start using the shared libasn1c, now that it has aper support
This commit is contained in:
parent
9da9697f55
commit
08de638790
|
@ -4,8 +4,8 @@ ASN1_FILES=HNBAP-CommonDataTypes.asn
|
||||||
ASN1TOSTRUCT:=$(ASN1_ROOT)/utils/asn1tostruct.py
|
ASN1TOSTRUCT:=$(ASN1_ROOT)/utils/asn1tostruct.py
|
||||||
#ASN1_SRCS:=$(patsubst
|
#ASN1_SRCS:=$(patsubst
|
||||||
|
|
||||||
CFLAGS=-g -Wall `pkg-config --cflags libosmocore libosmovty libosmogsm` -Iasn1c/
|
CFLAGS=-g -Wall `pkg-config --cflags libosmocore libosmovty libosmogsm libasn1c` -Iasn1c/
|
||||||
LDFLAGS=`pkg-config --libs libosmocore libosmovty libosmogsm` -lsctp
|
LDFLAGS=`pkg-config --libs libosmocore libosmovty libosmogsm libasn1c` -lsctp
|
||||||
|
|
||||||
all: hnbgw
|
all: hnbgw
|
||||||
|
|
||||||
|
|
243
src/asn1c/ANY.c
243
src/asn1c/ANY.c
|
@ -1,243 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <ANY.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
|
|
||||||
sizeof(ANY_t),
|
|
||||||
offsetof(ANY_t, _asn_ctx),
|
|
||||||
ASN_OSUBV_ANY
|
|
||||||
};
|
|
||||||
asn_TYPE_descriptor_t asn_DEF_ANY = {
|
|
||||||
"ANY",
|
|
||||||
"ANY",
|
|
||||||
OCTET_STRING_free,
|
|
||||||
OCTET_STRING_print,
|
|
||||||
asn_generic_no_constraint,
|
|
||||||
OCTET_STRING_decode_ber,
|
|
||||||
OCTET_STRING_encode_der,
|
|
||||||
OCTET_STRING_decode_xer_hex,
|
|
||||||
ANY_encode_xer,
|
|
||||||
OCTET_STRING_decode_uper,
|
|
||||||
OCTET_STRING_encode_uper,
|
|
||||||
OCTET_STRING_decode_aper,
|
|
||||||
OCTET_STRING_encode_aper,
|
|
||||||
0, /* Use generic outmost tag fetcher */
|
|
||||||
0, 0, 0, 0,
|
|
||||||
0, /* No PER visible constraints */
|
|
||||||
0, 0, /* No members */
|
|
||||||
&asn_DEF_ANY_specs,
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
|
|
||||||
if(flags & XER_F_CANONICAL) {
|
|
||||||
/*
|
|
||||||
* Canonical XER-encoding of ANY type is not supported.
|
|
||||||
*/
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Dump as binary */
|
|
||||||
return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
|
|
||||||
}
|
|
||||||
|
|
||||||
struct _callback_arg {
|
|
||||||
uint8_t *buffer;
|
|
||||||
size_t offset;
|
|
||||||
size_t size;
|
|
||||||
};
|
|
||||||
|
|
||||||
static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
|
|
||||||
|
|
||||||
int
|
|
||||||
ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
|
|
||||||
struct _callback_arg arg;
|
|
||||||
asn_enc_rval_t erval;
|
|
||||||
|
|
||||||
if(!st || !td) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!sptr) {
|
|
||||||
if(st->buf) FREEMEM(st->buf);
|
|
||||||
st->size = 0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
arg.offset = arg.size = 0;
|
|
||||||
arg.buffer = 0;
|
|
||||||
|
|
||||||
erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
|
|
||||||
if(erval.encoded == -1) {
|
|
||||||
if(arg.buffer) FREEMEM(arg.buffer);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
assert((size_t)erval.encoded == arg.offset);
|
|
||||||
|
|
||||||
if(st->buf) FREEMEM(st->buf);
|
|
||||||
st->buf = arg.buffer;
|
|
||||||
st->size = arg.offset;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
|
|
||||||
uint8_t *buffer = NULL;
|
|
||||||
ssize_t erval;
|
|
||||||
|
|
||||||
if(!st || !td) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!sptr) {
|
|
||||||
if(st->buf) FREEMEM(st->buf);
|
|
||||||
st->size = 0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
erval = aper_encode_to_new_buffer(td, td->per_constraints, sptr, (void**)&buffer);
|
|
||||||
|
|
||||||
if(erval == -1) {
|
|
||||||
if(buffer) FREEMEM(buffer);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
assert((size_t)erval > 0);
|
|
||||||
|
|
||||||
if(st->buf) FREEMEM(st->buf);
|
|
||||||
st->buf = buffer;
|
|
||||||
st->size = erval;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
ANY_t *
|
|
||||||
ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
|
|
||||||
ANY_t tmp;
|
|
||||||
ANY_t *st;
|
|
||||||
|
|
||||||
if(!td || !sptr) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&tmp, 0, sizeof(tmp));
|
|
||||||
|
|
||||||
if(ANY_fromType(&tmp, td, sptr)) return 0;
|
|
||||||
|
|
||||||
st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
|
|
||||||
if(st) {
|
|
||||||
*st = tmp;
|
|
||||||
return st;
|
|
||||||
} else {
|
|
||||||
FREEMEM(tmp.buf);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ANY_t *
|
|
||||||
ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr) {
|
|
||||||
ANY_t tmp;
|
|
||||||
ANY_t *st;
|
|
||||||
|
|
||||||
if(!td || !sptr) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&tmp, 0, sizeof(tmp));
|
|
||||||
|
|
||||||
if(ANY_fromType_aper(&tmp, td, sptr)) return 0;
|
|
||||||
|
|
||||||
st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
|
|
||||||
if(st) {
|
|
||||||
*st = tmp;
|
|
||||||
return st;
|
|
||||||
} else {
|
|
||||||
FREEMEM(tmp.buf);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
void *newst = 0;
|
|
||||||
|
|
||||||
if(!st || !td || !struct_ptr) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(st->buf == 0) {
|
|
||||||
/* Nothing to convert, make it empty. */
|
|
||||||
*struct_ptr = (void *)0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
*struct_ptr = newst;
|
|
||||||
return 0;
|
|
||||||
} else {
|
|
||||||
/* Remove possibly partially decoded data. */
|
|
||||||
ASN_STRUCT_FREE(*td, newst);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
ANY_to_type_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
void *newst = 0;
|
|
||||||
|
|
||||||
if(!st || !td || !struct_ptr) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(st->buf == 0) {
|
|
||||||
/* Nothing to convert, make it empty. */
|
|
||||||
*struct_ptr = (void *)0;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
rval = aper_decode(0, td, (void **)&newst, st->buf, st->size, 0, 0);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
*struct_ptr = newst;
|
|
||||||
return 0;
|
|
||||||
} else {
|
|
||||||
/* Remove possibly partially decoded data. */
|
|
||||||
ASN_STRUCT_FREE(*td, newst);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
|
|
||||||
struct _callback_arg *arg = (struct _callback_arg *)key;
|
|
||||||
|
|
||||||
if((arg->offset + size) >= arg->size) {
|
|
||||||
size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
|
|
||||||
void *p = REALLOC(arg->buffer, nsize);
|
|
||||||
if(!p) return -1;
|
|
||||||
arg->buffer = (uint8_t *)p;
|
|
||||||
arg->size = nsize;
|
|
||||||
}
|
|
||||||
|
|
||||||
memcpy(arg->buffer + arg->offset, buffer, size);
|
|
||||||
arg->offset += size;
|
|
||||||
assert(arg->offset < arg->size);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,51 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef ASN_TYPE_ANY_H
|
|
||||||
#define ASN_TYPE_ANY_H
|
|
||||||
|
|
||||||
#include <OCTET_STRING.h> /* Implemented via OCTET STRING type */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef struct ANY {
|
|
||||||
uint8_t *buf; /* BER-encoded ANY contents */
|
|
||||||
int size; /* Size of the above buffer */
|
|
||||||
|
|
||||||
asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */
|
|
||||||
} ANY_t;
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_ANY;
|
|
||||||
|
|
||||||
asn_struct_free_f ANY_free;
|
|
||||||
asn_struct_print_f ANY_print;
|
|
||||||
ber_type_decoder_f ANY_decode_ber;
|
|
||||||
der_type_encoder_f ANY_encode_der;
|
|
||||||
xer_type_encoder_f ANY_encode_xer;
|
|
||||||
|
|
||||||
/******************************
|
|
||||||
* Handy conversion routines. *
|
|
||||||
******************************/
|
|
||||||
|
|
||||||
/* Convert another ASN.1 type into the ANY. This implies DER encoding. */
|
|
||||||
int ANY_fromType(ANY_t *, asn_TYPE_descriptor_t *td, void *struct_ptr);
|
|
||||||
int ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr);
|
|
||||||
ANY_t *ANY_new_fromType(asn_TYPE_descriptor_t *td, void *struct_ptr);
|
|
||||||
ANY_t *ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr);
|
|
||||||
|
|
||||||
/* Convert the contents of the ANY type into the specified type. */
|
|
||||||
int ANY_to_type(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
|
|
||||||
int ANY_to_type_aper(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
|
|
||||||
|
|
||||||
#define ANY_fromBuf(s, buf, size) OCTET_STRING_fromBuf((s), (buf), (size))
|
|
||||||
#define ANY_new_fromBuf(buf, size) OCTET_STRING_new_fromBuf( \
|
|
||||||
&asn_DEF_ANY, (buf), (size))
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* ASN_TYPE_ANY_H */
|
|
|
@ -1,191 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <BIT_STRING.h>
|
|
||||||
#include <asn_internal.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* BIT STRING basic type description.
|
|
||||||
*/
|
|
||||||
static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
|
|
||||||
(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
|
|
||||||
};
|
|
||||||
static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
|
|
||||||
sizeof(BIT_STRING_t),
|
|
||||||
offsetof(BIT_STRING_t, _asn_ctx),
|
|
||||||
ASN_OSUBV_BIT
|
|
||||||
};
|
|
||||||
asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
|
|
||||||
"BIT STRING",
|
|
||||||
"BIT_STRING",
|
|
||||||
OCTET_STRING_free, /* Implemented in terms of OCTET STRING */
|
|
||||||
BIT_STRING_print,
|
|
||||||
BIT_STRING_constraint,
|
|
||||||
OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */
|
|
||||||
OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */
|
|
||||||
OCTET_STRING_decode_xer_binary,
|
|
||||||
BIT_STRING_encode_xer,
|
|
||||||
OCTET_STRING_decode_uper, /* Unaligned PER decoder */
|
|
||||||
OCTET_STRING_encode_uper, /* Unaligned PER encoder */
|
|
||||||
OCTET_STRING_decode_aper, /* Aligned PER decoder */
|
|
||||||
OCTET_STRING_encode_aper, /* Aligned PER encoder */
|
|
||||||
0, /* Use generic outmost tag fetcher */
|
|
||||||
asn_DEF_BIT_STRING_tags,
|
|
||||||
sizeof(asn_DEF_BIT_STRING_tags)
|
|
||||||
/ sizeof(asn_DEF_BIT_STRING_tags[0]),
|
|
||||||
asn_DEF_BIT_STRING_tags, /* Same as above */
|
|
||||||
sizeof(asn_DEF_BIT_STRING_tags)
|
|
||||||
/ sizeof(asn_DEF_BIT_STRING_tags[0]),
|
|
||||||
0, /* No PER visible constraints */
|
|
||||||
0, 0, /* No members */
|
|
||||||
&asn_DEF_BIT_STRING_specs
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
* BIT STRING generic constraint.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|
||||||
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
|
|
||||||
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
|
|
||||||
|
|
||||||
if(st && st->buf) {
|
|
||||||
if((st->size == 0 && st->bits_unused)
|
|
||||||
|| st->bits_unused < 0 || st->bits_unused > 7) {
|
|
||||||
_ASN_CTFAIL(app_key, td, sptr,
|
|
||||||
"%s: invalid padding byte (%s:%d)",
|
|
||||||
td->name, __FILE__, __LINE__);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
_ASN_CTFAIL(app_key, td, sptr,
|
|
||||||
"%s: value not given (%s:%d)",
|
|
||||||
td->name, __FILE__, __LINE__);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static char *_bit_pattern[16] = {
|
|
||||||
"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
|
|
||||||
"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
|
|
||||||
};
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
char scratch[128];
|
|
||||||
char *p = scratch;
|
|
||||||
char *scend = scratch + (sizeof(scratch) - 10);
|
|
||||||
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
|
|
||||||
int xcan = (flags & XER_F_CANONICAL);
|
|
||||||
uint8_t *buf;
|
|
||||||
uint8_t *end;
|
|
||||||
|
|
||||||
if(!st || !st->buf)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
buf = st->buf;
|
|
||||||
end = buf + st->size - 1; /* Last byte is special */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Binary dump
|
|
||||||
*/
|
|
||||||
for(; buf < end; buf++) {
|
|
||||||
int v = *buf;
|
|
||||||
int nline = xcan?0:(((buf - st->buf) % 8) == 0);
|
|
||||||
if(p >= scend || nline) {
|
|
||||||
er.encoded += p - scratch;
|
|
||||||
_ASN_CALLBACK(scratch, p - scratch);
|
|
||||||
p = scratch;
|
|
||||||
if(nline) _i_ASN_TEXT_INDENT(1, ilevel);
|
|
||||||
}
|
|
||||||
memcpy(p + 0, _bit_pattern[v >> 4], 4);
|
|
||||||
memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
|
|
||||||
p += 8;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!xcan && ((buf - st->buf) % 8) == 0)
|
|
||||||
_i_ASN_TEXT_INDENT(1, ilevel);
|
|
||||||
er.encoded += p - scratch;
|
|
||||||
_ASN_CALLBACK(scratch, p - scratch);
|
|
||||||
p = scratch;
|
|
||||||
|
|
||||||
if(buf == end) {
|
|
||||||
int v = *buf;
|
|
||||||
int ubits = st->bits_unused;
|
|
||||||
int i;
|
|
||||||
for(i = 7; i >= ubits; i--)
|
|
||||||
*p++ = (v & (1 << i)) ? 0x31 : 0x30;
|
|
||||||
er.encoded += p - scratch;
|
|
||||||
_ASN_CALLBACK(scratch, p - scratch);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
cb_failed:
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* BIT STRING specific contents printer.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
const char * const h2c = "0123456789ABCDEF";
|
|
||||||
char scratch[64];
|
|
||||||
const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
|
|
||||||
uint8_t *buf;
|
|
||||||
uint8_t *end;
|
|
||||||
char *p = scratch;
|
|
||||||
|
|
||||||
(void)td; /* Unused argument */
|
|
||||||
|
|
||||||
if(!st || !st->buf)
|
|
||||||
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
|
|
||||||
|
|
||||||
ilevel++;
|
|
||||||
buf = st->buf;
|
|
||||||
end = buf + st->size;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Hexadecimal dump.
|
|
||||||
*/
|
|
||||||
for(; buf < end; buf++) {
|
|
||||||
if((buf - st->buf) % 16 == 0 && (st->size > 16)
|
|
||||||
&& buf != st->buf) {
|
|
||||||
_i_INDENT(1);
|
|
||||||
/* Dump the string */
|
|
||||||
if(cb(scratch, p - scratch, app_key) < 0) return -1;
|
|
||||||
p = scratch;
|
|
||||||
}
|
|
||||||
*p++ = h2c[*buf >> 4];
|
|
||||||
*p++ = h2c[*buf & 0x0F];
|
|
||||||
*p++ = 0x20;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(p > scratch) {
|
|
||||||
p--; /* Eat the tailing space */
|
|
||||||
|
|
||||||
if((st->size > 16)) {
|
|
||||||
_i_INDENT(1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Dump the incomplete 16-bytes row */
|
|
||||||
if(cb(scratch, p - scratch, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,33 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _BIT_STRING_H_
|
|
||||||
#define _BIT_STRING_H_
|
|
||||||
|
|
||||||
#include <OCTET_STRING.h> /* Some help from OCTET STRING */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef struct BIT_STRING_s {
|
|
||||||
uint8_t *buf; /* BIT STRING body */
|
|
||||||
int size; /* Size of the above buffer */
|
|
||||||
|
|
||||||
int bits_unused;/* Unused trailing bits in the last octet (0..7) */
|
|
||||||
|
|
||||||
asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */
|
|
||||||
} BIT_STRING_t;
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
|
|
||||||
|
|
||||||
asn_struct_print_f BIT_STRING_print; /* Human-readable output */
|
|
||||||
asn_constr_check_f BIT_STRING_constraint;
|
|
||||||
xer_type_encoder_f BIT_STRING_encode_xer;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _BIT_STRING_H_ */
|
|
1465
src/asn1c/INTEGER.c
1465
src/asn1c/INTEGER.c
File diff suppressed because it is too large
Load Diff
|
@ -1,88 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _INTEGER_H_
|
|
||||||
#define _INTEGER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <asn_codecs_prim.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
|
|
||||||
|
|
||||||
/* Map with <tag> to integer value association */
|
|
||||||
typedef struct asn_INTEGER_enum_map_s {
|
|
||||||
int64_t nat_value; /* associated native integer value */
|
|
||||||
size_t enum_len; /* strlen("tag") */
|
|
||||||
const char *enum_name; /* "tag" */
|
|
||||||
} asn_INTEGER_enum_map_t;
|
|
||||||
|
|
||||||
/* This type describes an enumeration for INTEGER and ENUMERATED types */
|
|
||||||
typedef const struct asn_INTEGER_specifics_s {
|
|
||||||
const asn_INTEGER_enum_map_t *value2enum; /* N -> "tag"; sorted by N */
|
|
||||||
const unsigned int *enum2value; /* "tag" => N; sorted by tag */
|
|
||||||
int map_count; /* Elements in either map */
|
|
||||||
int extension; /* This map is extensible */
|
|
||||||
int strict_enumeration; /* Enumeration set is fixed */
|
|
||||||
int field_width; /* Size of native integer */
|
|
||||||
int field_unsigned; /* Signed=0, unsigned=1 */
|
|
||||||
} asn_INTEGER_specifics_t;
|
|
||||||
|
|
||||||
asn_struct_print_f INTEGER_print;
|
|
||||||
ber_type_decoder_f INTEGER_decode_ber;
|
|
||||||
der_type_encoder_f INTEGER_encode_der;
|
|
||||||
xer_type_decoder_f INTEGER_decode_xer;
|
|
||||||
xer_type_encoder_f INTEGER_encode_xer;
|
|
||||||
per_type_decoder_f INTEGER_decode_uper;
|
|
||||||
per_type_encoder_f INTEGER_encode_uper;
|
|
||||||
per_type_decoder_f INTEGER_decode_aper;
|
|
||||||
per_type_encoder_f INTEGER_encode_aper;
|
|
||||||
|
|
||||||
/***********************************
|
|
||||||
* Some handy conversion routines. *
|
|
||||||
***********************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns 0 if it was possible to convert, -1 otherwise.
|
|
||||||
* -1/EINVAL: Mandatory argument missing
|
|
||||||
* -1/ERANGE: Value encoded is out of range for long representation
|
|
||||||
* -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()).
|
|
||||||
*/
|
|
||||||
int asn_INTEGER2int64(const INTEGER_t *i, int64_t *l);
|
|
||||||
int asn_INTEGER2uint64(const INTEGER_t *i, uint64_t *l);
|
|
||||||
int asn_INTEGER2long(const INTEGER_t *i, long *l);
|
|
||||||
int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
|
|
||||||
int asn_int642INTEGER(INTEGER_t *i, int64_t l);
|
|
||||||
int asn_uint642INTEGER(INTEGER_t *i, uint64_t l);
|
|
||||||
int asn_long2INTEGER(INTEGER_t *i, long l);
|
|
||||||
int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
|
|
||||||
|
|
||||||
/* A a reified version of strtol(3) with nicer error reporting. */
|
|
||||||
enum asn_strtol_result_e {
|
|
||||||
ASN_STRTOL_ERROR_RANGE = -3, /* Input outside of numeric range for long type */
|
|
||||||
ASN_STRTOL_ERROR_INVAL = -2, /* Invalid data encountered (e.g., "+-") */
|
|
||||||
ASN_STRTOL_EXPECT_MORE = -1, /* More data expected (e.g. "+") */
|
|
||||||
ASN_STRTOL_OK = 0, /* Conversion succeded, number ends at (*end) */
|
|
||||||
ASN_STRTOL_EXTRA_DATA = 1, /* Conversion succeded, but the string has extra stuff */
|
|
||||||
};
|
|
||||||
enum asn_strtol_result_e asn_strtol_lim(const char *str, const char **end, long *l);
|
|
||||||
|
|
||||||
/* The asn_strtol is going to be DEPRECATED soon */
|
|
||||||
enum asn_strtol_result_e asn_strtol(const char *str, const char *end, long *l);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Convert the integer value into the corresponding enumeration map entry.
|
|
||||||
*/
|
|
||||||
const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _INTEGER_H_ */
|
|
|
@ -232,66 +232,6 @@ ASN_MODULE_HEADERS= \
|
||||||
PrivateMessage.h \
|
PrivateMessage.h \
|
||||||
IE.h
|
IE.h
|
||||||
|
|
||||||
ASN_MODULE_HEADERS+=ANY.h
|
|
||||||
ASN_MODULE_SOURCES+=ANY.c
|
|
||||||
ASN_MODULE_HEADERS+=INTEGER.h
|
|
||||||
ASN_MODULE_HEADERS+=NativeEnumerated.h
|
|
||||||
ASN_MODULE_SOURCES+=INTEGER.c
|
|
||||||
ASN_MODULE_SOURCES+=NativeEnumerated.c
|
|
||||||
ASN_MODULE_HEADERS+=NativeInteger.h
|
|
||||||
ASN_MODULE_SOURCES+=NativeInteger.c
|
|
||||||
ASN_MODULE_HEADERS+=OBJECT_IDENTIFIER.h
|
|
||||||
ASN_MODULE_SOURCES+=OBJECT_IDENTIFIER.c
|
|
||||||
ASN_MODULE_HEADERS+=asn_SEQUENCE_OF.h
|
|
||||||
ASN_MODULE_SOURCES+=asn_SEQUENCE_OF.c
|
|
||||||
ASN_MODULE_HEADERS+=asn_SET_OF.h
|
|
||||||
ASN_MODULE_SOURCES+=asn_SET_OF.c
|
|
||||||
ASN_MODULE_HEADERS+=constr_CHOICE.h
|
|
||||||
ASN_MODULE_SOURCES+=constr_CHOICE.c
|
|
||||||
ASN_MODULE_HEADERS+=constr_SEQUENCE.h
|
|
||||||
ASN_MODULE_SOURCES+=constr_SEQUENCE.c
|
|
||||||
ASN_MODULE_HEADERS+=constr_SEQUENCE_OF.h
|
|
||||||
ASN_MODULE_SOURCES+=constr_SEQUENCE_OF.c
|
|
||||||
ASN_MODULE_HEADERS+=constr_SET_OF.h
|
|
||||||
ASN_MODULE_SOURCES+=constr_SET_OF.c
|
|
||||||
ASN_MODULE_HEADERS+=asn_application.h
|
|
||||||
ASN_MODULE_HEADERS+=asn_system.h
|
|
||||||
ASN_MODULE_HEADERS+=asn_codecs.h
|
|
||||||
ASN_MODULE_HEADERS+=asn_internal.h
|
|
||||||
ASN_MODULE_HEADERS+=OCTET_STRING.h
|
|
||||||
ASN_MODULE_SOURCES+=OCTET_STRING.c
|
|
||||||
ASN_MODULE_HEADERS+=BIT_STRING.h
|
|
||||||
ASN_MODULE_SOURCES+=BIT_STRING.c
|
|
||||||
ASN_MODULE_SOURCES+=asn_codecs_prim.c
|
|
||||||
ASN_MODULE_HEADERS+=asn_codecs_prim.h
|
|
||||||
ASN_MODULE_HEADERS+=ber_tlv_length.h
|
|
||||||
ASN_MODULE_SOURCES+=ber_tlv_length.c
|
|
||||||
ASN_MODULE_HEADERS+=ber_tlv_tag.h
|
|
||||||
ASN_MODULE_SOURCES+=ber_tlv_tag.c
|
|
||||||
ASN_MODULE_HEADERS+=ber_decoder.h
|
|
||||||
ASN_MODULE_SOURCES+=ber_decoder.c
|
|
||||||
ASN_MODULE_HEADERS+=der_encoder.h
|
|
||||||
ASN_MODULE_SOURCES+=der_encoder.c
|
|
||||||
ASN_MODULE_HEADERS+=constr_TYPE.h
|
|
||||||
ASN_MODULE_SOURCES+=constr_TYPE.c
|
|
||||||
ASN_MODULE_HEADERS+=constraints.h
|
|
||||||
ASN_MODULE_SOURCES+=constraints.c
|
|
||||||
ASN_MODULE_HEADERS+=xer_support.h
|
|
||||||
ASN_MODULE_SOURCES+=xer_support.c
|
|
||||||
ASN_MODULE_HEADERS+=xer_decoder.h
|
|
||||||
ASN_MODULE_SOURCES+=xer_decoder.c
|
|
||||||
ASN_MODULE_HEADERS+=xer_encoder.h
|
|
||||||
ASN_MODULE_SOURCES+=xer_encoder.c
|
|
||||||
ASN_MODULE_HEADERS+=per_support.h
|
|
||||||
ASN_MODULE_SOURCES+=per_support.c
|
|
||||||
ASN_MODULE_HEADERS+=per_decoder.h
|
|
||||||
ASN_MODULE_SOURCES+=per_decoder.c
|
|
||||||
ASN_MODULE_HEADERS+=per_encoder.h
|
|
||||||
ASN_MODULE_SOURCES+=per_encoder.c
|
|
||||||
ASN_MODULE_HEADERS+=per_opentype.h
|
|
||||||
ASN_MODULE_SOURCES+=per_opentype.c
|
|
||||||
|
|
||||||
|
|
||||||
lib_LTLIBRARIES=libsomething.la
|
lib_LTLIBRARIES=libsomething.la
|
||||||
libsomething_la_SOURCES=$(ASN_MODULE_SOURCES) $(ASN_MODULE_HEADERS)
|
libsomething_la_SOURCES=$(ASN_MODULE_SOURCES) $(ASN_MODULE_HEADERS)
|
||||||
|
|
||||||
|
@ -318,5 +258,5 @@ clean:
|
||||||
regen: regenerate-from-asn1-source
|
regen: regenerate-from-asn1-source
|
||||||
|
|
||||||
regenerate-from-asn1-source:
|
regenerate-from-asn1-source:
|
||||||
asn1c -gen-PER -fnative-types -fskeletons-copy ../../asn1/hnbap/HNBAP-CommonDataTypes.asn ../../asn1/hnbap/HNBAP-Constants.asn ../../asn1/hnbap/HNBAP-IEs.asn ../../asn1/hnbap/HNBAP-PDU.asn
|
asn1c -gen-PER -fnative-types ../../asn1/hnbap/HNBAP-CommonDataTypes.asn ../../asn1/hnbap/HNBAP-Constants.asn ../../asn1/hnbap/HNBAP-IEs.asn ../../asn1/hnbap/HNBAP-PDU.asn
|
||||||
|
|
||||||
|
|
|
@ -1,333 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* Read the NativeInteger.h for the explanation wrt. differences between
|
|
||||||
* INTEGER and NativeInteger.
|
|
||||||
* Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
|
|
||||||
* implementation deals with the standard (machine-specific) representation
|
|
||||||
* of them instead of using the platform-independent buffer.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <NativeEnumerated.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* NativeEnumerated basic type description.
|
|
||||||
*/
|
|
||||||
static const ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = {
|
|
||||||
(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
|
|
||||||
};
|
|
||||||
asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = {
|
|
||||||
"ENUMERATED", /* The ASN.1 type is still ENUMERATED */
|
|
||||||
"ENUMERATED",
|
|
||||||
NativeInteger_free,
|
|
||||||
NativeInteger_print,
|
|
||||||
asn_generic_no_constraint,
|
|
||||||
NativeInteger_decode_ber,
|
|
||||||
NativeInteger_encode_der,
|
|
||||||
NativeInteger_decode_xer,
|
|
||||||
NativeEnumerated_encode_xer,
|
|
||||||
NativeEnumerated_decode_uper,
|
|
||||||
NativeEnumerated_encode_uper,
|
|
||||||
NativeEnumerated_decode_aper,
|
|
||||||
NativeEnumerated_encode_aper,
|
|
||||||
0, /* Use generic outmost tag fetcher */
|
|
||||||
asn_DEF_NativeEnumerated_tags,
|
|
||||||
sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
|
|
||||||
asn_DEF_NativeEnumerated_tags, /* Same as above */
|
|
||||||
sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
|
|
||||||
0, /* No PER visible constraints */
|
|
||||||
0, 0, /* No members */
|
|
||||||
0 /* No specifics */
|
|
||||||
};
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
const long *native = (const long *)sptr;
|
|
||||||
const asn_INTEGER_enum_map_t *el;
|
|
||||||
|
|
||||||
(void)ilevel;
|
|
||||||
(void)flags;
|
|
||||||
|
|
||||||
if(!native) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
el = INTEGER_map_value2enum(specs, *native);
|
|
||||||
if(el) {
|
|
||||||
size_t srcsize = el->enum_len + 5;
|
|
||||||
char *src = (char *)alloca(srcsize);
|
|
||||||
|
|
||||||
er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
|
|
||||||
assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
|
|
||||||
if(cb(src, er.encoded, app_key) < 0) _ASN_ENCODE_FAILED;
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
} else {
|
|
||||||
ASN_DEBUG("ASN.1 forbids dealing with "
|
|
||||||
"unknown value of ENUMERATED type");
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
|
|
||||||
void **sptr, asn_per_data_t *pd) {
|
|
||||||
asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_dec_rval_t rval = { RC_OK, 0 };
|
|
||||||
long *native = (long *)*sptr;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
long value;
|
|
||||||
|
|
||||||
(void)opt_codec_ctx;
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->value;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->value;
|
|
||||||
else _ASN_DECODE_FAILED; /* Mandatory! */
|
|
||||||
if(!specs) _ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
if(!native) {
|
|
||||||
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(!native) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
|
|
||||||
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
int inext = per_get_few_bits(pd, 1);
|
|
||||||
if(inext < 0) _ASN_DECODE_STARVED;
|
|
||||||
if(inext) ct = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->range_bits >= 0) {
|
|
||||||
value = per_get_few_bits(pd, ct->range_bits);
|
|
||||||
if(value < 0) _ASN_DECODE_STARVED;
|
|
||||||
if(value >= (specs->extension
|
|
||||||
? specs->extension - 1 : specs->map_count))
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
} else {
|
|
||||||
if(!specs->extension)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
/*
|
|
||||||
* X.691, #10.6: normally small non-negative whole number;
|
|
||||||
*/
|
|
||||||
value = uper_get_nsnnwn(pd);
|
|
||||||
if(value < 0) _ASN_DECODE_STARVED;
|
|
||||||
value += specs->extension - 1;
|
|
||||||
if(value >= specs->map_count)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
*native = specs->value2enum[value].nat_value;
|
|
||||||
ASN_DEBUG("Decoded %s = %ld", td->name, *native);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeEnumerated_decode_aper(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
|
|
||||||
void **sptr, asn_per_data_t *pd) {
|
|
||||||
asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_dec_rval_t rval = { RC_OK, 0 };
|
|
||||||
long *native = (long *)*sptr;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
long value;
|
|
||||||
|
|
||||||
(void)opt_codec_ctx;
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->value;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->value;
|
|
||||||
else _ASN_DECODE_FAILED; /* Mandatory! */
|
|
||||||
if(!specs) _ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
if(!native) {
|
|
||||||
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(!native) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
|
|
||||||
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
int inext = per_get_few_bits(pd, 1);
|
|
||||||
if(inext < 0) _ASN_DECODE_STARVED;
|
|
||||||
if(inext) ct = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->range_bits >= 0) {
|
|
||||||
value = per_get_few_bits(pd, ct->range_bits);
|
|
||||||
if(value < 0) _ASN_DECODE_STARVED;
|
|
||||||
if(value >= (specs->extension
|
|
||||||
? specs->extension - 1 : specs->map_count))
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
} else {
|
|
||||||
if(!specs->extension)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
/*
|
|
||||||
* X.691, #10.6: normally small non-negative whole number;
|
|
||||||
*/
|
|
||||||
value = uper_get_nsnnwn(pd);
|
|
||||||
if(value < 0) _ASN_DECODE_STARVED;
|
|
||||||
value += specs->extension - 1;
|
|
||||||
if(value >= specs->map_count)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
*native = specs->value2enum[value].nat_value;
|
|
||||||
ASN_DEBUG("Decoded %s = %ld", td->name, *native);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
NativeEnumerated__compar_value2enum(const void *ap, const void *bp) {
|
|
||||||
const asn_INTEGER_enum_map_t *a = ap;
|
|
||||||
const asn_INTEGER_enum_map_t *b = bp;
|
|
||||||
if(a->nat_value == b->nat_value)
|
|
||||||
return 0;
|
|
||||||
if(a->nat_value < b->nat_value)
|
|
||||||
return -1;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
long native, value;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
int inext = 0;
|
|
||||||
asn_INTEGER_enum_map_t key;
|
|
||||||
const asn_INTEGER_enum_map_t *kf;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
if(!specs) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->value;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->value;
|
|
||||||
else _ASN_ENCODE_FAILED; /* Mandatory! */
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
native = *(long *)sptr;
|
|
||||||
if(native < 0) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
key.nat_value = native;
|
|
||||||
kf = bsearch(&key, specs->value2enum, specs->map_count,
|
|
||||||
sizeof(key), NativeEnumerated__compar_value2enum);
|
|
||||||
if(!kf) {
|
|
||||||
ASN_DEBUG("No element corresponds to %ld", native);
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
value = kf - specs->value2enum;
|
|
||||||
|
|
||||||
if(ct->range_bits >= 0) {
|
|
||||||
int cmpWith = specs->extension
|
|
||||||
? specs->extension - 1 : specs->map_count;
|
|
||||||
if(value >= cmpWith)
|
|
||||||
inext = 1;
|
|
||||||
}
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
if(per_put_few_bits(po, inext, 1))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
if(inext) ct = 0;
|
|
||||||
} else if(inext) {
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->range_bits >= 0) {
|
|
||||||
if(per_put_few_bits(po, value, ct->range_bits))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!specs->extension)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* X.691, #10.6: normally small non-negative whole number;
|
|
||||||
*/
|
|
||||||
ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
|
|
||||||
value, specs->extension, inext,
|
|
||||||
value - (inext ? (specs->extension - 1) : 0));
|
|
||||||
if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeEnumerated_encode_aper(asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
long native, value;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
int inext = 0;
|
|
||||||
asn_INTEGER_enum_map_t key;
|
|
||||||
asn_INTEGER_enum_map_t *kf;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
if(!specs) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->value;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->value;
|
|
||||||
else _ASN_ENCODE_FAILED; /* Mandatory! */
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
native = *(long *)sptr;
|
|
||||||
if(native < 0) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
key.nat_value = native;
|
|
||||||
kf = bsearch(&key, specs->value2enum, specs->map_count,
|
|
||||||
sizeof(key), NativeEnumerated__compar_value2enum);
|
|
||||||
if(!kf) {
|
|
||||||
ASN_DEBUG("No element corresponds to %ld", native);
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
value = kf - specs->value2enum;
|
|
||||||
|
|
||||||
if(ct->range_bits >= 0) {
|
|
||||||
int cmpWith = specs->extension
|
|
||||||
? specs->extension - 1 : specs->map_count;
|
|
||||||
if(value >= cmpWith)
|
|
||||||
inext = 1;
|
|
||||||
}
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
if(per_put_few_bits(po, inext, 1))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
if(inext) ct = 0;
|
|
||||||
} else if(inext) {
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->range_bits >= 0) {
|
|
||||||
if(per_put_few_bits(po, value, ct->range_bits))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!specs->extension)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* X.691, #10.6: normally small non-negative whole number;
|
|
||||||
*/
|
|
||||||
ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
|
|
||||||
value, specs->extension, inext,
|
|
||||||
value - (inext ? (specs->extension - 1) : 0));
|
|
||||||
if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,34 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* This type differs from the standard ENUMERATED in that it is modelled using
|
|
||||||
* the fixed machine type (long, int, short), so it can hold only values of
|
|
||||||
* limited length. There is no type (i.e., NativeEnumerated_t, any integer type
|
|
||||||
* will do).
|
|
||||||
* This type may be used when integer range is limited by subtype constraints.
|
|
||||||
*/
|
|
||||||
#ifndef _NativeEnumerated_H_
|
|
||||||
#define _NativeEnumerated_H_
|
|
||||||
|
|
||||||
#include <NativeInteger.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated;
|
|
||||||
|
|
||||||
xer_type_encoder_f NativeEnumerated_encode_xer;
|
|
||||||
per_type_decoder_f NativeEnumerated_decode_uper;
|
|
||||||
per_type_encoder_f NativeEnumerated_encode_uper;
|
|
||||||
per_type_decoder_f NativeEnumerated_decode_aper;
|
|
||||||
per_type_encoder_f NativeEnumerated_encode_aper;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _NativeEnumerated_H_ */
|
|
|
@ -1,396 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* Read the NativeInteger.h for the explanation wrt. differences between
|
|
||||||
* INTEGER and NativeInteger.
|
|
||||||
* Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
|
|
||||||
* implementation deals with the standard (machine-specific) representation
|
|
||||||
* of them instead of using the platform-independent buffer.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <NativeInteger.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* NativeInteger basic type description.
|
|
||||||
*/
|
|
||||||
static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
|
|
||||||
(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
|
|
||||||
};
|
|
||||||
asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
|
|
||||||
"INTEGER", /* The ASN.1 type is still INTEGER */
|
|
||||||
"INTEGER",
|
|
||||||
NativeInteger_free,
|
|
||||||
NativeInteger_print,
|
|
||||||
asn_generic_no_constraint,
|
|
||||||
NativeInteger_decode_ber,
|
|
||||||
NativeInteger_encode_der,
|
|
||||||
NativeInteger_decode_xer,
|
|
||||||
NativeInteger_encode_xer,
|
|
||||||
NativeInteger_decode_uper, /* Unaligned PER decoder */
|
|
||||||
NativeInteger_encode_uper, /* Unaligned PER encoder */
|
|
||||||
NativeInteger_decode_aper, /* Aligned PER decoder */
|
|
||||||
NativeInteger_encode_aper, /* Aligned PER encoder */
|
|
||||||
0, /* Use generic outmost tag fetcher */
|
|
||||||
asn_DEF_NativeInteger_tags,
|
|
||||||
sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
|
|
||||||
asn_DEF_NativeInteger_tags, /* Same as above */
|
|
||||||
sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
|
|
||||||
0, /* No PER visible constraints */
|
|
||||||
0, 0, /* No members */
|
|
||||||
0 /* No specifics */
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decode INTEGER type.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
long *native = (long *)*nint_ptr;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
ber_tlv_len_t length;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If the structure is not there, allocate it.
|
|
||||||
*/
|
|
||||||
if(native == NULL) {
|
|
||||||
native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(native == NULL) {
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
rval.consumed = 0;
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
|
|
||||||
td->name, tag_mode);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check tags.
|
|
||||||
*/
|
|
||||||
rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
|
|
||||||
tag_mode, 0, &length, 0);
|
|
||||||
if(rval.code != RC_OK)
|
|
||||||
return rval;
|
|
||||||
|
|
||||||
ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure we have this length.
|
|
||||||
*/
|
|
||||||
buf_ptr = ((const char *)buf_ptr) + rval.consumed;
|
|
||||||
size -= rval.consumed;
|
|
||||||
if(length > (ber_tlv_len_t)size) {
|
|
||||||
rval.code = RC_WMORE;
|
|
||||||
rval.consumed = 0;
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* ASN.1 encoded INTEGER: buf_ptr, length
|
|
||||||
* Fill the native, at the same time checking for overflow.
|
|
||||||
* If overflow occured, return with RC_FAIL.
|
|
||||||
*/
|
|
||||||
{
|
|
||||||
INTEGER_t tmp;
|
|
||||||
union {
|
|
||||||
const void *constbuf;
|
|
||||||
void *nonconstbuf;
|
|
||||||
} unconst_buf;
|
|
||||||
long l;
|
|
||||||
|
|
||||||
unconst_buf.constbuf = buf_ptr;
|
|
||||||
tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
|
|
||||||
tmp.size = length;
|
|
||||||
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_INTEGER2ulong(&tmp, (unsigned long *)&l) /* sic */
|
|
||||||
: asn_INTEGER2long(&tmp, &l)) {
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
rval.consumed = 0;
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
*native = l;
|
|
||||||
}
|
|
||||||
|
|
||||||
rval.code = RC_OK;
|
|
||||||
rval.consumed += length;
|
|
||||||
|
|
||||||
ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
|
|
||||||
(long)rval.consumed, (long)length, td->name, (long)*native);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode the NativeInteger using the standard INTEGER type DER encoder.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
|
|
||||||
int tag_mode, ber_tlv_tag_t tag,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
unsigned long native = *(unsigned long *)ptr; /* Disable sign ext. */
|
|
||||||
asn_enc_rval_t erval;
|
|
||||||
INTEGER_t tmp;
|
|
||||||
|
|
||||||
#ifdef WORDS_BIGENDIAN /* Opportunistic optimization */
|
|
||||||
|
|
||||||
tmp.buf = (uint8_t *)&native;
|
|
||||||
tmp.size = sizeof(native);
|
|
||||||
|
|
||||||
#else /* Works even if WORDS_BIGENDIAN is not set where should've been */
|
|
||||||
uint8_t buf[sizeof(native)];
|
|
||||||
uint8_t *p;
|
|
||||||
|
|
||||||
/* Prepare a fake INTEGER */
|
|
||||||
for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
|
|
||||||
*p = (uint8_t)native;
|
|
||||||
|
|
||||||
tmp.buf = buf;
|
|
||||||
tmp.size = sizeof(buf);
|
|
||||||
#endif /* WORDS_BIGENDIAN */
|
|
||||||
|
|
||||||
/* Encode fake INTEGER */
|
|
||||||
erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
|
|
||||||
if(erval.encoded == -1) {
|
|
||||||
assert(erval.structure_ptr == &tmp);
|
|
||||||
erval.structure_ptr = ptr;
|
|
||||||
}
|
|
||||||
return erval;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decode the chunk of XML text encoding INTEGER.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
|
|
||||||
const void *buf_ptr, size_t size) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
INTEGER_t st;
|
|
||||||
void *st_ptr = (void *)&st;
|
|
||||||
long *native = (long *)*sptr;
|
|
||||||
|
|
||||||
if(!native) {
|
|
||||||
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(!native) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&st, 0, sizeof(st));
|
|
||||||
rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr,
|
|
||||||
opt_mname, buf_ptr, size);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
long l;
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_INTEGER2ulong(&st, (unsigned long *)&l) /* sic */
|
|
||||||
: asn_INTEGER2long(&st, &l)) {
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
rval.consumed = 0;
|
|
||||||
} else {
|
|
||||||
*native = l;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/*
|
|
||||||
* Cannot restart from the middle;
|
|
||||||
* there is no place to save state in the native type.
|
|
||||||
* Request a continuation from the very beginning.
|
|
||||||
*/
|
|
||||||
rval.consumed = 0;
|
|
||||||
}
|
|
||||||
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
char scratch[32]; /* Enough for 64-bit int */
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
const long *native = (const long *)sptr;
|
|
||||||
|
|
||||||
(void)ilevel;
|
|
||||||
(void)flags;
|
|
||||||
|
|
||||||
if(!native) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
er.encoded = snprintf(scratch, sizeof(scratch),
|
|
||||||
(specs && specs->field_unsigned)
|
|
||||||
? "%lu" : "%ld", *native);
|
|
||||||
if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
|
|
||||||
|| cb(scratch, er.encoded, app_key) < 0)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
long *native = (long *)*sptr;
|
|
||||||
INTEGER_t tmpint;
|
|
||||||
void *tmpintptr = &tmpint;
|
|
||||||
|
|
||||||
(void)opt_codec_ctx;
|
|
||||||
ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
|
|
||||||
|
|
||||||
if(!native) {
|
|
||||||
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(!native) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&tmpint, 0, sizeof tmpint);
|
|
||||||
rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
|
|
||||||
&tmpintptr, pd);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
|
|
||||||
: asn_INTEGER2long(&tmpint, native))
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
else
|
|
||||||
ASN_DEBUG("NativeInteger %s got value %ld",
|
|
||||||
td->name, *native);
|
|
||||||
}
|
|
||||||
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
NativeInteger_decode_aper(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
long *native = (long *)*sptr;
|
|
||||||
INTEGER_t tmpint;
|
|
||||||
void *tmpintptr = &tmpint;
|
|
||||||
|
|
||||||
(void)opt_codec_ctx;
|
|
||||||
ASN_DEBUG("Decoding NativeInteger %s (APER)", td->name);
|
|
||||||
|
|
||||||
if(!native) {
|
|
||||||
native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
|
|
||||||
if(!native) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&tmpint, 0, sizeof tmpint);
|
|
||||||
rval = INTEGER_decode_aper(opt_codec_ctx, td, constraints,
|
|
||||||
&tmpintptr, pd);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
|
|
||||||
: asn_INTEGER2long(&tmpint, native))
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
else
|
|
||||||
ASN_DEBUG("NativeInteger %s got value %ld",
|
|
||||||
td->name, *native);
|
|
||||||
}
|
|
||||||
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
long native;
|
|
||||||
INTEGER_t tmpint;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
native = *(long *)sptr;
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
|
|
||||||
|
|
||||||
memset(&tmpint, 0, sizeof(tmpint));
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_ulong2INTEGER(&tmpint, native)
|
|
||||||
: asn_long2INTEGER(&tmpint, native))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
er = INTEGER_encode_uper(td, constraints, &tmpint, po);
|
|
||||||
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
|
|
||||||
return er;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
NativeInteger_encode_aper(
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
long native;
|
|
||||||
INTEGER_t tmpint;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
native = *(long *)sptr;
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding NativeInteger %s %ld (APER)", td->name, native);
|
|
||||||
|
|
||||||
memset(&tmpint, 0, sizeof(tmpint));
|
|
||||||
if((specs&&specs->field_unsigned)
|
|
||||||
? asn_ulong2INTEGER(&tmpint, native)
|
|
||||||
: asn_long2INTEGER(&tmpint, native))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
er = INTEGER_encode_aper(td, constraints, &tmpint, po);
|
|
||||||
ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
|
|
||||||
return er;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* INTEGER specific human-readable output.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
|
|
||||||
const long *native = (const long *)sptr;
|
|
||||||
char scratch[32]; /* Enough for 64-bit int */
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
(void)td; /* Unused argument */
|
|
||||||
(void)ilevel; /* Unused argument */
|
|
||||||
|
|
||||||
if(native) {
|
|
||||||
ret = snprintf(scratch, sizeof(scratch),
|
|
||||||
(specs && specs->field_unsigned)
|
|
||||||
? "%lu" : "%ld", *native);
|
|
||||||
assert(ret > 0 && (size_t)ret < sizeof(scratch));
|
|
||||||
return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
|
|
||||||
} else {
|
|
||||||
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
|
|
||||||
|
|
||||||
if(!td || !ptr)
|
|
||||||
return;
|
|
||||||
|
|
||||||
ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
|
|
||||||
td->name, contents_only, ptr);
|
|
||||||
|
|
||||||
if(!contents_only) {
|
|
||||||
FREEMEM(ptr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,39 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* This type differs from the standard INTEGER in that it is modelled using
|
|
||||||
* the fixed machine type (long, int, short), so it can hold only values of
|
|
||||||
* limited length. There is no type (i.e., NativeInteger_t, any integer type
|
|
||||||
* will do).
|
|
||||||
* This type may be used when integer range is limited by subtype constraints.
|
|
||||||
*/
|
|
||||||
#ifndef _NativeInteger_H_
|
|
||||||
#define _NativeInteger_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <INTEGER.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
|
|
||||||
|
|
||||||
asn_struct_free_f NativeInteger_free;
|
|
||||||
asn_struct_print_f NativeInteger_print;
|
|
||||||
ber_type_decoder_f NativeInteger_decode_ber;
|
|
||||||
der_type_encoder_f NativeInteger_encode_der;
|
|
||||||
xer_type_decoder_f NativeInteger_decode_xer;
|
|
||||||
xer_type_encoder_f NativeInteger_encode_xer;
|
|
||||||
per_type_decoder_f NativeInteger_decode_uper;
|
|
||||||
per_type_encoder_f NativeInteger_encode_uper;
|
|
||||||
per_type_decoder_f NativeInteger_decode_aper;
|
|
||||||
per_type_encoder_f NativeInteger_encode_aper;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _NativeInteger_H_ */
|
|
|
@ -1,766 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <INTEGER.h>
|
|
||||||
#include <OBJECT_IDENTIFIER.h>
|
|
||||||
#include <OCTET_STRING.h>
|
|
||||||
#include <limits.h> /* for CHAR_BIT */
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* OBJECT IDENTIFIER basic type description.
|
|
||||||
*/
|
|
||||||
static const ber_tlv_tag_t asn_DEF_OBJECT_IDENTIFIER_tags[] = {
|
|
||||||
(ASN_TAG_CLASS_UNIVERSAL | (6 << 2))
|
|
||||||
};
|
|
||||||
asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER = {
|
|
||||||
"OBJECT IDENTIFIER",
|
|
||||||
"OBJECT_IDENTIFIER",
|
|
||||||
ASN__PRIMITIVE_TYPE_free,
|
|
||||||
OBJECT_IDENTIFIER_print,
|
|
||||||
OBJECT_IDENTIFIER_constraint,
|
|
||||||
ber_decode_primitive,
|
|
||||||
der_encode_primitive,
|
|
||||||
OBJECT_IDENTIFIER_decode_xer,
|
|
||||||
OBJECT_IDENTIFIER_encode_xer,
|
|
||||||
OCTET_STRING_decode_uper,
|
|
||||||
OCTET_STRING_encode_uper,
|
|
||||||
OCTET_STRING_decode_aper,
|
|
||||||
OCTET_STRING_encode_aper,
|
|
||||||
0, /* Use generic outmost tag fetcher */
|
|
||||||
asn_DEF_OBJECT_IDENTIFIER_tags,
|
|
||||||
sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
|
|
||||||
/ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
|
|
||||||
asn_DEF_OBJECT_IDENTIFIER_tags, /* Same as above */
|
|
||||||
sizeof(asn_DEF_OBJECT_IDENTIFIER_tags)
|
|
||||||
/ sizeof(asn_DEF_OBJECT_IDENTIFIER_tags[0]),
|
|
||||||
0, /* No PER visible constraints */
|
|
||||||
0, 0, /* No members */
|
|
||||||
0 /* No specifics */
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
|
|
||||||
asn_app_constraint_failed_f *ctfailcb, void *app_key) {
|
|
||||||
const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
|
|
||||||
|
|
||||||
if(st && st->buf) {
|
|
||||||
if(st->size < 1) {
|
|
||||||
_ASN_CTFAIL(app_key, td, sptr,
|
|
||||||
"%s: at least one numerical value "
|
|
||||||
"expected (%s:%d)",
|
|
||||||
td->name, __FILE__, __LINE__);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
_ASN_CTFAIL(app_key, td, sptr,
|
|
||||||
"%s: value not given (%s:%d)",
|
|
||||||
td->name, __FILE__, __LINE__);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen, signed int add, void *rvbufp, unsigned int rvsize) {
|
|
||||||
unsigned LE GCC_NOTUSED = 1; /* Little endian (x86) */
|
|
||||||
const uint8_t *arcend = arcbuf + arclen; /* End of arc */
|
|
||||||
unsigned int cache = 0; /* No more than 14 significant bits */
|
|
||||||
unsigned char *rvbuf = (unsigned char *)rvbufp;
|
|
||||||
unsigned char *rvstart = rvbuf; /* Original start of the value buffer */
|
|
||||||
int inc; /* Return value growth direction */
|
|
||||||
|
|
||||||
rvsize *= CHAR_BIT; /* bytes to bits */
|
|
||||||
arclen *= 7; /* bytes to bits */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The arc has the number of bits
|
|
||||||
* cannot be represented using supplied return value type.
|
|
||||||
*/
|
|
||||||
if(arclen > rvsize) {
|
|
||||||
if(arclen > (rvsize + CHAR_BIT)) {
|
|
||||||
errno = ERANGE; /* Overflow */
|
|
||||||
return -1;
|
|
||||||
} else {
|
|
||||||
/*
|
|
||||||
* Even if the number of bits in the arc representation
|
|
||||||
* is higher than the width of supplied * return value
|
|
||||||
* type, there is still possible to fit it when there
|
|
||||||
* are few unused high bits in the arc value
|
|
||||||
* representaion.
|
|
||||||
*
|
|
||||||
* Moreover, there is a possibility that the
|
|
||||||
* number could actually fit the arc space, given
|
|
||||||
* that add is negative, but we don't handle
|
|
||||||
* such "temporary lack of precision" situation here.
|
|
||||||
* May be considered as a bug.
|
|
||||||
*/
|
|
||||||
uint8_t mask = (0xff << (7-(arclen - rvsize))) & 0x7f;
|
|
||||||
if((*arcbuf & mask)) {
|
|
||||||
errno = ERANGE; /* Overflow */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
/* Fool the routine computing unused bits */
|
|
||||||
arclen -= 7;
|
|
||||||
cache = *arcbuf & 0x7f;
|
|
||||||
arcbuf++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Faster path for common size */
|
|
||||||
if(rvsize == (CHAR_BIT * sizeof(unsigned long))) {
|
|
||||||
unsigned long accum;
|
|
||||||
/* Gather all bits into the accumulator */
|
|
||||||
for(accum = cache; arcbuf < arcend; arcbuf++)
|
|
||||||
accum = (accum << 7) | (*arcbuf & ~0x80);
|
|
||||||
if(accum < (unsigned)-add) {
|
|
||||||
errno = ERANGE; /* Overflow */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
*(unsigned long *)(void *)rvbuf = accum + add; /* alignment OK! */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifndef WORDS_BIGENDIAN
|
|
||||||
if(*(unsigned char *)&LE) { /* Little endian (x86) */
|
|
||||||
/* "Convert" to big endian */
|
|
||||||
rvbuf += rvsize / CHAR_BIT - 1;
|
|
||||||
rvstart--;
|
|
||||||
inc = -1; /* Descending */
|
|
||||||
} else
|
|
||||||
#endif /* !WORDS_BIGENDIAN */
|
|
||||||
inc = +1; /* Big endian is known [at compile time] */
|
|
||||||
|
|
||||||
{
|
|
||||||
int bits; /* typically no more than 3-4 bits */
|
|
||||||
|
|
||||||
/* Clear the high unused bits */
|
|
||||||
for(bits = rvsize - arclen;
|
|
||||||
bits > CHAR_BIT;
|
|
||||||
rvbuf += inc, bits -= CHAR_BIT)
|
|
||||||
*rvbuf = 0;
|
|
||||||
|
|
||||||
/* Fill the body of a value */
|
|
||||||
for(; arcbuf < arcend; arcbuf++) {
|
|
||||||
cache = (cache << 7) | (*arcbuf & 0x7f);
|
|
||||||
bits += 7;
|
|
||||||
if(bits >= CHAR_BIT) {
|
|
||||||
bits -= CHAR_BIT;
|
|
||||||
*rvbuf = (cache >> bits);
|
|
||||||
rvbuf += inc;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(bits) {
|
|
||||||
*rvbuf = cache;
|
|
||||||
rvbuf += inc;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(add) {
|
|
||||||
for(rvbuf -= inc; rvbuf != rvstart; rvbuf -= inc) {
|
|
||||||
int v = add + *rvbuf;
|
|
||||||
if(v & (-1 << CHAR_BIT)) {
|
|
||||||
*rvbuf = (unsigned char)(v + (1 << CHAR_BIT));
|
|
||||||
add = -1;
|
|
||||||
} else {
|
|
||||||
*rvbuf = v;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(rvbuf == rvstart) {
|
|
||||||
/* No space to carry over */
|
|
||||||
errno = ERANGE; /* Overflow */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
char scratch[64]; /* Conservative estimate */
|
|
||||||
unsigned long accum; /* Bits accumulator */
|
|
||||||
char *p; /* Position in the scratch buffer */
|
|
||||||
|
|
||||||
if(OBJECT_IDENTIFIER_get_single_arc(arcbuf, arclen, add,
|
|
||||||
&accum, sizeof(accum)))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
if(accum) {
|
|
||||||
ssize_t len;
|
|
||||||
|
|
||||||
/* Fill the scratch buffer in reverse. */
|
|
||||||
p = scratch + sizeof(scratch);
|
|
||||||
for(; accum; accum /= 10)
|
|
||||||
*(--p) = (char)(accum % 10) + 0x30; /* Put a digit */
|
|
||||||
|
|
||||||
len = sizeof(scratch) - (p - scratch);
|
|
||||||
if(cb(p, len, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
return len;
|
|
||||||
} else {
|
|
||||||
*scratch = 0x30;
|
|
||||||
if(cb(scratch, 1, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen, int add,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
|
|
||||||
if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static ssize_t
|
|
||||||
OBJECT_IDENTIFIER__dump_body(const OBJECT_IDENTIFIER_t *st, asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
ssize_t wrote_len = 0;
|
|
||||||
int startn;
|
|
||||||
int add = 0;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for(i = 0, startn = 0; i < st->size; i++) {
|
|
||||||
uint8_t b = st->buf[i];
|
|
||||||
if((b & 0x80)) /* Continuation expected */
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if(startn == 0) {
|
|
||||||
/*
|
|
||||||
* First two arcs are encoded through the backdoor.
|
|
||||||
*/
|
|
||||||
if(i) {
|
|
||||||
add = -80;
|
|
||||||
if(cb("2", 1, app_key) < 0) return -1;
|
|
||||||
} else if(b <= 39) {
|
|
||||||
add = 0;
|
|
||||||
if(cb("0", 1, app_key) < 0) return -1;
|
|
||||||
} else if(b < 79) {
|
|
||||||
add = -40;
|
|
||||||
if(cb("1", 1, app_key) < 0) return -1;
|
|
||||||
} else {
|
|
||||||
add = -80;
|
|
||||||
if(cb("2", 1, app_key) < 0) return -1;
|
|
||||||
}
|
|
||||||
wrote_len += 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(cb(".", 1, app_key) < 0) /* Separate arcs */
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
add = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn],
|
|
||||||
i - startn + 1, add, cb, app_key);
|
|
||||||
if(add < 0) return -1;
|
|
||||||
wrote_len += 1 + add;
|
|
||||||
startn = i + 1;
|
|
||||||
add = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
return wrote_len;
|
|
||||||
}
|
|
||||||
|
|
||||||
static enum xer_pbd_rval
|
|
||||||
OBJECT_IDENTIFIER__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
|
|
||||||
OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)sptr;
|
|
||||||
const char *chunk_end = (const char *)chunk_buf + chunk_size;
|
|
||||||
const char *endptr;
|
|
||||||
long s_arcs[10];
|
|
||||||
long *arcs = s_arcs;
|
|
||||||
int arcs_count;
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
(void)td;
|
|
||||||
|
|
||||||
arcs_count = OBJECT_IDENTIFIER_parse_arcs(
|
|
||||||
(const char *)chunk_buf, chunk_size, arcs,
|
|
||||||
sizeof(s_arcs)/sizeof(s_arcs[0]), &endptr);
|
|
||||||
if(arcs_count < 0) {
|
|
||||||
/* Expecting more than zero arcs */
|
|
||||||
return XPBD_BROKEN_ENCODING;
|
|
||||||
} else if(arcs_count == 0) {
|
|
||||||
return XPBD_NOT_BODY_IGNORE;
|
|
||||||
}
|
|
||||||
assert(endptr == chunk_end);
|
|
||||||
|
|
||||||
if((size_t)arcs_count > sizeof(s_arcs)/sizeof(s_arcs[0])) {
|
|
||||||
arcs = (long *)MALLOC(arcs_count * sizeof(long));
|
|
||||||
if(!arcs) return XPBD_SYSTEM_FAILURE;
|
|
||||||
ret = OBJECT_IDENTIFIER_parse_arcs(
|
|
||||||
(const char *)chunk_buf, chunk_size,
|
|
||||||
arcs, arcs_count, &endptr);
|
|
||||||
if(ret != arcs_count)
|
|
||||||
return XPBD_SYSTEM_FAILURE; /* assert?.. */
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Convert arcs into BER representation.
|
|
||||||
*/
|
|
||||||
ret = OBJECT_IDENTIFIER_set_arcs(st, arcs, sizeof(*arcs), arcs_count);
|
|
||||||
if(arcs != s_arcs) FREEMEM(arcs);
|
|
||||||
|
|
||||||
return ret ? XPBD_SYSTEM_FAILURE : XPBD_BODY_CONSUMED;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
OBJECT_IDENTIFIER_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
|
|
||||||
const void *buf_ptr, size_t size) {
|
|
||||||
|
|
||||||
return xer_decode_primitive(opt_codec_ctx, td,
|
|
||||||
sptr, sizeof(OBJECT_IDENTIFIER_t), opt_mname,
|
|
||||||
buf_ptr, size, OBJECT_IDENTIFIER__xer_body_decode);
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
OBJECT_IDENTIFIER_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
|
|
||||||
(void)ilevel;
|
|
||||||
(void)flags;
|
|
||||||
|
|
||||||
if(!st || !st->buf)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
er.encoded = OBJECT_IDENTIFIER__dump_body(st, cb, app_key);
|
|
||||||
if(er.encoded < 0) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_print(asn_TYPE_descriptor_t *td, const void *sptr,
|
|
||||||
int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
const OBJECT_IDENTIFIER_t *st = (const OBJECT_IDENTIFIER_t *)sptr;
|
|
||||||
|
|
||||||
(void)td; /* Unused argument */
|
|
||||||
(void)ilevel; /* Unused argument */
|
|
||||||
|
|
||||||
if(!st || !st->buf)
|
|
||||||
return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
|
|
||||||
|
|
||||||
/* Dump preamble */
|
|
||||||
if(cb("{ ", 2, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return (cb(" }", 2, app_key) < 0) ? -1 : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *oid, void *arcs,
|
|
||||||
unsigned int arc_type_size, unsigned int arc_slots) {
|
|
||||||
void *arcs_end = (char *)arcs + (arc_type_size * arc_slots);
|
|
||||||
int num_arcs = 0;
|
|
||||||
int startn = 0;
|
|
||||||
int add = 0;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
if(!oid || !oid->buf || (arc_slots && arc_type_size <= 1)) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
for(i = 0; i < oid->size; i++) {
|
|
||||||
uint8_t b = oid->buf[i];
|
|
||||||
if((b & 0x80)) /* Continuation expected */
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if(num_arcs == 0) {
|
|
||||||
/*
|
|
||||||
* First two arcs are encoded through the backdoor.
|
|
||||||
*/
|
|
||||||
unsigned LE = 1; /* Little endian */
|
|
||||||
int first_arc;
|
|
||||||
num_arcs++;
|
|
||||||
if(!arc_slots) { num_arcs++; continue; }
|
|
||||||
|
|
||||||
if(i) first_arc = 2;
|
|
||||||
else if(b <= 39) first_arc = 0;
|
|
||||||
else if(b < 79) first_arc = 1;
|
|
||||||
else first_arc = 2;
|
|
||||||
|
|
||||||
add = -40 * first_arc;
|
|
||||||
memset(arcs, 0, arc_type_size);
|
|
||||||
*(unsigned char *)((char *)arcs
|
|
||||||
+ ((*(char *)&LE)?0:(arc_type_size - 1)))
|
|
||||||
= first_arc;
|
|
||||||
arcs = ((char *)arcs) + arc_type_size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Decode, if has space */
|
|
||||||
if(arcs < arcs_end) {
|
|
||||||
if(OBJECT_IDENTIFIER_get_single_arc(&oid->buf[startn],
|
|
||||||
i - startn + 1, add,
|
|
||||||
arcs, arc_type_size))
|
|
||||||
return -1;
|
|
||||||
startn = i + 1;
|
|
||||||
arcs = ((char *)arcs) + arc_type_size;
|
|
||||||
add = 0;
|
|
||||||
}
|
|
||||||
num_arcs++;
|
|
||||||
}
|
|
||||||
|
|
||||||
return num_arcs;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Save the single value as an object identifier arc.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf, const void *arcval, unsigned int arcval_size, int prepared_order) {
|
|
||||||
/*
|
|
||||||
* The following conditions must hold:
|
|
||||||
* assert(arcval);
|
|
||||||
* assert(arcval_size > 0);
|
|
||||||
* assert(arcval_size <= 16);
|
|
||||||
* assert(arcbuf);
|
|
||||||
*/
|
|
||||||
#ifdef WORDS_BIGENDIAN
|
|
||||||
const unsigned isLittleEndian = 0;
|
|
||||||
#else
|
|
||||||
unsigned LE = 1;
|
|
||||||
unsigned isLittleEndian = *(char *)&LE;
|
|
||||||
#endif
|
|
||||||
const uint8_t *tend, *tp;
|
|
||||||
unsigned int cache;
|
|
||||||
uint8_t *bp = arcbuf;
|
|
||||||
int bits;
|
|
||||||
uint8_t buffer[16];
|
|
||||||
|
|
||||||
if(isLittleEndian && !prepared_order) {
|
|
||||||
const uint8_t *a = (const unsigned char *)arcval + arcval_size - 1;
|
|
||||||
const uint8_t *aend = (const uint8_t *)arcval;
|
|
||||||
uint8_t *msb = buffer + arcval_size - 1;
|
|
||||||
uint8_t *tb;
|
|
||||||
for(tb = buffer; a >= aend; tb++, a--)
|
|
||||||
if((*tb = *a) && (tb < msb))
|
|
||||||
msb = tb;
|
|
||||||
tend = &buffer[arcval_size];
|
|
||||||
tp = msb; /* Most significant non-zero byte */
|
|
||||||
} else {
|
|
||||||
/* Look for most significant non-zero byte */
|
|
||||||
tend = (const unsigned char *)arcval + arcval_size;
|
|
||||||
for(tp = (const uint8_t *)arcval; tp < tend - 1; tp++)
|
|
||||||
if(*tp) break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Split the value in 7-bits chunks.
|
|
||||||
*/
|
|
||||||
bits = ((tend - tp) * CHAR_BIT) % 7;
|
|
||||||
if(bits) {
|
|
||||||
cache = *tp >> (CHAR_BIT - bits);
|
|
||||||
if(cache) {
|
|
||||||
*bp++ = cache | 0x80;
|
|
||||||
cache = *tp++;
|
|
||||||
bits = CHAR_BIT - bits;
|
|
||||||
} else {
|
|
||||||
bits = -bits;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
cache = 0;
|
|
||||||
}
|
|
||||||
for(; tp < tend; tp++) {
|
|
||||||
cache = (cache << CHAR_BIT) + *tp;
|
|
||||||
bits += CHAR_BIT;
|
|
||||||
while(bits >= 7) {
|
|
||||||
bits -= 7;
|
|
||||||
*bp++ = 0x80 | (cache >> bits);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(bits) *bp++ = cache;
|
|
||||||
bp[-1] &= 0x7f; /* Clear the last bit */
|
|
||||||
|
|
||||||
return bp - arcbuf;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *oid, const void *arcs, unsigned int arc_type_size, unsigned int arc_slots) {
|
|
||||||
uint8_t *buf;
|
|
||||||
uint8_t *bp;
|
|
||||||
unsigned LE = 1; /* Little endian (x86) */
|
|
||||||
unsigned isLittleEndian = *((char *)&LE);
|
|
||||||
unsigned int arc0;
|
|
||||||
unsigned int arc1;
|
|
||||||
unsigned size;
|
|
||||||
unsigned i;
|
|
||||||
|
|
||||||
if(!oid || !arcs || arc_type_size < 1
|
|
||||||
|| arc_type_size > 16
|
|
||||||
|| arc_slots < 2) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
switch(arc_type_size) {
|
|
||||||
case sizeof(char):
|
|
||||||
arc0 = ((const unsigned char *)arcs)[0];
|
|
||||||
arc1 = ((const unsigned char *)arcs)[1];
|
|
||||||
break;
|
|
||||||
case sizeof(short):
|
|
||||||
arc0 = ((const unsigned short *)arcs)[0];
|
|
||||||
arc1 = ((const unsigned short *)arcs)[1];
|
|
||||||
break;
|
|
||||||
case sizeof(int):
|
|
||||||
arc0 = ((const unsigned int *)arcs)[0];
|
|
||||||
arc1 = ((const unsigned int *)arcs)[1];
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
arc1 = arc0 = 0;
|
|
||||||
if(isLittleEndian) { /* Little endian (x86) */
|
|
||||||
const unsigned char *ps, *pe;
|
|
||||||
/* If more significant bytes are present,
|
|
||||||
* make them > 255 quick */
|
|
||||||
for(ps = (const unsigned char *)arcs + 1, pe = ps+arc_type_size;
|
|
||||||
ps < pe; ps++)
|
|
||||||
arc0 |= *ps, arc1 |= *(ps + arc_type_size);
|
|
||||||
arc0 <<= CHAR_BIT, arc1 <<= CHAR_BIT;
|
|
||||||
arc0 = *((const unsigned char *)arcs + 0);
|
|
||||||
arc1 = *((const unsigned char *)arcs + arc_type_size);
|
|
||||||
} else {
|
|
||||||
const unsigned char *ps, *pe;
|
|
||||||
/* If more significant bytes are present,
|
|
||||||
* make them > 255 quick */
|
|
||||||
for(ps = (const unsigned char *)arcs, pe = ps+arc_type_size - 1; ps < pe; ps++)
|
|
||||||
arc0 |= *ps, arc1 |= *(ps + arc_type_size);
|
|
||||||
arc0 = *((const unsigned char *)arcs + arc_type_size - 1);
|
|
||||||
arc1 = *((const unsigned char *)arcs +(arc_type_size<< 1)-1);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The previous chapter left us with the first and the second arcs.
|
|
||||||
* The values are not precise (that is, they are valid only if
|
|
||||||
* they're less than 255), but OK for the purposes of making
|
|
||||||
* the sanity test below.
|
|
||||||
*/
|
|
||||||
if(arc0 <= 1) {
|
|
||||||
if(arc1 >= 39) {
|
|
||||||
/* 8.19.4: At most 39 subsequent values (including 0) */
|
|
||||||
errno = ERANGE;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
} else if(arc0 > 2) {
|
|
||||||
/* 8.19.4: Only three values are allocated from the root node */
|
|
||||||
errno = ERANGE;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
* After above tests it is known that the value of arc0 is completely
|
|
||||||
* trustworthy (0..2). However, the arc1's value is still meaningless.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Roughly estimate the maximum size necessary to encode these arcs.
|
|
||||||
* This estimation implicitly takes in account the following facts,
|
|
||||||
* that cancel each other:
|
|
||||||
* * the first two arcs are encoded in a single value.
|
|
||||||
* * the first value may require more space (+1 byte)
|
|
||||||
* * the value of the first arc which is in range (0..2)
|
|
||||||
*/
|
|
||||||
size = ((arc_type_size * CHAR_BIT + 6) / 7) * arc_slots;
|
|
||||||
bp = buf = (uint8_t *)MALLOC(size + 1);
|
|
||||||
if(!buf) {
|
|
||||||
/* ENOMEM */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode the first two arcs.
|
|
||||||
* These require special treatment.
|
|
||||||
*/
|
|
||||||
{
|
|
||||||
uint8_t *tp;
|
|
||||||
uint8_t first_value[1 + 16]; /* of two arcs */
|
|
||||||
uint8_t *fv = first_value;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Simulate first_value = arc0 * 40 + arc1;
|
|
||||||
*/
|
|
||||||
/* Copy the second (1'st) arcs[1] into the first_value */
|
|
||||||
*fv++ = 0;
|
|
||||||
arcs = ((const char *)arcs) + arc_type_size;
|
|
||||||
if(isLittleEndian) {
|
|
||||||
const uint8_t *aend = (const unsigned char *)arcs - 1;
|
|
||||||
const uint8_t *a1 = (const unsigned char *)arcs + arc_type_size - 1;
|
|
||||||
for(; a1 > aend; fv++, a1--) *fv = *a1;
|
|
||||||
} else {
|
|
||||||
const uint8_t *a1 = (const uint8_t *)arcs;
|
|
||||||
const uint8_t *aend = a1 + arc_type_size;
|
|
||||||
for(; a1 < aend; fv++, a1++) *fv = *a1;
|
|
||||||
}
|
|
||||||
/* Increase the first_value by arc0 */
|
|
||||||
arc0 *= 40; /* (0..80) */
|
|
||||||
for(tp = first_value + arc_type_size; tp >= first_value; tp--) {
|
|
||||||
unsigned int v = *tp;
|
|
||||||
v += arc0;
|
|
||||||
*tp = v;
|
|
||||||
if(v >= (1 << CHAR_BIT)) arc0 = v >> CHAR_BIT;
|
|
||||||
else break;
|
|
||||||
}
|
|
||||||
|
|
||||||
assert(tp >= first_value);
|
|
||||||
|
|
||||||
bp += OBJECT_IDENTIFIER_set_single_arc(bp, first_value,
|
|
||||||
fv - first_value, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Save the rest of arcs.
|
|
||||||
*/
|
|
||||||
for(arcs = ((const char *)arcs) + arc_type_size, i = 2;
|
|
||||||
i < arc_slots;
|
|
||||||
i++, arcs = ((const char *)arcs) + arc_type_size) {
|
|
||||||
bp += OBJECT_IDENTIFIER_set_single_arc(bp,
|
|
||||||
arcs, arc_type_size, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
assert((unsigned)(bp - buf) <= size);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Replace buffer.
|
|
||||||
*/
|
|
||||||
oid->size = bp - buf;
|
|
||||||
bp = oid->buf;
|
|
||||||
oid->buf = buf;
|
|
||||||
if(bp) FREEMEM(bp);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int
|
|
||||||
OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
|
|
||||||
long *arcs, unsigned int arcs_slots, const char **opt_oid_text_end) {
|
|
||||||
unsigned int arcs_count = 0;
|
|
||||||
const char *oid_end;
|
|
||||||
enum {
|
|
||||||
ST_LEADSPACE,
|
|
||||||
ST_TAILSPACE,
|
|
||||||
ST_AFTERVALUE, /* Next character ought to be '.' or a space */
|
|
||||||
ST_WAITDIGITS, /* Next character is expected to be a digit */
|
|
||||||
} state = ST_LEADSPACE;
|
|
||||||
|
|
||||||
if(!oid_text || oid_txt_length < -1 || (arcs_slots && !arcs)) {
|
|
||||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text;
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(oid_txt_length == -1)
|
|
||||||
oid_txt_length = strlen(oid_text);
|
|
||||||
|
|
||||||
#define _OID_CAPTURE_ARC(oid_text, oid_end) do { \
|
|
||||||
const char *endp = oid_end; \
|
|
||||||
long value; \
|
|
||||||
switch(asn_strtol_lim(oid_text, &endp, &value)) { \
|
|
||||||
case ASN_STRTOL_EXTRA_DATA: \
|
|
||||||
case ASN_STRTOL_OK: \
|
|
||||||
if(arcs_count < arcs_slots) \
|
|
||||||
arcs[arcs_count] = value; \
|
|
||||||
arcs_count++; \
|
|
||||||
oid_text = endp - 1; \
|
|
||||||
break; \
|
|
||||||
case ASN_STRTOL_ERROR_RANGE: \
|
|
||||||
if(opt_oid_text_end) \
|
|
||||||
*opt_oid_text_end = oid_text; \
|
|
||||||
errno = ERANGE; \
|
|
||||||
return -1; \
|
|
||||||
case ASN_STRTOL_ERROR_INVAL: \
|
|
||||||
case ASN_STRTOL_EXPECT_MORE: \
|
|
||||||
if(opt_oid_text_end) \
|
|
||||||
*opt_oid_text_end = oid_text; \
|
|
||||||
errno = EINVAL; \
|
|
||||||
return -1; \
|
|
||||||
} \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
for(oid_end = oid_text + oid_txt_length; oid_text<oid_end; oid_text++) {
|
|
||||||
switch(*oid_text) {
|
|
||||||
case 0x09: case 0x0a: case 0x0d: case 0x20: /* whitespace */
|
|
||||||
switch(state) {
|
|
||||||
case ST_LEADSPACE:
|
|
||||||
case ST_TAILSPACE:
|
|
||||||
continue;
|
|
||||||
case ST_AFTERVALUE:
|
|
||||||
state = ST_TAILSPACE;
|
|
||||||
continue;
|
|
||||||
case ST_WAITDIGITS:
|
|
||||||
break; /* Digits expected after ".", got whitespace */
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case 0x2e: /* '.' */
|
|
||||||
switch(state) {
|
|
||||||
case ST_LEADSPACE:
|
|
||||||
case ST_TAILSPACE:
|
|
||||||
case ST_WAITDIGITS:
|
|
||||||
if(opt_oid_text_end)
|
|
||||||
*opt_oid_text_end = oid_text;
|
|
||||||
errno = EINVAL; /* Broken OID */
|
|
||||||
return -1;
|
|
||||||
break;
|
|
||||||
case ST_AFTERVALUE:
|
|
||||||
state = ST_WAITDIGITS;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case 0x30: case 0x31: case 0x32: case 0x33: case 0x34:
|
|
||||||
case 0x35: case 0x36: case 0x37: case 0x38: case 0x39:
|
|
||||||
switch(state) {
|
|
||||||
case ST_TAILSPACE:
|
|
||||||
case ST_AFTERVALUE:
|
|
||||||
if(opt_oid_text_end)
|
|
||||||
*opt_oid_text_end = oid_text;
|
|
||||||
errno = EINVAL; /* "1. 1" => broken OID */
|
|
||||||
return -1;
|
|
||||||
case ST_LEADSPACE:
|
|
||||||
case ST_WAITDIGITS:
|
|
||||||
_OID_CAPTURE_ARC(oid_text, oid_end);
|
|
||||||
state = ST_AFTERVALUE;
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
/* Unexpected symbols */
|
|
||||||
state = ST_WAITDIGITS;
|
|
||||||
break;
|
|
||||||
} /* switch() */
|
|
||||||
break;
|
|
||||||
} /* for() */
|
|
||||||
|
|
||||||
|
|
||||||
if(opt_oid_text_end) *opt_oid_text_end = oid_text;
|
|
||||||
|
|
||||||
/* Finalize last arc */
|
|
||||||
switch(state) {
|
|
||||||
case ST_LEADSPACE:
|
|
||||||
return 0; /* No OID found in input data */
|
|
||||||
case ST_WAITDIGITS:
|
|
||||||
errno = EINVAL; /* Broken OID */
|
|
||||||
return -1;
|
|
||||||
case ST_AFTERVALUE:
|
|
||||||
case ST_TAILSPACE:
|
|
||||||
return arcs_count;
|
|
||||||
}
|
|
||||||
|
|
||||||
errno = EINVAL; /* Broken OID */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
|
@ -1,139 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _OBJECT_IDENTIFIER_H_
|
|
||||||
#define _OBJECT_IDENTIFIER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <asn_codecs_prim.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef ASN__PRIMITIVE_TYPE_t OBJECT_IDENTIFIER_t;
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_OBJECT_IDENTIFIER;
|
|
||||||
|
|
||||||
asn_struct_print_f OBJECT_IDENTIFIER_print;
|
|
||||||
asn_constr_check_f OBJECT_IDENTIFIER_constraint;
|
|
||||||
der_type_encoder_f OBJECT_IDENTIFIER_encode_der;
|
|
||||||
xer_type_decoder_f OBJECT_IDENTIFIER_decode_xer;
|
|
||||||
xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer;
|
|
||||||
|
|
||||||
/**********************************
|
|
||||||
* Some handy conversion routines *
|
|
||||||
**********************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function fills an (_arcs) array with OBJECT IDENTIFIER arcs
|
|
||||||
* up to specified (_arc_slots) elements.
|
|
||||||
*
|
|
||||||
* EXAMPLE:
|
|
||||||
* void print_arcs(OBJECT_IDENTIFIER_t *oid) {
|
|
||||||
* unsigned long fixed_arcs[10]; // Try with fixed space first
|
|
||||||
* unsigned long *arcs = fixed_arcs;
|
|
||||||
* int arc_type_size = sizeof(fixed_arcs[0]); // sizeof(long)
|
|
||||||
* int arc_slots = sizeof(fixed_arcs)/sizeof(fixed_arcs[0]); // 10
|
|
||||||
* int count; // Real number of arcs.
|
|
||||||
* int i;
|
|
||||||
*
|
|
||||||
* count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
|
|
||||||
* arc_type_size, arc_slots);
|
|
||||||
* // If necessary, reallocate arcs array and try again.
|
|
||||||
* if(count > arc_slots) {
|
|
||||||
* arc_slots = count;
|
|
||||||
* arcs = malloc(arc_type_size * arc_slots);
|
|
||||||
* if(!arcs) return;
|
|
||||||
* count = OBJECT_IDENTIFIER_get_arcs(oid, arcs,
|
|
||||||
* arc_type_size, arc_slots);
|
|
||||||
* assert(count == arc_slots);
|
|
||||||
* }
|
|
||||||
*
|
|
||||||
* // Print the contents of the arcs array.
|
|
||||||
* for(i = 0; i < count; i++)
|
|
||||||
* printf("%d\n", arcs[i]);
|
|
||||||
*
|
|
||||||
* // Avoid memory leak.
|
|
||||||
* if(arcs != fixed_arcs) free(arcs);
|
|
||||||
* }
|
|
||||||
*
|
|
||||||
* RETURN VALUES:
|
|
||||||
* -1/EINVAL: Invalid arguments (oid is missing)
|
|
||||||
* -1/ERANGE: One or more arcs have value out of array cell type range.
|
|
||||||
* >=0: Number of arcs contained in the OBJECT IDENTIFIER
|
|
||||||
*
|
|
||||||
* WARNING: The function always returns the real number of arcs,
|
|
||||||
* even if there is no sufficient (_arc_slots) provided.
|
|
||||||
*/
|
|
||||||
int OBJECT_IDENTIFIER_get_arcs(const OBJECT_IDENTIFIER_t *_oid,
|
|
||||||
void *_arcs, /* e.g., unsigned int arcs[N] */
|
|
||||||
unsigned int _arc_type_size, /* e.g., sizeof(arcs[0]) */
|
|
||||||
unsigned int _arc_slots /* e.g., N */);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This functions initializes the OBJECT IDENTIFIER object with
|
|
||||||
* the given set of arcs.
|
|
||||||
* The minimum of two arcs must be present; some restrictions apply.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* -1/EINVAL: Invalid arguments
|
|
||||||
* -1/ERANGE: The first two arcs do not conform to ASN.1 restrictions.
|
|
||||||
* -1/ENOMEM: Memory allocation failed
|
|
||||||
* 0: The object was initialized with new arcs.
|
|
||||||
*/
|
|
||||||
int OBJECT_IDENTIFIER_set_arcs(OBJECT_IDENTIFIER_t *_oid,
|
|
||||||
const void *_arcs, /* e.g., unsigned int arcs[N] */
|
|
||||||
unsigned int _arc_type_size, /* e.g., sizeof(arcs[0]) */
|
|
||||||
unsigned int _arc_slots /* e.g., N */);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Print the specified OBJECT IDENTIFIER arc.
|
|
||||||
*/
|
|
||||||
int OBJECT_IDENTIFIER_print_arc(const uint8_t *arcbuf, int arclen,
|
|
||||||
int add, /* Arbitrary offset, required to process the first two arcs */
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key);
|
|
||||||
|
|
||||||
/* Same as above, but returns the number of written digits, instead of 0 */
|
|
||||||
ssize_t OBJECT_IDENTIFIER__dump_arc(const uint8_t *arcbuf, int arclen, int add,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Parse the OBJECT IDENTIFIER textual representation ("1.3.6.1.4.1.9363").
|
|
||||||
* No arc can exceed the (0..signed_long_max) range (typically, 0..2G if L32).
|
|
||||||
* This function is not specific to OBJECT IDENTIFIER, it may be used to parse
|
|
||||||
* the RELATIVE-OID data, or any other data consisting of dot-separated
|
|
||||||
* series of numeric values.
|
|
||||||
*
|
|
||||||
* If (oid_txt_length == -1), the strlen() will be invoked to determine the
|
|
||||||
* size of the (oid_text) string.
|
|
||||||
*
|
|
||||||
* After return, the optional (opt_oid_text_end) is set to the character after
|
|
||||||
* the last parsed one. (opt_oid_text_end) is never less than (oid_text).
|
|
||||||
*
|
|
||||||
* RETURN VALUES:
|
|
||||||
* -1: Parse error.
|
|
||||||
* >= 0: Number of arcs contained in the OBJECT IDENTIFIER.
|
|
||||||
*
|
|
||||||
* WARNING: The function always returns the real number of arcs,
|
|
||||||
* even if there is no sufficient (_arc_slots) provided.
|
|
||||||
* This is useful for (_arc_slots) value estimation.
|
|
||||||
*/
|
|
||||||
int OBJECT_IDENTIFIER_parse_arcs(const char *oid_text, ssize_t oid_txt_length,
|
|
||||||
long arcs[], unsigned int arcs_slots, const char **opt_oid_text_end);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Internal functions.
|
|
||||||
* Used by RELATIVE-OID implementation in particular.
|
|
||||||
*/
|
|
||||||
int OBJECT_IDENTIFIER_get_single_arc(const uint8_t *arcbuf, unsigned int arclen,
|
|
||||||
signed int add, void *value, unsigned int value_size);
|
|
||||||
int OBJECT_IDENTIFIER_set_single_arc(uint8_t *arcbuf,
|
|
||||||
const void *arcval, unsigned int arcval_size, int _prepared_order);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _OBJECT_IDENTIFIER_H_ */
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,88 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _OCTET_STRING_H_
|
|
||||||
#define _OCTET_STRING_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef struct OCTET_STRING {
|
|
||||||
uint8_t *buf; /* Buffer with consecutive OCTET_STRING bits */
|
|
||||||
int size; /* Size of the buffer */
|
|
||||||
|
|
||||||
asn_struct_ctx_t _asn_ctx; /* Parsing across buffer boundaries */
|
|
||||||
} OCTET_STRING_t;
|
|
||||||
|
|
||||||
extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
|
|
||||||
|
|
||||||
asn_struct_free_f OCTET_STRING_free;
|
|
||||||
asn_struct_print_f OCTET_STRING_print;
|
|
||||||
asn_struct_print_f OCTET_STRING_print_utf8;
|
|
||||||
ber_type_decoder_f OCTET_STRING_decode_ber;
|
|
||||||
der_type_encoder_f OCTET_STRING_encode_der;
|
|
||||||
xer_type_decoder_f OCTET_STRING_decode_xer_hex; /* Hexadecimal */
|
|
||||||
xer_type_decoder_f OCTET_STRING_decode_xer_binary; /* 01010111010 */
|
|
||||||
xer_type_decoder_f OCTET_STRING_decode_xer_utf8; /* ASCII/UTF-8 */
|
|
||||||
xer_type_encoder_f OCTET_STRING_encode_xer;
|
|
||||||
xer_type_encoder_f OCTET_STRING_encode_xer_utf8;
|
|
||||||
per_type_decoder_f OCTET_STRING_decode_uper;
|
|
||||||
per_type_encoder_f OCTET_STRING_encode_uper;
|
|
||||||
per_type_decoder_f OCTET_STRING_decode_aper;
|
|
||||||
per_type_encoder_f OCTET_STRING_encode_aper;
|
|
||||||
|
|
||||||
/******************************
|
|
||||||
* Handy conversion routines. *
|
|
||||||
******************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function clears the previous value of the OCTET STRING (if any)
|
|
||||||
* and then allocates a new memory with the specified content (str/size).
|
|
||||||
* If size = -1, the size of the original string will be determined
|
|
||||||
* using strlen(str).
|
|
||||||
* If str equals to NULL, the function will silently clear the
|
|
||||||
* current contents of the OCTET STRING.
|
|
||||||
* Returns 0 if it was possible to perform operation, -1 otherwise.
|
|
||||||
*/
|
|
||||||
int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
|
|
||||||
|
|
||||||
/* Handy conversion from the C string into the OCTET STRING. */
|
|
||||||
#define OCTET_STRING_fromString(s, str) OCTET_STRING_fromBuf(s, str, -1)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Allocate and fill the new OCTET STRING and return a pointer to the newly
|
|
||||||
* allocated object. NULL is permitted in str: the function will just allocate
|
|
||||||
* empty OCTET STRING.
|
|
||||||
*/
|
|
||||||
OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
|
|
||||||
const char *str, int size);
|
|
||||||
|
|
||||||
/****************************
|
|
||||||
* Internally useful stuff. *
|
|
||||||
****************************/
|
|
||||||
|
|
||||||
typedef const struct asn_OCTET_STRING_specifics_s {
|
|
||||||
/*
|
|
||||||
* Target structure description.
|
|
||||||
*/
|
|
||||||
int struct_size; /* Size of the structure */
|
|
||||||
int ctx_offset; /* Offset of the asn_struct_ctx_t member */
|
|
||||||
|
|
||||||
enum asn_OS_Subvariant {
|
|
||||||
ASN_OSUBV_ANY, /* The open type (ANY) */
|
|
||||||
ASN_OSUBV_BIT, /* BIT STRING */
|
|
||||||
ASN_OSUBV_STR, /* String types, not {BMP,Universal}String */
|
|
||||||
ASN_OSUBV_U16, /* 16-bit character (BMPString) */
|
|
||||||
ASN_OSUBV_U32 /* 32-bit character (UniversalString) */
|
|
||||||
} subvariant;
|
|
||||||
} asn_OCTET_STRING_specifics_t;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _OCTET_STRING_H_ */
|
|
|
@ -1,41 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <asn_SEQUENCE_OF.h>
|
|
||||||
|
|
||||||
typedef A_SEQUENCE_OF(void) asn_sequence;
|
|
||||||
|
|
||||||
void
|
|
||||||
asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free) {
|
|
||||||
asn_sequence *as = (asn_sequence *)asn_sequence_of_x;
|
|
||||||
|
|
||||||
if(as) {
|
|
||||||
void *ptr;
|
|
||||||
int n;
|
|
||||||
|
|
||||||
if(number < 0 || number >= as->count)
|
|
||||||
return; /* Nothing to delete */
|
|
||||||
|
|
||||||
if(_do_free && as->free) {
|
|
||||||
ptr = as->array[number];
|
|
||||||
} else {
|
|
||||||
ptr = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Shift all elements to the left to hide the gap.
|
|
||||||
*/
|
|
||||||
--as->count;
|
|
||||||
for(n = number; n < as->count; n++)
|
|
||||||
as->array[n] = as->array[n+1];
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke the third-party function only when the state
|
|
||||||
* of the parent structure is consistent.
|
|
||||||
*/
|
|
||||||
if(ptr) as->free(ptr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,52 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef ASN_SEQUENCE_OF_H
|
|
||||||
#define ASN_SEQUENCE_OF_H
|
|
||||||
|
|
||||||
#include <asn_SET_OF.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* SEQUENCE OF is the same as SET OF with a tiny difference:
|
|
||||||
* the delete operation preserves the initial order of elements
|
|
||||||
* and thus MAY operate in non-constant time.
|
|
||||||
*/
|
|
||||||
#define A_SEQUENCE_OF(type) A_SET_OF(type)
|
|
||||||
|
|
||||||
#define ASN_SEQUENCE_ADD(headptr, ptr) \
|
|
||||||
asn_sequence_add((headptr), (ptr))
|
|
||||||
|
|
||||||
/***********************************************
|
|
||||||
* Implementation of the SEQUENCE OF structure.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define asn_sequence_add asn_set_add
|
|
||||||
#define asn_sequence_empty asn_set_empty
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Delete the element from the set by its number (base 0).
|
|
||||||
* This is NOT a constant-time operation.
|
|
||||||
* The order of elements is preserved.
|
|
||||||
* If _do_free is given AND the (*free) is initialized, the element
|
|
||||||
* will be freed using the custom (*free) function as well.
|
|
||||||
*/
|
|
||||||
void asn_sequence_del(void *asn_sequence_of_x, int number, int _do_free);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Cope with different conversions requirements to/from void in C and C++.
|
|
||||||
* This is mostly useful for support library.
|
|
||||||
*/
|
|
||||||
typedef A_SEQUENCE_OF(void) asn_anonymous_sequence_;
|
|
||||||
#define _A_SEQUENCE_FROM_VOID(ptr) ((asn_anonymous_sequence_ *)(ptr))
|
|
||||||
#define _A_CSEQUENCE_FROM_VOID(ptr) ((const asn_anonymous_sequence_ *)(ptr))
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* ASN_SEQUENCE_OF_H */
|
|
|
@ -1,88 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <asn_SET_OF.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Add another element into the set.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
asn_set_add(void *asn_set_of_x, void *ptr) {
|
|
||||||
asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
|
|
||||||
|
|
||||||
if(as == 0 || ptr == 0) {
|
|
||||||
errno = EINVAL; /* Invalid arguments */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure there's enough space to insert an element.
|
|
||||||
*/
|
|
||||||
if(as->count == as->size) {
|
|
||||||
int _newsize = as->size ? (as->size << 1) : 4;
|
|
||||||
void *_new_arr;
|
|
||||||
_new_arr = REALLOC(as->array, _newsize * sizeof(as->array[0]));
|
|
||||||
if(_new_arr) {
|
|
||||||
as->array = (void **)_new_arr;
|
|
||||||
as->size = _newsize;
|
|
||||||
} else {
|
|
||||||
/* ENOMEM */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
as->array[as->count++] = ptr;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
asn_set_del(void *asn_set_of_x, int number, int _do_free) {
|
|
||||||
asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
|
|
||||||
|
|
||||||
if(as) {
|
|
||||||
void *ptr;
|
|
||||||
if(number < 0 || number >= as->count)
|
|
||||||
return;
|
|
||||||
|
|
||||||
if(_do_free && as->free) {
|
|
||||||
ptr = as->array[number];
|
|
||||||
} else {
|
|
||||||
ptr = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
as->array[number] = as->array[--as->count];
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke the third-party function only when the state
|
|
||||||
* of the parent structure is consistent.
|
|
||||||
*/
|
|
||||||
if(ptr) as->free(ptr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Free the contents of the set, do not free the set itself.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
asn_set_empty(void *asn_set_of_x) {
|
|
||||||
asn_anonymous_set_ *as = _A_SET_FROM_VOID(asn_set_of_x);
|
|
||||||
|
|
||||||
if(as) {
|
|
||||||
if(as->array) {
|
|
||||||
if(as->free) {
|
|
||||||
while(as->count--)
|
|
||||||
as->free(as->array[as->count]);
|
|
||||||
}
|
|
||||||
FREEMEM(as->array);
|
|
||||||
as->array = 0;
|
|
||||||
}
|
|
||||||
as->count = 0;
|
|
||||||
as->size = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,62 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef ASN_SET_OF_H
|
|
||||||
#define ASN_SET_OF_H
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define A_SET_OF(type) \
|
|
||||||
struct { \
|
|
||||||
type **array; \
|
|
||||||
int count; /* Meaningful size */ \
|
|
||||||
int size; /* Allocated size */ \
|
|
||||||
void (*free)(type *); \
|
|
||||||
}
|
|
||||||
|
|
||||||
#define ASN_SET_ADD(headptr, ptr) \
|
|
||||||
asn_set_add((headptr), (ptr))
|
|
||||||
|
|
||||||
/*******************************************
|
|
||||||
* Implementation of the SET OF structure.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Add another structure into the set by its pointer.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* 0 for success and -1/errno for failure.
|
|
||||||
*/
|
|
||||||
int asn_set_add(void *asn_set_of_x, void *ptr);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Delete the element from the set by its number (base 0).
|
|
||||||
* This is a constant-time operation. The order of elements before the
|
|
||||||
* deleted ones is guaranteed, the order of elements after the deleted
|
|
||||||
* one is NOT guaranteed.
|
|
||||||
* If _do_free is given AND the (*free) is initialized, the element
|
|
||||||
* will be freed using the custom (*free) function as well.
|
|
||||||
*/
|
|
||||||
void asn_set_del(void *asn_set_of_x, int number, int _do_free);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Empty the contents of the set. Will free the elements, if (*free) is given.
|
|
||||||
* Will NOT free the set itself.
|
|
||||||
*/
|
|
||||||
void asn_set_empty(void *asn_set_of_x);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Cope with different conversions requirements to/from void in C and C++.
|
|
||||||
* This is mostly useful for support library.
|
|
||||||
*/
|
|
||||||
typedef A_SET_OF(void) asn_anonymous_set_;
|
|
||||||
#define _A_SET_FROM_VOID(ptr) ((asn_anonymous_set_ *)(ptr))
|
|
||||||
#define _A_CSET_FROM_VOID(ptr) ((const asn_anonymous_set_ *)(ptr))
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* ASN_SET_OF_H */
|
|
|
@ -1,47 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004, 2006 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* Application-level ASN.1 callbacks.
|
|
||||||
*/
|
|
||||||
#ifndef _ASN_APPLICATION_H_
|
|
||||||
#define _ASN_APPLICATION_H_
|
|
||||||
|
|
||||||
#include "asn_system.h" /* for platform-dependent types */
|
|
||||||
#include "asn_codecs.h" /* for ASN.1 codecs specifics */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generic type of an application-defined callback to return various
|
|
||||||
* types of data to the application.
|
|
||||||
* EXPECTED RETURN VALUES:
|
|
||||||
* -1: Failed to consume bytes. Abort the mission.
|
|
||||||
* Non-negative return values indicate success, and ignored.
|
|
||||||
*/
|
|
||||||
typedef int (asn_app_consume_bytes_f)(const void *buffer, size_t size,
|
|
||||||
void *application_specific_key);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A callback of this type is called whenever constraint validation fails
|
|
||||||
* on some ASN.1 type. See "constraints.h" for more details on constraint
|
|
||||||
* validation.
|
|
||||||
* This callback specifies a descriptor of the ASN.1 type which failed
|
|
||||||
* the constraint check, as well as human readable message on what
|
|
||||||
* particular constraint has failed.
|
|
||||||
*/
|
|
||||||
typedef void (asn_app_constraint_failed_f)(void *application_specific_key,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor_which_failed,
|
|
||||||
const void *structure_which_failed_ptr,
|
|
||||||
const char *error_message_format, ...) GCC_PRINTFLIKE(4, 5);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include "constr_TYPE.h" /* for asn_TYPE_descriptor_t */
|
|
||||||
|
|
||||||
#endif /* _ASN_APPLICATION_H_ */
|
|
|
@ -1,109 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _ASN_CODECS_H_
|
|
||||||
#define _ASN_CODECS_H_
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This structure defines a set of parameters that may be passed
|
|
||||||
* to every ASN.1 encoder or decoder function.
|
|
||||||
* WARNING: if max_stack_size member is set, and you are calling the
|
|
||||||
* function pointers of the asn_TYPE_descriptor_t directly,
|
|
||||||
* this structure must be ALLOCATED ON THE STACK!
|
|
||||||
* If you can't always satisfy this requirement, use ber_decode(),
|
|
||||||
* xer_decode() and uper_decode() functions instead.
|
|
||||||
*/
|
|
||||||
typedef struct asn_codec_ctx_s {
|
|
||||||
/*
|
|
||||||
* Limit the decoder routines to use no (much) more stack than a given
|
|
||||||
* number of bytes. Most of decoders are stack-based, and this
|
|
||||||
* would protect against stack overflows if the number of nested
|
|
||||||
* encodings is high.
|
|
||||||
* The OCTET STRING, BIT STRING and ANY BER decoders are heap-based,
|
|
||||||
* and are safe from this kind of overflow.
|
|
||||||
* A value from getrlimit(RLIMIT_STACK) may be used to initialize
|
|
||||||
* this variable. Be careful in multithreaded environments, as the
|
|
||||||
* stack size is rather limited.
|
|
||||||
*/
|
|
||||||
size_t max_stack_size; /* 0 disables stack bounds checking */
|
|
||||||
} asn_codec_ctx_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of the return value of the encoding functions (der_encode, xer_encode).
|
|
||||||
*/
|
|
||||||
typedef struct asn_enc_rval_s {
|
|
||||||
/*
|
|
||||||
* Number of bytes encoded.
|
|
||||||
* -1 indicates failure to encode the structure.
|
|
||||||
* In this case, the members below this one are meaningful.
|
|
||||||
*/
|
|
||||||
ssize_t encoded;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Members meaningful when (encoded == -1), for post mortem analysis.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Type which cannot be encoded */
|
|
||||||
struct asn_TYPE_descriptor_s *failed_type;
|
|
||||||
|
|
||||||
/* Pointer to the structure of that type */
|
|
||||||
void *structure_ptr;
|
|
||||||
} asn_enc_rval_t;
|
|
||||||
#define _ASN_ENCODE_FAILED do { \
|
|
||||||
asn_enc_rval_t tmp_error; \
|
|
||||||
tmp_error.encoded = -1; \
|
|
||||||
tmp_error.failed_type = td; \
|
|
||||||
tmp_error.structure_ptr = sptr; \
|
|
||||||
ASN_DEBUG("Failed to encode element %s", td ? td->name : ""); \
|
|
||||||
return tmp_error; \
|
|
||||||
} while(0)
|
|
||||||
#define _ASN_ENCODED_OK(rval) do { \
|
|
||||||
rval.structure_ptr = 0; \
|
|
||||||
rval.failed_type = 0; \
|
|
||||||
return rval; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of the return value of the decoding functions (ber_decode, xer_decode)
|
|
||||||
*
|
|
||||||
* Please note that the number of consumed bytes is ALWAYS meaningful,
|
|
||||||
* even if code==RC_FAIL. This is to indicate the number of successfully
|
|
||||||
* decoded bytes, hence providing a possibility to fail with more diagnostics
|
|
||||||
* (i.e., print the offending remainder of the buffer).
|
|
||||||
*/
|
|
||||||
enum asn_dec_rval_code_e {
|
|
||||||
RC_OK, /* Decoded successfully */
|
|
||||||
RC_WMORE, /* More data expected, call again */
|
|
||||||
RC_FAIL /* Failure to decode data */
|
|
||||||
};
|
|
||||||
typedef struct asn_dec_rval_s {
|
|
||||||
enum asn_dec_rval_code_e code; /* Result code */
|
|
||||||
size_t consumed; /* Number of bytes consumed */
|
|
||||||
} asn_dec_rval_t;
|
|
||||||
#define _ASN_DECODE_FAILED do { \
|
|
||||||
asn_dec_rval_t tmp_error; \
|
|
||||||
tmp_error.code = RC_FAIL; \
|
|
||||||
tmp_error.consumed = 0; \
|
|
||||||
ASN_DEBUG("Failed to decode element %s", td ? td->name : ""); \
|
|
||||||
return tmp_error; \
|
|
||||||
} while(0)
|
|
||||||
#define _ASN_DECODE_STARVED do { \
|
|
||||||
asn_dec_rval_t tmp_error; \
|
|
||||||
tmp_error.code = RC_WMORE; \
|
|
||||||
tmp_error.consumed = 0; \
|
|
||||||
return tmp_error; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _ASN_CODECS_H_ */
|
|
|
@ -1,312 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <asn_codecs_prim.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decode an always-primitive type.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
ber_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
void **sptr, const void *buf_ptr, size_t size, int tag_mode) {
|
|
||||||
ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
ber_tlv_len_t length = 0; // =0 to avoid [incorrect] warning.
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If the structure is not there, allocate it.
|
|
||||||
*/
|
|
||||||
if(st == NULL) {
|
|
||||||
st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st));
|
|
||||||
if(st == NULL) _ASN_DECODE_FAILED;
|
|
||||||
*sptr = (void *)st;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Decoding %s as plain primitive (tm=%d)",
|
|
||||||
td->name, tag_mode);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check tags and extract value length.
|
|
||||||
*/
|
|
||||||
rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
|
|
||||||
tag_mode, 0, &length, 0);
|
|
||||||
if(rval.code != RC_OK)
|
|
||||||
return rval;
|
|
||||||
|
|
||||||
ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure we have this length.
|
|
||||||
*/
|
|
||||||
buf_ptr = ((const char *)buf_ptr) + rval.consumed;
|
|
||||||
size -= rval.consumed;
|
|
||||||
if(length > (ber_tlv_len_t)size) {
|
|
||||||
rval.code = RC_WMORE;
|
|
||||||
rval.consumed = 0;
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
st->size = (int)length;
|
|
||||||
/* The following better be optimized away. */
|
|
||||||
if(sizeof(st->size) != sizeof(length)
|
|
||||||
&& (ber_tlv_len_t)st->size != length) {
|
|
||||||
st->size = 0;
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
st->buf = (uint8_t *)MALLOC(length + 1);
|
|
||||||
if(!st->buf) {
|
|
||||||
st->size = 0;
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
memcpy(st->buf, buf_ptr, length);
|
|
||||||
st->buf[length] = '\0'; /* Just in case */
|
|
||||||
|
|
||||||
rval.code = RC_OK;
|
|
||||||
rval.consumed += length;
|
|
||||||
|
|
||||||
ASN_DEBUG("Took %ld/%ld bytes to encode %s",
|
|
||||||
(long)rval.consumed,
|
|
||||||
(long)length, td->name);
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode an always-primitive type using DER.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
der_encode_primitive(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int tag_mode, ber_tlv_tag_t tag,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_enc_rval_t erval;
|
|
||||||
ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
|
|
||||||
|
|
||||||
ASN_DEBUG("%s %s as a primitive type (tm=%d)",
|
|
||||||
cb?"Encoding":"Estimating", td->name, tag_mode);
|
|
||||||
|
|
||||||
erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag,
|
|
||||||
cb, app_key);
|
|
||||||
ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded);
|
|
||||||
if(erval.encoded == -1) {
|
|
||||||
erval.failed_type = td;
|
|
||||||
erval.structure_ptr = sptr;
|
|
||||||
return erval;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(cb && st->buf) {
|
|
||||||
if(cb(st->buf, st->size, app_key) < 0) {
|
|
||||||
erval.encoded = -1;
|
|
||||||
erval.failed_type = td;
|
|
||||||
erval.structure_ptr = sptr;
|
|
||||||
return erval;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
assert(st->buf || st->size == 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
erval.encoded += st->size;
|
|
||||||
_ASN_ENCODED_OK(erval);
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
ASN__PRIMITIVE_TYPE_free(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int contents_only) {
|
|
||||||
ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
|
|
||||||
|
|
||||||
if(!td || !sptr)
|
|
||||||
return;
|
|
||||||
|
|
||||||
ASN_DEBUG("Freeing %s as a primitive type", td->name);
|
|
||||||
|
|
||||||
if(st->buf)
|
|
||||||
FREEMEM(st->buf);
|
|
||||||
|
|
||||||
if(!contents_only)
|
|
||||||
FREEMEM(st);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Local internal type passed around as an argument.
|
|
||||||
*/
|
|
||||||
struct xdp_arg_s {
|
|
||||||
asn_TYPE_descriptor_t *type_descriptor;
|
|
||||||
void *struct_key;
|
|
||||||
xer_primitive_body_decoder_f *prim_body_decoder;
|
|
||||||
int decoded_something;
|
|
||||||
int want_more;
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Since some kinds of primitive values can be encoded using value-specific
|
|
||||||
* tags (<MINUS-INFINITY>, <enum-element>, etc), the primitive decoder must
|
|
||||||
* be supplied with such tags to parse them as needed.
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
xer_decode__unexpected_tag(void *key, const void *chunk_buf, size_t chunk_size) {
|
|
||||||
struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
|
|
||||||
enum xer_pbd_rval bret;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The chunk_buf is guaranteed to start at '<'.
|
|
||||||
*/
|
|
||||||
assert(chunk_size && ((const char *)chunk_buf)[0] == 0x3c);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decoding was performed once already. Prohibit doing it again.
|
|
||||||
*/
|
|
||||||
if(arg->decoded_something)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
bret = arg->prim_body_decoder(arg->type_descriptor,
|
|
||||||
arg->struct_key, chunk_buf, chunk_size);
|
|
||||||
switch(bret) {
|
|
||||||
case XPBD_SYSTEM_FAILURE:
|
|
||||||
case XPBD_DECODER_LIMIT:
|
|
||||||
case XPBD_BROKEN_ENCODING:
|
|
||||||
break;
|
|
||||||
case XPBD_BODY_CONSUMED:
|
|
||||||
/* Tag decoded successfully */
|
|
||||||
arg->decoded_something = 1;
|
|
||||||
/* Fall through */
|
|
||||||
case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static ssize_t
|
|
||||||
xer_decode__primitive_body(void *key, const void *chunk_buf, size_t chunk_size, int have_more) {
|
|
||||||
struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
|
|
||||||
enum xer_pbd_rval bret;
|
|
||||||
size_t lead_wsp_size;
|
|
||||||
|
|
||||||
if(arg->decoded_something) {
|
|
||||||
if(xer_whitespace_span(chunk_buf, chunk_size) == chunk_size) {
|
|
||||||
/*
|
|
||||||
* Example:
|
|
||||||
* "<INTEGER>123<!--/--> </INTEGER>"
|
|
||||||
* ^- chunk_buf position.
|
|
||||||
*/
|
|
||||||
return chunk_size;
|
|
||||||
}
|
|
||||||
/*
|
|
||||||
* Decoding was done once already. Prohibit doing it again.
|
|
||||||
*/
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!have_more) {
|
|
||||||
/*
|
|
||||||
* If we've received something like "1", we can't really
|
|
||||||
* tell whether it is really `1` or `123`, until we know
|
|
||||||
* that there is no more data coming.
|
|
||||||
* The have_more argument will be set to 1 once something
|
|
||||||
* like this is available to the caller of this callback:
|
|
||||||
* "1<tag_start..."
|
|
||||||
*/
|
|
||||||
arg->want_more = 1;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
lead_wsp_size = xer_whitespace_span(chunk_buf, chunk_size);
|
|
||||||
chunk_buf = (const char *)chunk_buf + lead_wsp_size;
|
|
||||||
chunk_size -= lead_wsp_size;
|
|
||||||
|
|
||||||
bret = arg->prim_body_decoder(arg->type_descriptor,
|
|
||||||
arg->struct_key, chunk_buf, chunk_size);
|
|
||||||
switch(bret) {
|
|
||||||
case XPBD_SYSTEM_FAILURE:
|
|
||||||
case XPBD_DECODER_LIMIT:
|
|
||||||
case XPBD_BROKEN_ENCODING:
|
|
||||||
break;
|
|
||||||
case XPBD_BODY_CONSUMED:
|
|
||||||
/* Tag decoded successfully */
|
|
||||||
arg->decoded_something = 1;
|
|
||||||
/* Fall through */
|
|
||||||
case XPBD_NOT_BODY_IGNORE: /* Safe to proceed further */
|
|
||||||
return lead_wsp_size + chunk_size;
|
|
||||||
}
|
|
||||||
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td,
|
|
||||||
void **sptr,
|
|
||||||
size_t struct_size,
|
|
||||||
const char *opt_mname,
|
|
||||||
const void *buf_ptr, size_t size,
|
|
||||||
xer_primitive_body_decoder_f *prim_body_decoder
|
|
||||||
) {
|
|
||||||
const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
|
|
||||||
asn_struct_ctx_t s_ctx;
|
|
||||||
struct xdp_arg_s s_arg;
|
|
||||||
asn_dec_rval_t rc;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Create the structure if does not exist.
|
|
||||||
*/
|
|
||||||
if(!*sptr) {
|
|
||||||
*sptr = CALLOC(1, struct_size);
|
|
||||||
if(!*sptr) _ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
memset(&s_ctx, 0, sizeof(s_ctx));
|
|
||||||
s_arg.type_descriptor = td;
|
|
||||||
s_arg.struct_key = *sptr;
|
|
||||||
s_arg.prim_body_decoder = prim_body_decoder;
|
|
||||||
s_arg.decoded_something = 0;
|
|
||||||
s_arg.want_more = 0;
|
|
||||||
|
|
||||||
rc = xer_decode_general(opt_codec_ctx, &s_ctx, &s_arg,
|
|
||||||
xml_tag, buf_ptr, size,
|
|
||||||
xer_decode__unexpected_tag, xer_decode__primitive_body);
|
|
||||||
switch(rc.code) {
|
|
||||||
case RC_OK:
|
|
||||||
if(!s_arg.decoded_something) {
|
|
||||||
char ch;
|
|
||||||
ASN_DEBUG("Primitive body is not recognized, "
|
|
||||||
"supplying empty one");
|
|
||||||
/*
|
|
||||||
* Decoding opportunity has come and gone.
|
|
||||||
* Where's the result?
|
|
||||||
* Try to feed with empty body, see if it eats it.
|
|
||||||
*/
|
|
||||||
if(prim_body_decoder(s_arg.type_descriptor,
|
|
||||||
s_arg.struct_key, &ch, 0)
|
|
||||||
!= XPBD_BODY_CONSUMED) {
|
|
||||||
/*
|
|
||||||
* This decoder does not like empty stuff.
|
|
||||||
*/
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case RC_WMORE:
|
|
||||||
/*
|
|
||||||
* Redo the whole thing later.
|
|
||||||
* We don't have a context to save intermediate parsing state.
|
|
||||||
*/
|
|
||||||
rc.consumed = 0;
|
|
||||||
break;
|
|
||||||
case RC_FAIL:
|
|
||||||
rc.consumed = 0;
|
|
||||||
if(s_arg.want_more)
|
|
||||||
rc.code = RC_WMORE;
|
|
||||||
else
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
return rc;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,53 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef ASN_CODECS_PRIM_H
|
|
||||||
#define ASN_CODECS_PRIM_H
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef struct ASN__PRIMITIVE_TYPE_s {
|
|
||||||
uint8_t *buf; /* Buffer with consecutive primitive encoding bytes */
|
|
||||||
int size; /* Size of the buffer */
|
|
||||||
} ASN__PRIMITIVE_TYPE_t; /* Do not use this type directly! */
|
|
||||||
|
|
||||||
asn_struct_free_f ASN__PRIMITIVE_TYPE_free;
|
|
||||||
ber_type_decoder_f ber_decode_primitive;
|
|
||||||
der_type_encoder_f der_encode_primitive;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A callback specification for the xer_decode_primitive() function below.
|
|
||||||
*/
|
|
||||||
enum xer_pbd_rval {
|
|
||||||
XPBD_SYSTEM_FAILURE, /* System failure (memory shortage, etc) */
|
|
||||||
XPBD_DECODER_LIMIT, /* Hit some decoder limitation or deficiency */
|
|
||||||
XPBD_BROKEN_ENCODING, /* Encoding of a primitive body is broken */
|
|
||||||
XPBD_NOT_BODY_IGNORE, /* Not a body format, but safe to ignore */
|
|
||||||
XPBD_BODY_CONSUMED /* Body is recognized and consumed */
|
|
||||||
};
|
|
||||||
typedef enum xer_pbd_rval (xer_primitive_body_decoder_f)
|
|
||||||
(asn_TYPE_descriptor_t *td, void *struct_ptr,
|
|
||||||
const void *chunk_buf, size_t chunk_size);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Specific function to decode simple primitive types.
|
|
||||||
* Also see xer_decode_general() in xer_decoder.h
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t xer_decode_primitive(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
void **struct_ptr, size_t struct_size,
|
|
||||||
const char *opt_mname,
|
|
||||||
const void *buf_ptr, size_t size,
|
|
||||||
xer_primitive_body_decoder_f *prim_body_decoder
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* ASN_CODECS_PRIM_H */
|
|
|
@ -1,130 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2005, 2007 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* Declarations internally useful for the ASN.1 support code.
|
|
||||||
*/
|
|
||||||
#ifndef _ASN_INTERNAL_H_
|
|
||||||
#define _ASN_INTERNAL_H_
|
|
||||||
|
|
||||||
#include "asn_application.h" /* Application-visible API */
|
|
||||||
|
|
||||||
#ifndef __NO_ASSERT_H__ /* Include assert.h only for internal use. */
|
|
||||||
#include <assert.h> /* for assert() macro */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Environment version might be used to avoid running with the old library */
|
|
||||||
#define ASN1C_ENVIRONMENT_VERSION 924 /* Compile-time version */
|
|
||||||
int get_asn1c_environment_version(void); /* Run-time version */
|
|
||||||
|
|
||||||
#define CALLOC(nmemb, size) calloc(nmemb, size)
|
|
||||||
#define MALLOC(size) malloc(size)
|
|
||||||
#define REALLOC(oldptr, size) realloc(oldptr, size)
|
|
||||||
#define FREEMEM(ptr) free(ptr)
|
|
||||||
|
|
||||||
#define asn_debug_indent 0
|
|
||||||
#define ASN_DEBUG_INDENT_ADD(i) do{}while(0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A macro for debugging the ASN.1 internals.
|
|
||||||
* You may enable or override it.
|
|
||||||
*/
|
|
||||||
#ifndef ASN_DEBUG /* If debugging code is not defined elsewhere... */
|
|
||||||
#if EMIT_ASN_DEBUG == 1 /* And it was asked to emit this code... */
|
|
||||||
#ifdef __GNUC__
|
|
||||||
#ifdef ASN_THREAD_SAFE
|
|
||||||
/* Thread safety requires sacrifice in output indentation:
|
|
||||||
* Retain empty definition of ASN_DEBUG_INDENT_ADD. */
|
|
||||||
#else /* !ASN_THREAD_SAFE */
|
|
||||||
#undef ASN_DEBUG_INDENT_ADD
|
|
||||||
#undef asn_debug_indent
|
|
||||||
int asn_debug_indent;
|
|
||||||
#define ASN_DEBUG_INDENT_ADD(i) do { asn_debug_indent += i; } while(0)
|
|
||||||
#endif /* ASN_THREAD_SAFE */
|
|
||||||
extern int asn_debug; /* Allow option on execution */
|
|
||||||
#define ASN_DEBUG(fmt, args...) \
|
|
||||||
if (asn_debug) { \
|
|
||||||
do { \
|
|
||||||
int adi = asn_debug_indent; \
|
|
||||||
while(adi--) fprintf(stderr, " "); \
|
|
||||||
fprintf(stderr, fmt, ##args); \
|
|
||||||
fprintf(stderr, " (%s:%d)\n", \
|
|
||||||
__FILE__, __LINE__); \
|
|
||||||
} while(0); \
|
|
||||||
}
|
|
||||||
#else /* !__GNUC__ */
|
|
||||||
void ASN_DEBUG_f(const char *fmt, ...);
|
|
||||||
#define ASN_DEBUG ASN_DEBUG_f
|
|
||||||
#endif /* __GNUC__ */
|
|
||||||
#else /* EMIT_ASN_DEBUG != 1 */
|
|
||||||
static inline void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }
|
|
||||||
#endif /* EMIT_ASN_DEBUG */
|
|
||||||
#endif /* ASN_DEBUG */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke the application-supplied callback and fail, if something is wrong.
|
|
||||||
*/
|
|
||||||
#define __ASN_E_cbc(buf, size) (cb((buf), (size), app_key) < 0)
|
|
||||||
#define _ASN_E_CALLBACK(foo) do { \
|
|
||||||
if(foo) goto cb_failed; \
|
|
||||||
} while(0)
|
|
||||||
#define _ASN_CALLBACK(buf, size) \
|
|
||||||
_ASN_E_CALLBACK(__ASN_E_cbc(buf, size))
|
|
||||||
#define _ASN_CALLBACK2(buf1, size1, buf2, size2) \
|
|
||||||
_ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) || __ASN_E_cbc(buf2, size2))
|
|
||||||
#define _ASN_CALLBACK3(buf1, size1, buf2, size2, buf3, size3) \
|
|
||||||
_ASN_E_CALLBACK(__ASN_E_cbc(buf1, size1) \
|
|
||||||
|| __ASN_E_cbc(buf2, size2) \
|
|
||||||
|| __ASN_E_cbc(buf3, size3))
|
|
||||||
|
|
||||||
#define _i_ASN_TEXT_INDENT(nl, level) do { \
|
|
||||||
int __level = (level); \
|
|
||||||
int __nl = ((nl) != 0); \
|
|
||||||
int __i; \
|
|
||||||
if(__nl) _ASN_CALLBACK("\n", 1); \
|
|
||||||
if(__level < 0) __level = 0; \
|
|
||||||
for(__i = 0; __i < __level; __i++) \
|
|
||||||
_ASN_CALLBACK(" ", 4); \
|
|
||||||
er.encoded += __nl + 4 * __level; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
#define _i_INDENT(nl) do { \
|
|
||||||
int __i; \
|
|
||||||
if((nl) && cb("\n", 1, app_key) < 0) return -1; \
|
|
||||||
for(__i = 0; __i < ilevel; __i++) \
|
|
||||||
if(cb(" ", 4, app_key) < 0) return -1; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check stack against overflow, if limit is set.
|
|
||||||
*/
|
|
||||||
#define _ASN_DEFAULT_STACK_MAX (30000)
|
|
||||||
static inline int
|
|
||||||
_ASN_STACK_OVERFLOW_CHECK(asn_codec_ctx_t *ctx) {
|
|
||||||
if(ctx && ctx->max_stack_size) {
|
|
||||||
|
|
||||||
/* ctx MUST be allocated on the stack */
|
|
||||||
ptrdiff_t usedstack = ((char *)ctx - (char *)&ctx);
|
|
||||||
if(usedstack > 0) usedstack = -usedstack; /* grows up! */
|
|
||||||
|
|
||||||
/* double negative required to avoid int wrap-around */
|
|
||||||
if(usedstack < -(ptrdiff_t)ctx->max_stack_size) {
|
|
||||||
ASN_DEBUG("Stack limit %ld reached",
|
|
||||||
(long)ctx->max_stack_size);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _ASN_INTERNAL_H_ */
|
|
|
@ -1,129 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2007 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* Miscellaneous system-dependent types.
|
|
||||||
*/
|
|
||||||
#ifndef _ASN_SYSTEM_H_
|
|
||||||
#define _ASN_SYSTEM_H_
|
|
||||||
|
|
||||||
#ifdef HAVE_CONFIG_H
|
|
||||||
#include "config.h"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <stdio.h> /* For snprintf(3) */
|
|
||||||
#include <stdlib.h> /* For *alloc(3) */
|
|
||||||
#include <string.h> /* For memcpy(3) */
|
|
||||||
#include <sys/types.h> /* For size_t */
|
|
||||||
#include <limits.h> /* For LONG_MAX */
|
|
||||||
#include <stdarg.h> /* For va_start */
|
|
||||||
#include <stddef.h> /* for offsetof and ptrdiff_t */
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
|
|
||||||
#include <malloc.h>
|
|
||||||
#define snprintf _snprintf
|
|
||||||
#define vsnprintf _vsnprintf
|
|
||||||
|
|
||||||
/* To avoid linking with ws2_32.lib, here's the definition of ntohl() */
|
|
||||||
#define sys_ntohl(l) ((((l) << 24) & 0xff000000) \
|
|
||||||
| (((l) << 8) & 0xff0000) \
|
|
||||||
| (((l) >> 8) & 0xff00) \
|
|
||||||
| ((l >> 24) & 0xff))
|
|
||||||
|
|
||||||
#ifdef _MSC_VER /* MSVS.Net */
|
|
||||||
#ifndef __cplusplus
|
|
||||||
#define inline __inline
|
|
||||||
#endif
|
|
||||||
#ifndef ASSUMESTDTYPES /* Standard types have been defined elsewhere */
|
|
||||||
#define ssize_t SSIZE_T
|
|
||||||
typedef char int8_t;
|
|
||||||
typedef short int16_t;
|
|
||||||
typedef int int32_t;
|
|
||||||
typedef unsigned char uint8_t;
|
|
||||||
typedef unsigned short uint16_t;
|
|
||||||
typedef unsigned int uint32_t;
|
|
||||||
#endif /* ASSUMESTDTYPES */
|
|
||||||
#define WIN32_LEAN_AND_MEAN
|
|
||||||
#include <windows.h>
|
|
||||||
#include <float.h>
|
|
||||||
#define isnan _isnan
|
|
||||||
#define finite _finite
|
|
||||||
#define copysign _copysign
|
|
||||||
#define ilogb _logb
|
|
||||||
#else /* !_MSC_VER */
|
|
||||||
#include <stdint.h>
|
|
||||||
#endif /* _MSC_VER */
|
|
||||||
|
|
||||||
#else /* !_WIN32 */
|
|
||||||
|
|
||||||
#if defined(__vxworks)
|
|
||||||
#include <types/vxTypes.h>
|
|
||||||
#else /* !defined(__vxworks) */
|
|
||||||
|
|
||||||
#include <inttypes.h> /* C99 specifies this file */
|
|
||||||
/*
|
|
||||||
* 1. Earlier FreeBSD version didn't have <stdint.h>,
|
|
||||||
* but <inttypes.h> was present.
|
|
||||||
* 2. Sun Solaris requires <alloca.h> for alloca(3),
|
|
||||||
* but does not have <stdint.h>.
|
|
||||||
*/
|
|
||||||
#if (!defined(__FreeBSD__) || !defined(_SYS_INTTYPES_H_))
|
|
||||||
#if defined(sun)
|
|
||||||
#include <alloca.h> /* For alloca(3) */
|
|
||||||
#include <ieeefp.h> /* for finite(3) */
|
|
||||||
#elif defined(__hpux)
|
|
||||||
#ifdef __GNUC__
|
|
||||||
#include <alloca.h> /* For alloca(3) */
|
|
||||||
#else /* !__GNUC__ */
|
|
||||||
#define inline
|
|
||||||
#endif /* __GNUC__ */
|
|
||||||
#else
|
|
||||||
#include <stdint.h> /* SUSv2+ and C99 specify this file, for uintXX_t */
|
|
||||||
#endif /* defined(sun) */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <netinet/in.h> /* for ntohl() */
|
|
||||||
#define sys_ntohl(foo) ntohl(foo)
|
|
||||||
|
|
||||||
#endif /* defined(__vxworks) */
|
|
||||||
|
|
||||||
#endif /* _WIN32 */
|
|
||||||
|
|
||||||
#if __GNUC__ >= 3
|
|
||||||
#ifndef GCC_PRINTFLIKE
|
|
||||||
#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
|
|
||||||
#endif
|
|
||||||
#ifndef GCC_NOTUSED
|
|
||||||
#define GCC_NOTUSED __attribute__((unused))
|
|
||||||
#endif
|
|
||||||
#else
|
|
||||||
#ifndef GCC_PRINTFLIKE
|
|
||||||
#define GCC_PRINTFLIKE(fmt,var) /* nothing */
|
|
||||||
#endif
|
|
||||||
#ifndef GCC_NOTUSED
|
|
||||||
#define GCC_NOTUSED
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Figure out if thread safety is requested */
|
|
||||||
#if !defined(ASN_THREAD_SAFE) && (defined(THREAD_SAFE) || defined(_REENTRANT))
|
|
||||||
#define ASN_THREAD_SAFE
|
|
||||||
#endif /* Thread safety */
|
|
||||||
|
|
||||||
#ifndef offsetof /* If not defined by <stddef.h> */
|
|
||||||
#define offsetof(s, m) ((ptrdiff_t)&(((s *)0)->m) - (ptrdiff_t)((s *)0))
|
|
||||||
#endif /* offsetof */
|
|
||||||
|
|
||||||
#ifndef MIN /* Suitable for comparing primitive types (integers) */
|
|
||||||
#if defined(__GNUC__)
|
|
||||||
#define MIN(a,b) ({ __typeof a _a = a; __typeof b _b = b; \
|
|
||||||
((_a)<(_b)?(_a):(_b)); })
|
|
||||||
#else /* !__GNUC__ */
|
|
||||||
#define MIN(a,b) ((a)<(b)?(a):(b)) /* Unsafe variant */
|
|
||||||
#endif /* __GNUC__ */
|
|
||||||
#endif /* MIN */
|
|
||||||
|
|
||||||
#endif /* _ASN_SYSTEM_H_ */
|
|
|
@ -1,283 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
|
|
||||||
#undef ADVANCE
|
|
||||||
#define ADVANCE(num_bytes) do { \
|
|
||||||
size_t num = num_bytes; \
|
|
||||||
ptr = ((const char *)ptr) + num; \
|
|
||||||
size -= num; \
|
|
||||||
consumed_myself += num; \
|
|
||||||
} while(0)
|
|
||||||
#undef RETURN
|
|
||||||
#define RETURN(_code) do { \
|
|
||||||
asn_dec_rval_t rval; \
|
|
||||||
rval.code = _code; \
|
|
||||||
if(opt_ctx) opt_ctx->step = step; /* Save context */ \
|
|
||||||
if(_code == RC_OK || opt_ctx) \
|
|
||||||
rval.consumed = consumed_myself; \
|
|
||||||
else \
|
|
||||||
rval.consumed = 0; /* Context-free */ \
|
|
||||||
return rval; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The BER decoder of any type.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
ber_decode(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
void **struct_ptr, const void *ptr, size_t size) {
|
|
||||||
asn_codec_ctx_t s_codec_ctx;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Stack checker requires that the codec context
|
|
||||||
* must be allocated on the stack.
|
|
||||||
*/
|
|
||||||
if(opt_codec_ctx) {
|
|
||||||
if(opt_codec_ctx->max_stack_size) {
|
|
||||||
s_codec_ctx = *opt_codec_ctx;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* If context is not given, be security-conscious anyway */
|
|
||||||
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
|
|
||||||
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific decoder.
|
|
||||||
*/
|
|
||||||
return type_descriptor->ber_decoder(opt_codec_ctx, type_descriptor,
|
|
||||||
struct_ptr, /* Pointer to the destination structure */
|
|
||||||
ptr, size, /* Buffer and its size */
|
|
||||||
0 /* Default tag mode is 0 */
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check the set of <TL<TL<TL...>>> tags matches the definition.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
ber_check_tags(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_TYPE_descriptor_t *td, asn_struct_ctx_t *opt_ctx,
|
|
||||||
const void *ptr, size_t size, int tag_mode, int last_tag_form,
|
|
||||||
ber_tlv_len_t *last_length, int *opt_tlv_form) {
|
|
||||||
ssize_t consumed_myself = 0;
|
|
||||||
ssize_t tag_len;
|
|
||||||
ssize_t len_len;
|
|
||||||
ber_tlv_tag_t tlv_tag;
|
|
||||||
ber_tlv_len_t tlv_len;
|
|
||||||
ber_tlv_len_t limit_len = -1;
|
|
||||||
int expect_00_terminators = 0;
|
|
||||||
int tlv_constr = -1; /* If CHOICE, opt_tlv_form is not given */
|
|
||||||
int step = opt_ctx ? opt_ctx->step : 0; /* Where we left previously */
|
|
||||||
int tagno;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure we didn't exceed the maximum stack size.
|
|
||||||
*/
|
|
||||||
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* So what does all this implicit skip stuff mean?
|
|
||||||
* Imagine two types,
|
|
||||||
* A ::= [5] IMPLICIT T
|
|
||||||
* B ::= [2] EXPLICIT T
|
|
||||||
* Where T is defined as
|
|
||||||
* T ::= [4] IMPLICIT SEQUENCE { ... }
|
|
||||||
*
|
|
||||||
* Let's say, we are starting to decode type A, given the
|
|
||||||
* following TLV stream: <5> <0>. What does this mean?
|
|
||||||
* It means that the type A contains type T which is,
|
|
||||||
* in turn, empty.
|
|
||||||
* Remember though, that we are still in A. We cannot
|
|
||||||
* just pass control to the type T decoder. Why? Because
|
|
||||||
* the type T decoder expects <4> <0>, not <5> <0>.
|
|
||||||
* So, we must make sure we are going to receive <5> while
|
|
||||||
* still in A, then pass control to the T decoder, indicating
|
|
||||||
* that the tag <4> was implicitly skipped. The decoder of T
|
|
||||||
* hence will be prepared to treat <4> as valid tag, and decode
|
|
||||||
* it appropriately.
|
|
||||||
*/
|
|
||||||
|
|
||||||
tagno = step /* Continuing where left previously */
|
|
||||||
+ (tag_mode==1?-1:0)
|
|
||||||
;
|
|
||||||
ASN_DEBUG("ber_check_tags(%s, size=%ld, tm=%d, step=%d, tagno=%d)",
|
|
||||||
td->name, (long)size, tag_mode, step, tagno);
|
|
||||||
/* assert(td->tags_count >= 1) May not be the case for CHOICE or ANY */
|
|
||||||
|
|
||||||
if(tag_mode == 0 && tagno == td->tags_count) {
|
|
||||||
/*
|
|
||||||
* This must be the _untagged_ ANY type,
|
|
||||||
* which outermost tag isn't known in advance.
|
|
||||||
* Fetch the tag and length separately.
|
|
||||||
*/
|
|
||||||
tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
|
|
||||||
switch(tag_len) {
|
|
||||||
case -1: RETURN(RC_FAIL);
|
|
||||||
case 0: RETURN(RC_WMORE);
|
|
||||||
}
|
|
||||||
tlv_constr = BER_TLV_CONSTRUCTED(ptr);
|
|
||||||
len_len = ber_fetch_length(tlv_constr,
|
|
||||||
(const char *)ptr + tag_len, size - tag_len, &tlv_len);
|
|
||||||
switch(len_len) {
|
|
||||||
case -1: RETURN(RC_FAIL);
|
|
||||||
case 0: RETURN(RC_WMORE);
|
|
||||||
}
|
|
||||||
ASN_DEBUG("Advancing %ld in ANY case",
|
|
||||||
(long)(tag_len + len_len));
|
|
||||||
ADVANCE(tag_len + len_len);
|
|
||||||
} else {
|
|
||||||
assert(tagno < td->tags_count); /* At least one loop */
|
|
||||||
}
|
|
||||||
for((void)tagno; tagno < td->tags_count; tagno++, step++) {
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fetch and process T from TLV.
|
|
||||||
*/
|
|
||||||
tag_len = ber_fetch_tag(ptr, size, &tlv_tag);
|
|
||||||
ASN_DEBUG("Fetching tag from {%p,%ld}: "
|
|
||||||
"len %ld, step %d, tagno %d got %s",
|
|
||||||
ptr, (long)size,
|
|
||||||
(long)tag_len, step, tagno,
|
|
||||||
ber_tlv_tag_string(tlv_tag));
|
|
||||||
switch(tag_len) {
|
|
||||||
case -1: RETURN(RC_FAIL);
|
|
||||||
case 0: RETURN(RC_WMORE);
|
|
||||||
}
|
|
||||||
|
|
||||||
tlv_constr = BER_TLV_CONSTRUCTED(ptr);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If {I}, don't check anything.
|
|
||||||
* If {I,B,C}, check B and C unless we're at I.
|
|
||||||
*/
|
|
||||||
if(tag_mode != 0 && step == 0) {
|
|
||||||
/*
|
|
||||||
* We don't expect tag to match here.
|
|
||||||
* It's just because we don't know how the tag
|
|
||||||
* is supposed to look like.
|
|
||||||
*/
|
|
||||||
} else {
|
|
||||||
assert(tagno >= 0); /* Guaranteed by the code above */
|
|
||||||
if(tlv_tag != td->tags[tagno]) {
|
|
||||||
/*
|
|
||||||
* Unexpected tag. Too bad.
|
|
||||||
*/
|
|
||||||
ASN_DEBUG("Expected: %s, "
|
|
||||||
"expectation failed (tn=%d, tm=%d)",
|
|
||||||
ber_tlv_tag_string(td->tags[tagno]),
|
|
||||||
tagno, tag_mode
|
|
||||||
);
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Attention: if there are more tags expected,
|
|
||||||
* ensure that the current tag is presented
|
|
||||||
* in constructed form (it contains other tags!).
|
|
||||||
* If this one is the last one, check that the tag form
|
|
||||||
* matches the one given in descriptor.
|
|
||||||
*/
|
|
||||||
if(tagno < (td->tags_count - 1)) {
|
|
||||||
if(tlv_constr == 0) {
|
|
||||||
ASN_DEBUG("tlv_constr = %d, expfail",
|
|
||||||
tlv_constr);
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if(last_tag_form != tlv_constr
|
|
||||||
&& last_tag_form != -1) {
|
|
||||||
ASN_DEBUG("last_tag_form %d != %d",
|
|
||||||
last_tag_form, tlv_constr);
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fetch and process L from TLV.
|
|
||||||
*/
|
|
||||||
len_len = ber_fetch_length(tlv_constr,
|
|
||||||
(const char *)ptr + tag_len, size - tag_len, &tlv_len);
|
|
||||||
ASN_DEBUG("Fetching len = %ld", (long)len_len);
|
|
||||||
switch(len_len) {
|
|
||||||
case -1: RETURN(RC_FAIL);
|
|
||||||
case 0: RETURN(RC_WMORE);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* FIXME
|
|
||||||
* As of today, the chain of tags
|
|
||||||
* must either contain several indefinite length TLVs,
|
|
||||||
* or several definite length ones.
|
|
||||||
* No mixing is allowed.
|
|
||||||
*/
|
|
||||||
if(tlv_len == -1) {
|
|
||||||
/*
|
|
||||||
* Indefinite length.
|
|
||||||
*/
|
|
||||||
if(limit_len == -1) {
|
|
||||||
expect_00_terminators++;
|
|
||||||
} else {
|
|
||||||
ASN_DEBUG("Unexpected indefinite length "
|
|
||||||
"in a chain of definite lengths");
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
ADVANCE(tag_len + len_len);
|
|
||||||
continue;
|
|
||||||
} else {
|
|
||||||
if(expect_00_terminators) {
|
|
||||||
ASN_DEBUG("Unexpected definite length "
|
|
||||||
"in a chain of indefinite lengths");
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check that multiple TLVs specify ever decreasing length,
|
|
||||||
* which is consistent.
|
|
||||||
*/
|
|
||||||
if(limit_len == -1) {
|
|
||||||
limit_len = tlv_len + tag_len + len_len;
|
|
||||||
if(limit_len < 0) {
|
|
||||||
/* Too great tlv_len value? */
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
} else if(limit_len != tlv_len + tag_len + len_len) {
|
|
||||||
/*
|
|
||||||
* Inner TLV specifies length which is inconsistent
|
|
||||||
* with the outer TLV's length value.
|
|
||||||
*/
|
|
||||||
ASN_DEBUG("Outer TLV is %ld and inner is %ld",
|
|
||||||
(long)limit_len, (long)tlv_len);
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
|
|
||||||
ADVANCE(tag_len + len_len);
|
|
||||||
|
|
||||||
limit_len -= (tag_len + len_len);
|
|
||||||
if((ssize_t)size > limit_len) {
|
|
||||||
/*
|
|
||||||
* Make sure that we won't consume more bytes
|
|
||||||
* from the parent frame than the inferred limit.
|
|
||||||
*/
|
|
||||||
size = limit_len;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(opt_tlv_form)
|
|
||||||
*opt_tlv_form = tlv_constr;
|
|
||||||
if(expect_00_terminators)
|
|
||||||
*last_length = -expect_00_terminators;
|
|
||||||
else
|
|
||||||
*last_length = tlv_len;
|
|
||||||
|
|
||||||
RETURN(RC_OK);
|
|
||||||
}
|
|
|
@ -1,64 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _BER_DECODER_H_
|
|
||||||
#define _BER_DECODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
struct asn_codec_ctx_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The BER decoder of any type.
|
|
||||||
* This function may be invoked directly from the application.
|
|
||||||
* The der_encode() function (der_encoder.h) is an opposite to ber_decode().
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t ber_decode(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size /* Size of that buffer */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of generic function which decodes the byte stream into the structure.
|
|
||||||
*/
|
|
||||||
typedef asn_dec_rval_t (ber_type_decoder_f)(
|
|
||||||
struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void **struct_ptr, const void *buf_ptr, size_t size,
|
|
||||||
int tag_mode);
|
|
||||||
|
|
||||||
/*******************************
|
|
||||||
* INTERNALLY USEFUL FUNCTIONS *
|
|
||||||
*******************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Check that all tags correspond to the type definition (as given in head).
|
|
||||||
* On return, last_length would contain either a non-negative length of the
|
|
||||||
* value part of the last TLV, or the negative number of expected
|
|
||||||
* "end of content" sequences. The number may only be negative if the
|
|
||||||
* head->last_tag_form is non-zero.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t ber_check_tags(
|
|
||||||
struct asn_codec_ctx_s *opt_codec_ctx, /* codec options */
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
asn_struct_ctx_t *opt_ctx, /* saved decoding context */
|
|
||||||
const void *ptr, size_t size,
|
|
||||||
int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
|
|
||||||
int last_tag_form, /* {-1,0:1}: any, primitive, constr */
|
|
||||||
ber_tlv_len_t *last_length,
|
|
||||||
int *opt_tlv_form /* optional tag form */
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _BER_DECODER_H_ */
|
|
|
@ -1,178 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <ber_tlv_length.h>
|
|
||||||
#include <ber_tlv_tag.h>
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
|
|
||||||
ber_tlv_len_t *len_r) {
|
|
||||||
const uint8_t *buf = (const uint8_t *)bufptr;
|
|
||||||
unsigned oct;
|
|
||||||
|
|
||||||
if(size == 0)
|
|
||||||
return 0; /* Want more */
|
|
||||||
|
|
||||||
oct = *(const uint8_t *)buf;
|
|
||||||
if((oct & 0x80) == 0) {
|
|
||||||
/*
|
|
||||||
* Short definite length.
|
|
||||||
*/
|
|
||||||
*len_r = oct; /* & 0x7F */
|
|
||||||
return 1;
|
|
||||||
} else {
|
|
||||||
ber_tlv_len_t len;
|
|
||||||
size_t skipped;
|
|
||||||
|
|
||||||
if(_is_constructed && oct == 0x80) {
|
|
||||||
*len_r = -1; /* Indefinite length */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(oct == 0xff) {
|
|
||||||
/* Reserved in standard for future use. */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
oct &= 0x7F; /* Leave only the 7 LS bits */
|
|
||||||
for(len = 0, buf++, skipped = 1;
|
|
||||||
oct && (++skipped <= size); buf++, oct--) {
|
|
||||||
|
|
||||||
len = (len << 8) | *buf;
|
|
||||||
if(len < 0
|
|
||||||
|| (len >> ((8 * sizeof(len)) - 8) && oct > 1)) {
|
|
||||||
/*
|
|
||||||
* Too large length value.
|
|
||||||
*/
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if(oct == 0) {
|
|
||||||
ber_tlv_len_t lenplusepsilon = (size_t)len + 1024;
|
|
||||||
/*
|
|
||||||
* Here length may be very close or equal to 2G.
|
|
||||||
* However, the arithmetics used in some decoders
|
|
||||||
* may add some (small) quantities to the length,
|
|
||||||
* to check the resulting value against some limits.
|
|
||||||
* This may result in integer wrap-around, which
|
|
||||||
* we try to avoid by checking it earlier here.
|
|
||||||
*/
|
|
||||||
if(lenplusepsilon < 0) {
|
|
||||||
/* Too large length value */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
*len_r = len;
|
|
||||||
return skipped;
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0; /* Want more */
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
ber_skip_length(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
int _is_constructed, const void *ptr, size_t size) {
|
|
||||||
ber_tlv_len_t vlen; /* Length of V in TLV */
|
|
||||||
ssize_t tl; /* Length of L in TLV */
|
|
||||||
ssize_t ll; /* Length of L in TLV */
|
|
||||||
size_t skip;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Make sure we didn't exceed the maximum stack size.
|
|
||||||
*/
|
|
||||||
if(_ASN_STACK_OVERFLOW_CHECK(opt_codec_ctx))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Determine the size of L in TLV.
|
|
||||||
*/
|
|
||||||
ll = ber_fetch_length(_is_constructed, ptr, size, &vlen);
|
|
||||||
if(ll <= 0) return ll;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Definite length.
|
|
||||||
*/
|
|
||||||
if(vlen >= 0) {
|
|
||||||
skip = ll + vlen;
|
|
||||||
if(skip > size)
|
|
||||||
return 0; /* Want more */
|
|
||||||
return skip;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Indefinite length!
|
|
||||||
*/
|
|
||||||
ASN_DEBUG("Skipping indefinite length");
|
|
||||||
for(skip = ll, ptr = ((const char *)ptr) + ll, size -= ll;;) {
|
|
||||||
ber_tlv_tag_t tag;
|
|
||||||
|
|
||||||
/* Fetch the tag */
|
|
||||||
tl = ber_fetch_tag(ptr, size, &tag);
|
|
||||||
if(tl <= 0) return tl;
|
|
||||||
|
|
||||||
ll = ber_skip_length(opt_codec_ctx,
|
|
||||||
BER_TLV_CONSTRUCTED(ptr),
|
|
||||||
((const char *)ptr) + tl, size - tl);
|
|
||||||
if(ll <= 0) return ll;
|
|
||||||
|
|
||||||
skip += tl + ll;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This may be the end of the indefinite length structure,
|
|
||||||
* two consecutive 0 octets.
|
|
||||||
* Check if it is true.
|
|
||||||
*/
|
|
||||||
if(((const uint8_t *)ptr)[0] == 0
|
|
||||||
&& ((const uint8_t *)ptr)[1] == 0)
|
|
||||||
return skip;
|
|
||||||
|
|
||||||
ptr = ((const char *)ptr) + tl + ll;
|
|
||||||
size -= tl + ll;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* UNREACHABLE */
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t
|
|
||||||
der_tlv_length_serialize(ber_tlv_len_t len, void *bufp, size_t size) {
|
|
||||||
size_t required_size; /* Size of len encoding */
|
|
||||||
uint8_t *buf = (uint8_t *)bufp;
|
|
||||||
uint8_t *end;
|
|
||||||
size_t i;
|
|
||||||
|
|
||||||
if(len <= 127) {
|
|
||||||
/* Encoded in 1 octet */
|
|
||||||
if(size) *buf = (uint8_t)len;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Compute the size of the subsequent bytes.
|
|
||||||
*/
|
|
||||||
for(required_size = 1, i = 8; i < 8 * sizeof(len); i += 8) {
|
|
||||||
if(len >> i)
|
|
||||||
required_size++;
|
|
||||||
else
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(size <= required_size)
|
|
||||||
return required_size + 1;
|
|
||||||
|
|
||||||
*buf++ = (uint8_t)(0x80 | required_size); /* Length of the encoding */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Produce the len encoding, space permitting.
|
|
||||||
*/
|
|
||||||
end = buf + required_size;
|
|
||||||
for(i -= 8; buf < end; i -= 8, buf++)
|
|
||||||
*buf = (uint8_t)(len >> i);
|
|
||||||
|
|
||||||
return required_size + 1;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,50 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _BER_TLV_LENGTH_H_
|
|
||||||
#define _BER_TLV_LENGTH_H_
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef ssize_t ber_tlv_len_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function tries to fetch the length of the BER TLV value and place it
|
|
||||||
* in *len_r.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* 0: More data expected than bufptr contains.
|
|
||||||
* -1: Fatal error deciphering length.
|
|
||||||
* >0: Number of bytes used from bufptr.
|
|
||||||
* On return with >0, len_r is constrained as -1..MAX, where -1 mean
|
|
||||||
* that the value is of indefinite length.
|
|
||||||
*/
|
|
||||||
ssize_t ber_fetch_length(int _is_constructed, const void *bufptr, size_t size,
|
|
||||||
ber_tlv_len_t *len_r);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function expects bufptr to be positioned over L in TLV.
|
|
||||||
* It returns number of bytes occupied by L and V together, suitable
|
|
||||||
* for skipping. The function properly handles indefinite length.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* Standard {-1,0,>0} convention.
|
|
||||||
*/
|
|
||||||
ssize_t ber_skip_length(
|
|
||||||
struct asn_codec_ctx_s *opt_codec_ctx, /* optional context */
|
|
||||||
int _is_constructed, const void *bufptr, size_t size);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function serializes the length (L from TLV) in DER format.
|
|
||||||
* It always returns number of bytes necessary to represent the length,
|
|
||||||
* it is a caller's responsibility to check the return value
|
|
||||||
* against the supplied buffer's size.
|
|
||||||
*/
|
|
||||||
size_t der_tlv_length_serialize(ber_tlv_len_t len, void *bufptr, size_t size);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _BER_TLV_LENGTH_H_ */
|
|
|
@ -1,144 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <ber_tlv_tag.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
ber_fetch_tag(const void *ptr, size_t size, ber_tlv_tag_t *tag_r) {
|
|
||||||
ber_tlv_tag_t val;
|
|
||||||
ber_tlv_tag_t tclass;
|
|
||||||
size_t skipped;
|
|
||||||
|
|
||||||
if(size == 0)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
val = *(const uint8_t *)ptr;
|
|
||||||
tclass = (val >> 6);
|
|
||||||
if((val &= 0x1F) != 0x1F) {
|
|
||||||
/*
|
|
||||||
* Simple form: everything encoded in a single octet.
|
|
||||||
* Tag Class is encoded using two least significant bits.
|
|
||||||
*/
|
|
||||||
*tag_r = (val << 2) | tclass;
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Each octet contains 7 bits of useful information.
|
|
||||||
* The MSB is 0 if it is the last octet of the tag.
|
|
||||||
*/
|
|
||||||
for(val = 0, ptr = ((const char *)ptr) + 1, skipped = 2;
|
|
||||||
skipped <= size;
|
|
||||||
ptr = ((const char *)ptr) + 1, skipped++) {
|
|
||||||
unsigned int oct = *(const uint8_t *)ptr;
|
|
||||||
if(oct & 0x80) {
|
|
||||||
val = (val << 7) | (oct & 0x7F);
|
|
||||||
/*
|
|
||||||
* Make sure there are at least 9 bits spare
|
|
||||||
* at the MS side of a value.
|
|
||||||
*/
|
|
||||||
if(val >> ((8 * sizeof(val)) - 9)) {
|
|
||||||
/*
|
|
||||||
* We would not be able to accomodate
|
|
||||||
* any more tag bits.
|
|
||||||
*/
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
val = (val << 7) | oct;
|
|
||||||
*tag_r = (val << 2) | tclass;
|
|
||||||
return skipped;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0; /* Want more */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *f) {
|
|
||||||
char buf[sizeof("[APPLICATION ]") + 32];
|
|
||||||
ssize_t ret;
|
|
||||||
|
|
||||||
ret = ber_tlv_tag_snprint(tag, buf, sizeof(buf));
|
|
||||||
if(ret >= (ssize_t)sizeof(buf) || ret < 2) {
|
|
||||||
errno = EPERM;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return fwrite(buf, 1, ret, f);
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t size) {
|
|
||||||
char *type = 0;
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
switch(tag & 0x3) {
|
|
||||||
case ASN_TAG_CLASS_UNIVERSAL: type = "UNIVERSAL "; break;
|
|
||||||
case ASN_TAG_CLASS_APPLICATION: type = "APPLICATION "; break;
|
|
||||||
case ASN_TAG_CLASS_CONTEXT: type = ""; break;
|
|
||||||
case ASN_TAG_CLASS_PRIVATE: type = "PRIVATE "; break;
|
|
||||||
}
|
|
||||||
|
|
||||||
ret = snprintf(buf, size, "[%s%u]", type, ((unsigned)tag) >> 2);
|
|
||||||
if(ret <= 0 && size) buf[0] = '\0'; /* against broken libc's */
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
char *
|
|
||||||
ber_tlv_tag_string(ber_tlv_tag_t tag) {
|
|
||||||
static char buf[sizeof("[APPLICATION ]") + 32];
|
|
||||||
|
|
||||||
(void)ber_tlv_tag_snprint(tag, buf, sizeof(buf));
|
|
||||||
|
|
||||||
return buf;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
size_t
|
|
||||||
ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufp, size_t size) {
|
|
||||||
int tclass = BER_TAG_CLASS(tag);
|
|
||||||
ber_tlv_tag_t tval = BER_TAG_VALUE(tag);
|
|
||||||
uint8_t *buf = (uint8_t *)bufp;
|
|
||||||
uint8_t *end;
|
|
||||||
size_t required_size;
|
|
||||||
size_t i;
|
|
||||||
|
|
||||||
if(tval <= 30) {
|
|
||||||
/* Encoded in 1 octet */
|
|
||||||
if(size) buf[0] = (tclass << 6) | tval;
|
|
||||||
return 1;
|
|
||||||
} else if(size) {
|
|
||||||
*buf++ = (tclass << 6) | 0x1F;
|
|
||||||
size--;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Compute the size of the subsequent bytes.
|
|
||||||
*/
|
|
||||||
for(required_size = 1, i = 7; i < 8 * sizeof(tval); i += 7) {
|
|
||||||
if(tval >> i)
|
|
||||||
required_size++;
|
|
||||||
else
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(size < required_size)
|
|
||||||
return required_size + 1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fill in the buffer, space permitting.
|
|
||||||
*/
|
|
||||||
end = buf + required_size - 1;
|
|
||||||
for(i -= 7; buf < end; i -= 7, buf++)
|
|
||||||
*buf = 0x80 | ((tval >> i) & 0x7F);
|
|
||||||
*buf = (tval & 0x7F); /* Last octet without high bit */
|
|
||||||
|
|
||||||
return required_size + 1;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,60 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _BER_TLV_TAG_H_
|
|
||||||
#define _BER_TLV_TAG_H_
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
enum asn_tag_class {
|
|
||||||
ASN_TAG_CLASS_UNIVERSAL = 0, /* 0b00 */
|
|
||||||
ASN_TAG_CLASS_APPLICATION = 1, /* 0b01 */
|
|
||||||
ASN_TAG_CLASS_CONTEXT = 2, /* 0b10 */
|
|
||||||
ASN_TAG_CLASS_PRIVATE = 3 /* 0b11 */
|
|
||||||
};
|
|
||||||
typedef unsigned ber_tlv_tag_t; /* BER TAG from Tag-Length-Value */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Tag class is encoded together with tag value for optimization purposes.
|
|
||||||
*/
|
|
||||||
#define BER_TAG_CLASS(tag) ((tag) & 0x3)
|
|
||||||
#define BER_TAG_VALUE(tag) ((tag) >> 2)
|
|
||||||
#define BER_TLV_CONSTRUCTED(tagptr) (((*(const uint8_t *)tagptr)&0x20)?1:0)
|
|
||||||
|
|
||||||
#define BER_TAGS_EQUAL(tag1, tag2) ((tag1) == (tag2))
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Several functions for printing the TAG in the canonical form
|
|
||||||
* (i.e. "[PRIVATE 0]").
|
|
||||||
* Return values correspond to their libc counterparts (if any).
|
|
||||||
*/
|
|
||||||
ssize_t ber_tlv_tag_snprint(ber_tlv_tag_t tag, char *buf, size_t buflen);
|
|
||||||
ssize_t ber_tlv_tag_fwrite(ber_tlv_tag_t tag, FILE *);
|
|
||||||
char *ber_tlv_tag_string(ber_tlv_tag_t tag);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function tries to fetch the tag from the input stream.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* 0: More data expected than bufptr contains.
|
|
||||||
* -1: Fatal error deciphering tag.
|
|
||||||
* >0: Number of bytes used from bufptr. tag_r will contain the tag.
|
|
||||||
*/
|
|
||||||
ssize_t ber_fetch_tag(const void *bufptr, size_t size, ber_tlv_tag_t *tag_r);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function serializes the tag (T from TLV) in BER format.
|
|
||||||
* It always returns number of bytes necessary to represent the tag,
|
|
||||||
* it is a caller's responsibility to check the return value
|
|
||||||
* against the supplied buffer's size.
|
|
||||||
*/
|
|
||||||
size_t ber_tlv_tag_serialize(ber_tlv_tag_t tag, void *bufptr, size_t size);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _BER_TLV_TAG_H_ */
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,59 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _CONSTR_CHOICE_H_
|
|
||||||
#define _CONSTR_CHOICE_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef const struct asn_CHOICE_specifics_s {
|
|
||||||
/*
|
|
||||||
* Target structure description.
|
|
||||||
*/
|
|
||||||
int struct_size; /* Size of the target structure. */
|
|
||||||
int ctx_offset; /* Offset of the asn_codec_ctx_t member */
|
|
||||||
int pres_offset; /* Identifier of the present member */
|
|
||||||
int pres_size; /* Size of the identifier (enum) */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Tags to members mapping table.
|
|
||||||
*/
|
|
||||||
const asn_TYPE_tag2member_t *tag2el;
|
|
||||||
int tag2el_count;
|
|
||||||
|
|
||||||
/* Canonical ordering of CHOICE elements, for PER */
|
|
||||||
int *canonical_order;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extensions-related stuff.
|
|
||||||
*/
|
|
||||||
int ext_start; /* First member of extensions, or -1 */
|
|
||||||
} asn_CHOICE_specifics_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A set specialized functions dealing with the CHOICE type.
|
|
||||||
*/
|
|
||||||
asn_struct_free_f CHOICE_free;
|
|
||||||
asn_struct_print_f CHOICE_print;
|
|
||||||
asn_constr_check_f CHOICE_constraint;
|
|
||||||
ber_type_decoder_f CHOICE_decode_ber;
|
|
||||||
der_type_encoder_f CHOICE_encode_der;
|
|
||||||
xer_type_decoder_f CHOICE_decode_xer;
|
|
||||||
xer_type_encoder_f CHOICE_encode_xer;
|
|
||||||
per_type_decoder_f CHOICE_decode_uper;
|
|
||||||
per_type_encoder_f CHOICE_encode_uper;
|
|
||||||
per_type_decoder_f CHOICE_decode_aper;
|
|
||||||
per_type_encoder_f CHOICE_encode_aper;
|
|
||||||
asn_outmost_tag_f CHOICE_outmost_tag;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _CONSTR_CHOICE_H_ */
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,62 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _CONSTR_SEQUENCE_H_
|
|
||||||
#define _CONSTR_SEQUENCE_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef const struct asn_SEQUENCE_specifics_s {
|
|
||||||
/*
|
|
||||||
* Target structure description.
|
|
||||||
*/
|
|
||||||
int struct_size; /* Size of the target structure. */
|
|
||||||
int ctx_offset; /* Offset of the asn_struct_ctx_t member */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Tags to members mapping table (sorted).
|
|
||||||
*/
|
|
||||||
const asn_TYPE_tag2member_t *tag2el;
|
|
||||||
int tag2el_count;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Optional members of the extensions root (roms) or additions (aoms).
|
|
||||||
* Meaningful for PER.
|
|
||||||
*/
|
|
||||||
const int *oms; /* Optional MemberS */
|
|
||||||
int roms_count; /* Root optional members count */
|
|
||||||
int aoms_count; /* Additions optional members count */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Description of an extensions group.
|
|
||||||
*/
|
|
||||||
int ext_after; /* Extensions start after this member */
|
|
||||||
int ext_before; /* Extensions stop before this member */
|
|
||||||
} asn_SEQUENCE_specifics_t;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A set specialized functions dealing with the SEQUENCE type.
|
|
||||||
*/
|
|
||||||
asn_struct_free_f SEQUENCE_free;
|
|
||||||
asn_struct_print_f SEQUENCE_print;
|
|
||||||
asn_constr_check_f SEQUENCE_constraint;
|
|
||||||
ber_type_decoder_f SEQUENCE_decode_ber;
|
|
||||||
der_type_encoder_f SEQUENCE_encode_der;
|
|
||||||
xer_type_decoder_f SEQUENCE_decode_xer;
|
|
||||||
xer_type_encoder_f SEQUENCE_encode_xer;
|
|
||||||
per_type_decoder_f SEQUENCE_decode_uper;
|
|
||||||
per_type_encoder_f SEQUENCE_encode_uper;
|
|
||||||
per_type_decoder_f SEQUENCE_decode_aper;
|
|
||||||
per_type_encoder_f SEQUENCE_encode_aper;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _CONSTR_SEQUENCE_H_ */
|
|
|
@ -1,275 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2006 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <constr_SEQUENCE_OF.h>
|
|
||||||
#include <asn_SEQUENCE_OF.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The DER encoder of the SEQUENCE OF type.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
SEQUENCE_OF_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
|
|
||||||
int tag_mode, ber_tlv_tag_t tag,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_TYPE_member_t *elm = td->elements;
|
|
||||||
asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(ptr);
|
|
||||||
size_t computed_size = 0;
|
|
||||||
ssize_t encoding_size = 0;
|
|
||||||
asn_enc_rval_t erval;
|
|
||||||
int edx;
|
|
||||||
|
|
||||||
ASN_DEBUG("Estimating size of SEQUENCE OF %s", td->name);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Gather the length of the underlying members sequence.
|
|
||||||
*/
|
|
||||||
for(edx = 0; edx < list->count; edx++) {
|
|
||||||
void *memb_ptr = list->array[edx];
|
|
||||||
if(!memb_ptr) continue;
|
|
||||||
erval = elm->type->der_encoder(elm->type, memb_ptr,
|
|
||||||
0, elm->tag,
|
|
||||||
0, 0);
|
|
||||||
if(erval.encoded == -1)
|
|
||||||
return erval;
|
|
||||||
computed_size += erval.encoded;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode the TLV for the sequence itself.
|
|
||||||
*/
|
|
||||||
encoding_size = der_write_tags(td, computed_size, tag_mode, 1, tag,
|
|
||||||
cb, app_key);
|
|
||||||
if(encoding_size == -1) {
|
|
||||||
erval.encoded = -1;
|
|
||||||
erval.failed_type = td;
|
|
||||||
erval.structure_ptr = ptr;
|
|
||||||
return erval;
|
|
||||||
}
|
|
||||||
|
|
||||||
computed_size += encoding_size;
|
|
||||||
if(!cb) {
|
|
||||||
erval.encoded = computed_size;
|
|
||||||
_ASN_ENCODED_OK(erval);
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding members of SEQUENCE OF %s", td->name);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode all members.
|
|
||||||
*/
|
|
||||||
for(edx = 0; edx < list->count; edx++) {
|
|
||||||
void *memb_ptr = list->array[edx];
|
|
||||||
if(!memb_ptr) continue;
|
|
||||||
erval = elm->type->der_encoder(elm->type, memb_ptr,
|
|
||||||
0, elm->tag,
|
|
||||||
cb, app_key);
|
|
||||||
if(erval.encoded == -1)
|
|
||||||
return erval;
|
|
||||||
encoding_size += erval.encoded;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(computed_size != (size_t)encoding_size) {
|
|
||||||
/*
|
|
||||||
* Encoded size is not equal to the computed size.
|
|
||||||
*/
|
|
||||||
erval.encoded = -1;
|
|
||||||
erval.failed_type = td;
|
|
||||||
erval.structure_ptr = ptr;
|
|
||||||
} else {
|
|
||||||
erval.encoded = computed_size;
|
|
||||||
erval.structure_ptr = 0;
|
|
||||||
erval.failed_type = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
return erval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
SEQUENCE_OF_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
int ilevel, enum xer_encoder_flags_e flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
asn_SET_OF_specifics_t *specs = (asn_SET_OF_specifics_t *)td->specifics;
|
|
||||||
asn_TYPE_member_t *elm = td->elements;
|
|
||||||
asn_anonymous_sequence_ *list = _A_SEQUENCE_FROM_VOID(sptr);
|
|
||||||
const char *mname = specs->as_XMLValueList
|
|
||||||
? 0 : ((*elm->name) ? elm->name : elm->type->xml_tag);
|
|
||||||
unsigned int mlen = mname ? strlen(mname) : 0;
|
|
||||||
int xcan = (flags & XER_F_CANONICAL);
|
|
||||||
int i;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
for(i = 0; i < list->count; i++) {
|
|
||||||
asn_enc_rval_t tmper;
|
|
||||||
void *memb_ptr = list->array[i];
|
|
||||||
if(!memb_ptr) continue;
|
|
||||||
|
|
||||||
if(mname) {
|
|
||||||
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel);
|
|
||||||
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
tmper = elm->type->xer_encoder(elm->type, memb_ptr,
|
|
||||||
ilevel + 1, flags, cb, app_key);
|
|
||||||
if(tmper.encoded == -1) return tmper;
|
|
||||||
if(tmper.encoded == 0 && specs->as_XMLValueList) {
|
|
||||||
const char *name = elm->type->xml_tag;
|
|
||||||
size_t len = strlen(name);
|
|
||||||
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel + 1);
|
|
||||||
_ASN_CALLBACK3("<", 1, name, len, "/>", 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
if(mname) {
|
|
||||||
_ASN_CALLBACK3("</", 2, mname, mlen, ">", 1);
|
|
||||||
er.encoded += 5;
|
|
||||||
}
|
|
||||||
|
|
||||||
er.encoded += (2 * mlen) + tmper.encoded;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
cb_failed:
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
SEQUENCE_OF_encode_uper(asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
asn_anonymous_sequence_ *list;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
asn_TYPE_member_t *elm = td->elements;
|
|
||||||
int seq;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
list = _A_SEQUENCE_FROM_VOID(sptr);
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding %s as SEQUENCE OF (%d)", td->name, list->count);
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->size;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->size;
|
|
||||||
else ct = 0;
|
|
||||||
|
|
||||||
/* If extensible constraint, check if size is in root */
|
|
||||||
if(ct) {
|
|
||||||
int not_in_root = (list->count < ct->lower_bound
|
|
||||||
|| list->count > ct->upper_bound);
|
|
||||||
ASN_DEBUG("lb %lld ub %lld %s",
|
|
||||||
ct->lower_bound, ct->upper_bound,
|
|
||||||
ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
/* Declare whether size is in extension root */
|
|
||||||
if(per_put_few_bits(po, not_in_root, 1))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
if(not_in_root) ct = 0;
|
|
||||||
} else if(not_in_root && ct->effective_bits >= 0)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->effective_bits >= 0) {
|
|
||||||
/* X.691, #19.5: No length determinant */
|
|
||||||
if(per_put_few_bits(po, list->count - ct->lower_bound,
|
|
||||||
ct->effective_bits))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
for(seq = -1; seq < list->count;) {
|
|
||||||
ssize_t mayEncode;
|
|
||||||
if(seq < 0) seq = 0;
|
|
||||||
if(ct && ct->effective_bits >= 0) {
|
|
||||||
mayEncode = list->count;
|
|
||||||
} else {
|
|
||||||
mayEncode = uper_put_length(po, list->count - seq);
|
|
||||||
if(mayEncode < 0) _ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
while(mayEncode--) {
|
|
||||||
void *memb_ptr = list->array[seq++];
|
|
||||||
if(!memb_ptr) _ASN_ENCODE_FAILED;
|
|
||||||
er = elm->type->uper_encoder(elm->type,
|
|
||||||
elm->per_constraints, memb_ptr, po);
|
|
||||||
if(er.encoded == -1)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
SEQUENCE_OF_encode_aper(asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
asn_anonymous_sequence_ *list;
|
|
||||||
asn_per_constraint_t *ct;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
asn_TYPE_member_t *elm = td->elements;
|
|
||||||
int seq;
|
|
||||||
|
|
||||||
if(!sptr) _ASN_ENCODE_FAILED;
|
|
||||||
list = _A_SEQUENCE_FROM_VOID(sptr);
|
|
||||||
|
|
||||||
er.encoded = 0;
|
|
||||||
|
|
||||||
ASN_DEBUG("Encoding %s as SEQUENCE OF size (%d) using ALIGNED PER", td->name, list->count);
|
|
||||||
|
|
||||||
if(constraints) ct = &constraints->size;
|
|
||||||
else if(td->per_constraints) ct = &td->per_constraints->size;
|
|
||||||
else ct = 0;
|
|
||||||
|
|
||||||
/* If extensible constraint, check if size is in root */
|
|
||||||
if(ct) {
|
|
||||||
int not_in_root = (list->count < ct->lower_bound
|
|
||||||
|| list->count > ct->upper_bound);
|
|
||||||
ASN_DEBUG("lb %lld ub %lld %s",
|
|
||||||
ct->lower_bound, ct->upper_bound,
|
|
||||||
ct->flags & APC_EXTENSIBLE ? "ext" : "fix");
|
|
||||||
if(ct->flags & APC_EXTENSIBLE) {
|
|
||||||
/* Declare whether size is in extension root */
|
|
||||||
if(per_put_few_bits(po, not_in_root, 1))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
if(not_in_root) ct = 0;
|
|
||||||
} else if(not_in_root && ct->effective_bits >= 0)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(ct && ct->effective_bits >= 0) {
|
|
||||||
/* X.691, #19.5: No length determinant */
|
|
||||||
// if(per_put_few_bits(po, list->count - ct->lower_bound,
|
|
||||||
// ct->effective_bits))
|
|
||||||
// _ASN_ENCODE_FAILED;
|
|
||||||
if (aper_put_length(po, ct->upper_bound - ct->lower_bound + 1, list->count - ct->lower_bound) < 0)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
for(seq = -1; seq < list->count;) {
|
|
||||||
ssize_t mayEncode;
|
|
||||||
if(seq < 0) seq = 0;
|
|
||||||
if(ct && ct->effective_bits >= 0) {
|
|
||||||
mayEncode = list->count;
|
|
||||||
} else {
|
|
||||||
mayEncode = aper_put_length(po, -1, list->count - seq);
|
|
||||||
if(mayEncode < 0) _ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
while(mayEncode--) {
|
|
||||||
void *memb_ptr = list->array[seq++];
|
|
||||||
if(!memb_ptr) _ASN_ENCODE_FAILED;
|
|
||||||
er = elm->type->aper_encoder(elm->type,
|
|
||||||
elm->per_constraints, memb_ptr, po);
|
|
||||||
if(er.encoded == -1)
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
}
|
|
|
@ -1,35 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _CONSTR_SEQUENCE_OF_H_
|
|
||||||
#define _CONSTR_SEQUENCE_OF_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <constr_SET_OF.h> /* Implemented using SET OF */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A set specialized functions dealing with the SEQUENCE OF type.
|
|
||||||
* Generally implemented using SET OF.
|
|
||||||
*/
|
|
||||||
#define SEQUENCE_OF_free SET_OF_free
|
|
||||||
#define SEQUENCE_OF_print SET_OF_print
|
|
||||||
#define SEQUENCE_OF_constraint SET_OF_constraint
|
|
||||||
#define SEQUENCE_OF_decode_ber SET_OF_decode_ber
|
|
||||||
#define SEQUENCE_OF_decode_xer SET_OF_decode_xer
|
|
||||||
#define SEQUENCE_OF_decode_uper SET_OF_decode_uper
|
|
||||||
#define SEQUENCE_OF_decode_aper SET_OF_decode_aper
|
|
||||||
der_type_encoder_f SEQUENCE_OF_encode_der;
|
|
||||||
xer_type_encoder_f SEQUENCE_OF_encode_xer;
|
|
||||||
per_type_encoder_f SEQUENCE_OF_encode_uper;
|
|
||||||
per_type_encoder_f SEQUENCE_OF_encode_aper;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _CONSTR_SET_OF_H_ */
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,44 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _CONSTR_SET_OF_H_
|
|
||||||
#define _CONSTR_SET_OF_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef const struct asn_SET_OF_specifics_s {
|
|
||||||
/*
|
|
||||||
* Target structure description.
|
|
||||||
*/
|
|
||||||
int struct_size; /* Size of the target structure. */
|
|
||||||
int ctx_offset; /* Offset of the asn_struct_ctx_t member */
|
|
||||||
|
|
||||||
/* XER-specific stuff */
|
|
||||||
int as_XMLValueList; /* The member type must be encoded like this */
|
|
||||||
} asn_SET_OF_specifics_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A set specialized functions dealing with the SET OF type.
|
|
||||||
*/
|
|
||||||
asn_struct_free_f SET_OF_free;
|
|
||||||
asn_struct_print_f SET_OF_print;
|
|
||||||
asn_constr_check_f SET_OF_constraint;
|
|
||||||
ber_type_decoder_f SET_OF_decode_ber;
|
|
||||||
der_type_encoder_f SET_OF_encode_der;
|
|
||||||
xer_type_decoder_f SET_OF_decode_xer;
|
|
||||||
xer_type_encoder_f SET_OF_encode_xer;
|
|
||||||
per_type_decoder_f SET_OF_decode_uper;
|
|
||||||
per_type_encoder_f SET_OF_encode_uper;
|
|
||||||
per_type_decoder_f SET_OF_decode_aper;
|
|
||||||
per_type_encoder_f SET_OF_encode_aper;
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _CONSTR_SET_OF_H_ */
|
|
|
@ -1,77 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <constr_TYPE.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Version of the ASN.1 infrastructure shipped with compiler.
|
|
||||||
*/
|
|
||||||
int get_asn1c_environment_version() { return ASN1C_ENVIRONMENT_VERSION; }
|
|
||||||
|
|
||||||
static asn_app_consume_bytes_f _print2fp;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Return the outmost tag of the type.
|
|
||||||
*/
|
|
||||||
ber_tlv_tag_t
|
|
||||||
asn_TYPE_outmost_tag(const asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
const void *struct_ptr, int tag_mode, ber_tlv_tag_t tag) {
|
|
||||||
|
|
||||||
if(tag_mode)
|
|
||||||
return tag;
|
|
||||||
|
|
||||||
if(type_descriptor->tags_count)
|
|
||||||
return type_descriptor->tags[0];
|
|
||||||
|
|
||||||
return type_descriptor->outmost_tag(type_descriptor, struct_ptr, 0, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Print the target language's structure in human readable form.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
asn_fprint(FILE *stream, asn_TYPE_descriptor_t *td, const void *struct_ptr) {
|
|
||||||
if(!stream) stream = stdout;
|
|
||||||
if(!td || !struct_ptr) {
|
|
||||||
errno = EINVAL;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Invoke type-specific printer */
|
|
||||||
if(td->print_struct(td, struct_ptr, 1, _print2fp, stream))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
/* Terminate the output */
|
|
||||||
if(_print2fp("\n", 1, stream))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return fflush(stream);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Dump the data into the specified stdio stream */
|
|
||||||
static int
|
|
||||||
_print2fp(const void *buffer, size_t size, void *app_key) {
|
|
||||||
FILE *stream = (FILE *)app_key;
|
|
||||||
|
|
||||||
if(fwrite(buffer, 1, size, stream) != size)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Some compilers do not support variable args macros.
|
|
||||||
* This function is a replacement of ASN_DEBUG() macro.
|
|
||||||
*/
|
|
||||||
void ASN_DEBUG_f(const char *fmt, ...);
|
|
||||||
void ASN_DEBUG_f(const char *fmt, ...) {
|
|
||||||
va_list ap;
|
|
||||||
va_start(ap, fmt);
|
|
||||||
vfprintf(stderr, fmt, ap);
|
|
||||||
fprintf(stderr, "\n");
|
|
||||||
va_end(ap);
|
|
||||||
}
|
|
|
@ -1,182 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
/*
|
|
||||||
* This file contains the declaration structure called "ASN.1 Type Definition",
|
|
||||||
* which holds all information necessary for encoding and decoding routines.
|
|
||||||
* This structure even contains pointer to these encoding and decoding routines
|
|
||||||
* for each defined ASN.1 type.
|
|
||||||
*/
|
|
||||||
#ifndef _CONSTR_TYPE_H_
|
|
||||||
#define _CONSTR_TYPE_H_
|
|
||||||
|
|
||||||
#include <ber_tlv_length.h>
|
|
||||||
#include <ber_tlv_tag.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
struct asn_TYPE_member_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This type provides the context information for various ASN.1 routines,
|
|
||||||
* primarily ones doing decoding. A member _asn_ctx of this type must be
|
|
||||||
* included into certain target language's structures, such as compound types.
|
|
||||||
*/
|
|
||||||
typedef struct asn_struct_ctx_s {
|
|
||||||
short phase; /* Decoding phase */
|
|
||||||
short step; /* Elementary step of a phase */
|
|
||||||
int context; /* Other context information */
|
|
||||||
void *ptr; /* Decoder-specific stuff (stack elements) */
|
|
||||||
ber_tlv_len_t left; /* Number of bytes left, -1 for indefinite */
|
|
||||||
} asn_struct_ctx_t;
|
|
||||||
|
|
||||||
#include <ber_decoder.h> /* Basic Encoding Rules decoder */
|
|
||||||
#include <der_encoder.h> /* Distinguished Encoding Rules encoder */
|
|
||||||
#include <xer_decoder.h> /* Decoder of XER (XML, text) */
|
|
||||||
#include <xer_encoder.h> /* Encoder into XER (XML, text) */
|
|
||||||
#include <per_decoder.h> /* Packet Encoding Rules decoder */
|
|
||||||
#include <per_encoder.h> /* Packet Encoding Rules encoder */
|
|
||||||
#include <constraints.h> /* Subtype constraints support */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Free the structure according to its specification.
|
|
||||||
* If (free_contents_only) is set, the wrapper structure itself (struct_ptr)
|
|
||||||
* will not be freed. (It may be useful in case the structure is allocated
|
|
||||||
* statically or arranged on the stack, yet its elements are allocated
|
|
||||||
* dynamically.)
|
|
||||||
*/
|
|
||||||
typedef void (asn_struct_free_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, int free_contents_only);
|
|
||||||
#define ASN_STRUCT_FREE(asn_DEF, ptr) (asn_DEF).free_struct(&(asn_DEF),ptr,0)
|
|
||||||
#define ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF, ptr) \
|
|
||||||
(asn_DEF).free_struct(&(asn_DEF),ptr,1)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Print the structure according to its specification.
|
|
||||||
*/
|
|
||||||
typedef int (asn_struct_print_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
const void *struct_ptr,
|
|
||||||
int level, /* Indentation level */
|
|
||||||
asn_app_consume_bytes_f *callback, void *app_key);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Return the outmost tag of the type.
|
|
||||||
* If the type is untagged CHOICE, the dynamic operation is performed.
|
|
||||||
* NOTE: This function pointer type is only useful internally.
|
|
||||||
* Do not use it in your application.
|
|
||||||
*/
|
|
||||||
typedef ber_tlv_tag_t (asn_outmost_tag_f)(
|
|
||||||
const struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
const void *struct_ptr, int tag_mode, ber_tlv_tag_t tag);
|
|
||||||
/* The instance of the above function type; used internally. */
|
|
||||||
asn_outmost_tag_f asn_TYPE_outmost_tag;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The definitive description of the destination language's structure.
|
|
||||||
*/
|
|
||||||
typedef struct asn_TYPE_descriptor_s {
|
|
||||||
const char *name; /* A name of the ASN.1 type. "" in some cases. */
|
|
||||||
const char *xml_tag; /* Name used in XML tag */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generalized functions for dealing with the specific type.
|
|
||||||
* May be directly invoked by applications.
|
|
||||||
*/
|
|
||||||
asn_struct_free_f *free_struct; /* Free the structure */
|
|
||||||
asn_struct_print_f *print_struct; /* Human readable output */
|
|
||||||
asn_constr_check_f *check_constraints; /* Constraints validator */
|
|
||||||
ber_type_decoder_f *ber_decoder; /* Generic BER decoder */
|
|
||||||
der_type_encoder_f *der_encoder; /* Canonical DER encoder */
|
|
||||||
xer_type_decoder_f *xer_decoder; /* Generic XER decoder */
|
|
||||||
xer_type_encoder_f *xer_encoder; /* [Canonical] XER encoder */
|
|
||||||
per_type_decoder_f *uper_decoder; /* Unaligned PER decoder */
|
|
||||||
per_type_encoder_f *uper_encoder; /* Unaligned PER encoder */
|
|
||||||
per_type_decoder_f *aper_decoder; /* Aligned PER decoder */
|
|
||||||
per_type_encoder_f *aper_encoder; /* Aligned PER encoder */
|
|
||||||
|
|
||||||
/***********************************************************************
|
|
||||||
* Internally useful members. Not to be used by applications directly. *
|
|
||||||
**********************************************************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Tags that are expected to occur.
|
|
||||||
*/
|
|
||||||
asn_outmost_tag_f *outmost_tag; /* <optional, internal> */
|
|
||||||
const ber_tlv_tag_t *tags; /* Effective tags sequence for this type */
|
|
||||||
int tags_count; /* Number of tags which are expected */
|
|
||||||
const ber_tlv_tag_t *all_tags; /* Every tag for BER/containment */
|
|
||||||
int all_tags_count; /* Number of tags */
|
|
||||||
|
|
||||||
asn_per_constraints_t *per_constraints; /* PER compiled constraints */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* An ASN.1 production type members (members of SEQUENCE, SET, CHOICE).
|
|
||||||
*/
|
|
||||||
struct asn_TYPE_member_s *elements;
|
|
||||||
int elements_count;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Additional information describing the type, used by appropriate
|
|
||||||
* functions above.
|
|
||||||
*/
|
|
||||||
const void *specifics;
|
|
||||||
} asn_TYPE_descriptor_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This type describes an element of the constructed type,
|
|
||||||
* i.e. SEQUENCE, SET, CHOICE, etc.
|
|
||||||
*/
|
|
||||||
enum asn_TYPE_flags_e {
|
|
||||||
ATF_NOFLAGS,
|
|
||||||
ATF_POINTER = 0x01, /* Represented by the pointer */
|
|
||||||
ATF_OPEN_TYPE = 0x02 /* ANY type, without meaningful tag */
|
|
||||||
};
|
|
||||||
typedef struct asn_TYPE_member_s {
|
|
||||||
enum asn_TYPE_flags_e flags; /* Element's presentation flags */
|
|
||||||
int optional; /* Following optional members, including current */
|
|
||||||
int memb_offset; /* Offset of the element */
|
|
||||||
ber_tlv_tag_t tag; /* Outmost (most immediate) tag */
|
|
||||||
int tag_mode; /* IMPLICIT/no/EXPLICIT tag at current level */
|
|
||||||
asn_TYPE_descriptor_t *type; /* Member type descriptor */
|
|
||||||
asn_constr_check_f *memb_constraints; /* Constraints validator */
|
|
||||||
asn_per_constraints_t *per_constraints; /* PER compiled constraints */
|
|
||||||
int (*default_value)(int setval, void **sptr); /* DEFAULT <value> */
|
|
||||||
const char *name; /* ASN.1 identifier of the element */
|
|
||||||
} asn_TYPE_member_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* BER tag to element number mapping.
|
|
||||||
*/
|
|
||||||
typedef struct asn_TYPE_tag2member_s {
|
|
||||||
ber_tlv_tag_t el_tag; /* Outmost tag of the member */
|
|
||||||
int el_no; /* Index of the associated member, base 0 */
|
|
||||||
int toff_first; /* First occurence of the el_tag, relative */
|
|
||||||
int toff_last; /* Last occurence of the el_tag, relatvie */
|
|
||||||
} asn_TYPE_tag2member_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function is a wrapper around (td)->print_struct, which prints out
|
|
||||||
* the contents of the target language's structure (struct_ptr) into the
|
|
||||||
* file pointer (stream) in human readable form.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* 0: The structure is printed.
|
|
||||||
* -1: Problem dumping the structure.
|
|
||||||
* (See also xer_fprint() in xer_encoder.h)
|
|
||||||
*/
|
|
||||||
int asn_fprint(FILE *stream, /* Destination stream descriptor */
|
|
||||||
asn_TYPE_descriptor_t *td, /* ASN.1 type descriptor */
|
|
||||||
const void *struct_ptr); /* Structure to be printed */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _CONSTR_TYPE_H_ */
|
|
|
@ -1,93 +0,0 @@
|
||||||
#include "asn_internal.h"
|
|
||||||
#include "constraints.h"
|
|
||||||
|
|
||||||
int
|
|
||||||
asn_generic_no_constraint(asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) {
|
|
||||||
|
|
||||||
(void)type_descriptor; /* Unused argument */
|
|
||||||
(void)struct_ptr; /* Unused argument */
|
|
||||||
(void)cb; /* Unused argument */
|
|
||||||
(void)key; /* Unused argument */
|
|
||||||
|
|
||||||
/* Nothing to check */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
asn_generic_unknown_constraint(asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
const void *struct_ptr, asn_app_constraint_failed_f *cb, void *key) {
|
|
||||||
|
|
||||||
(void)type_descriptor; /* Unused argument */
|
|
||||||
(void)struct_ptr; /* Unused argument */
|
|
||||||
(void)cb; /* Unused argument */
|
|
||||||
(void)key; /* Unused argument */
|
|
||||||
|
|
||||||
/* Unknown how to check */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct errbufDesc {
|
|
||||||
asn_TYPE_descriptor_t *failed_type;
|
|
||||||
const void *failed_struct_ptr;
|
|
||||||
char *errbuf;
|
|
||||||
size_t errlen;
|
|
||||||
};
|
|
||||||
|
|
||||||
static void
|
|
||||||
_asn_i_ctfailcb(void *key, asn_TYPE_descriptor_t *td, const void *sptr, const char *fmt, ...) {
|
|
||||||
struct errbufDesc *arg = key;
|
|
||||||
va_list ap;
|
|
||||||
ssize_t vlen;
|
|
||||||
ssize_t maxlen;
|
|
||||||
|
|
||||||
arg->failed_type = td;
|
|
||||||
arg->failed_struct_ptr = sptr;
|
|
||||||
|
|
||||||
maxlen = arg->errlen;
|
|
||||||
if(maxlen <= 0)
|
|
||||||
return;
|
|
||||||
|
|
||||||
va_start(ap, fmt);
|
|
||||||
vlen = vsnprintf(arg->errbuf, maxlen, fmt, ap);
|
|
||||||
va_end(ap);
|
|
||||||
if(vlen >= maxlen) {
|
|
||||||
arg->errbuf[maxlen-1] = '\0'; /* Ensuring libc correctness */
|
|
||||||
arg->errlen = maxlen - 1; /* Not counting termination */
|
|
||||||
return;
|
|
||||||
} else if(vlen >= 0) {
|
|
||||||
arg->errbuf[vlen] = '\0'; /* Ensuring libc correctness */
|
|
||||||
arg->errlen = vlen; /* Not counting termination */
|
|
||||||
} else {
|
|
||||||
/*
|
|
||||||
* The libc on this system is broken.
|
|
||||||
*/
|
|
||||||
vlen = sizeof("<broken vsnprintf>") - 1;
|
|
||||||
maxlen--;
|
|
||||||
arg->errlen = vlen < maxlen ? vlen : maxlen;
|
|
||||||
memcpy(arg->errbuf, "<broken vsnprintf>", arg->errlen);
|
|
||||||
arg->errbuf[arg->errlen] = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
asn_check_constraints(asn_TYPE_descriptor_t *type_descriptor,
|
|
||||||
const void *struct_ptr, char *errbuf, size_t *errlen) {
|
|
||||||
struct errbufDesc arg;
|
|
||||||
int ret;
|
|
||||||
|
|
||||||
arg.failed_type = 0;
|
|
||||||
arg.failed_struct_ptr = 0;
|
|
||||||
arg.errbuf = errbuf;
|
|
||||||
arg.errlen = errlen ? *errlen : 0;
|
|
||||||
|
|
||||||
ret = type_descriptor->check_constraints(type_descriptor,
|
|
||||||
struct_ptr, _asn_i_ctfailcb, &arg);
|
|
||||||
if(ret == -1 && errlen)
|
|
||||||
*errlen = arg.errlen;
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,63 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004, 2006 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _ASN1_CONSTRAINTS_VALIDATOR_H_
|
|
||||||
#define _ASN1_CONSTRAINTS_VALIDATOR_H_
|
|
||||||
|
|
||||||
#include <asn_system.h> /* Platform-dependent types */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Validate the structure according to the ASN.1 constraints.
|
|
||||||
* If errbuf and errlen are given, they shall be pointing to the appropriate
|
|
||||||
* buffer space and its length before calling this function. Alternatively,
|
|
||||||
* they could be passed as NULL's. If constraints validation fails,
|
|
||||||
* errlen will contain the actual number of bytes taken from the errbuf
|
|
||||||
* to encode an error message (properly 0-terminated).
|
|
||||||
*
|
|
||||||
* RETURN VALUES:
|
|
||||||
* This function returns 0 in case all ASN.1 constraints are met
|
|
||||||
* and -1 if one or more constraints were failed.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
asn_check_constraints(struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
const void *struct_ptr, /* Target language's structure */
|
|
||||||
char *errbuf, /* Returned error description */
|
|
||||||
size_t *errlen /* Length of the error description */
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generic type for constraint checking callback,
|
|
||||||
* associated with every type descriptor.
|
|
||||||
*/
|
|
||||||
typedef int (asn_constr_check_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
const void *struct_ptr,
|
|
||||||
asn_app_constraint_failed_f *optional_callback, /* Log the error */
|
|
||||||
void *optional_app_key /* Opaque key passed to a callback */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*******************************
|
|
||||||
* INTERNALLY USEFUL FUNCTIONS *
|
|
||||||
*******************************/
|
|
||||||
|
|
||||||
asn_constr_check_f asn_generic_no_constraint; /* No constraint whatsoever */
|
|
||||||
asn_constr_check_f asn_generic_unknown_constraint; /* Not fully supported */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke the callback with a complete error message.
|
|
||||||
*/
|
|
||||||
#define _ASN_CTFAIL if(ctfailcb) ctfailcb
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _ASN1_CONSTRAINTS_VALIDATOR_H_ */
|
|
|
@ -1,201 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key, int constructed);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The DER encoder of any type.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
der_encode(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr,
|
|
||||||
asn_app_consume_bytes_f *consume_bytes, void *app_key) {
|
|
||||||
|
|
||||||
ASN_DEBUG("DER encoder invoked for %s",
|
|
||||||
type_descriptor->name);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific encoder.
|
|
||||||
*/
|
|
||||||
return type_descriptor->der_encoder(type_descriptor,
|
|
||||||
struct_ptr, /* Pointer to the destination structure */
|
|
||||||
0, 0,
|
|
||||||
consume_bytes, app_key);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Argument type and callback necessary for der_encode_to_buffer().
|
|
||||||
*/
|
|
||||||
typedef struct enc_to_buf_arg {
|
|
||||||
void *buffer;
|
|
||||||
size_t left;
|
|
||||||
} enc_to_buf_arg;
|
|
||||||
static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
|
|
||||||
enc_to_buf_arg *arg = (enc_to_buf_arg *)key;
|
|
||||||
|
|
||||||
if(arg->left < size)
|
|
||||||
return -1; /* Data exceeds the available buffer size */
|
|
||||||
|
|
||||||
memcpy(arg->buffer, buffer, size);
|
|
||||||
arg->buffer = ((char *)arg->buffer) + size;
|
|
||||||
arg->left -= size;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A variant of the der_encode() which encodes the data into the provided buffer
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
der_encode_to_buffer(asn_TYPE_descriptor_t *type_descriptor, void *struct_ptr,
|
|
||||||
void *buffer, size_t buffer_size) {
|
|
||||||
enc_to_buf_arg arg;
|
|
||||||
asn_enc_rval_t ec;
|
|
||||||
|
|
||||||
arg.buffer = buffer;
|
|
||||||
arg.left = buffer_size;
|
|
||||||
|
|
||||||
ec = type_descriptor->der_encoder(type_descriptor,
|
|
||||||
struct_ptr, /* Pointer to the destination structure */
|
|
||||||
0, 0, encode_to_buffer_cb, &arg);
|
|
||||||
if(ec.encoded != -1) {
|
|
||||||
assert(ec.encoded == (ssize_t)(buffer_size - arg.left));
|
|
||||||
/* Return the encoded contents size */
|
|
||||||
}
|
|
||||||
return ec;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Write out leading TL[v] sequence according to the type definition.
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
der_write_tags(asn_TYPE_descriptor_t *sd,
|
|
||||||
size_t struct_length,
|
|
||||||
int tag_mode, int last_tag_form,
|
|
||||||
ber_tlv_tag_t tag, /* EXPLICIT or IMPLICIT tag */
|
|
||||||
asn_app_consume_bytes_f *cb,
|
|
||||||
void *app_key) {
|
|
||||||
const ber_tlv_tag_t *tags; /* Copy of tags stream */
|
|
||||||
int tags_count; /* Number of tags */
|
|
||||||
size_t overall_length;
|
|
||||||
ssize_t *lens;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
ASN_DEBUG("Writing tags (%s, tm=%d, tc=%d, tag=%s, mtc=%d)",
|
|
||||||
sd->name, tag_mode, sd->tags_count,
|
|
||||||
ber_tlv_tag_string(tag),
|
|
||||||
tag_mode
|
|
||||||
?(sd->tags_count+1
|
|
||||||
-((tag_mode == -1) && sd->tags_count))
|
|
||||||
:sd->tags_count
|
|
||||||
);
|
|
||||||
|
|
||||||
if(tag_mode) {
|
|
||||||
/*
|
|
||||||
* Instead of doing shaman dance like we do in ber_check_tags(),
|
|
||||||
* allocate a small array on the stack
|
|
||||||
* and initialize it appropriately.
|
|
||||||
*/
|
|
||||||
int stag_offset;
|
|
||||||
ber_tlv_tag_t *tags_buf;
|
|
||||||
tags_buf = (ber_tlv_tag_t *)alloca((sd->tags_count + 1) * sizeof(ber_tlv_tag_t));
|
|
||||||
if(!tags_buf) { /* Can fail on !x86 */
|
|
||||||
errno = ENOMEM;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
tags_count = sd->tags_count
|
|
||||||
+ 1 /* EXPLICIT or IMPLICIT tag is given */
|
|
||||||
- ((tag_mode == -1) && sd->tags_count);
|
|
||||||
/* Copy tags over */
|
|
||||||
tags_buf[0] = tag;
|
|
||||||
stag_offset = -1 + ((tag_mode == -1) && sd->tags_count);
|
|
||||||
for(i = 1; i < tags_count; i++)
|
|
||||||
tags_buf[i] = sd->tags[i + stag_offset];
|
|
||||||
tags = tags_buf;
|
|
||||||
} else {
|
|
||||||
tags = sd->tags;
|
|
||||||
tags_count = sd->tags_count;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* No tags to write */
|
|
||||||
if(tags_count == 0)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
lens = (ssize_t *)alloca(tags_count * sizeof(lens[0]));
|
|
||||||
if(!lens) {
|
|
||||||
errno = ENOMEM;
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Array of tags is initialized.
|
|
||||||
* Now, compute the size of the TLV pairs, from right to left.
|
|
||||||
*/
|
|
||||||
overall_length = struct_length;
|
|
||||||
for(i = tags_count - 1; i >= 0; --i) {
|
|
||||||
lens[i] = der_write_TL(tags[i], overall_length, 0, 0, 0);
|
|
||||||
if(lens[i] == -1) return -1;
|
|
||||||
overall_length += lens[i];
|
|
||||||
lens[i] = overall_length - lens[i];
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!cb) return overall_length - struct_length;
|
|
||||||
|
|
||||||
ASN_DEBUG("%s %s TL sequence (%d elements)",
|
|
||||||
cb?"Encoding":"Estimating", sd->name, tags_count);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode the TL sequence for real.
|
|
||||||
*/
|
|
||||||
for(i = 0; i < tags_count; i++) {
|
|
||||||
ssize_t len;
|
|
||||||
int _constr;
|
|
||||||
|
|
||||||
/* Check if this tag happens to be constructed */
|
|
||||||
_constr = (last_tag_form || i < (tags_count - 1));
|
|
||||||
|
|
||||||
len = der_write_TL(tags[i], lens[i], cb, app_key, _constr);
|
|
||||||
if(len == -1) return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return overall_length - struct_length;
|
|
||||||
}
|
|
||||||
|
|
||||||
static ssize_t
|
|
||||||
der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key,
|
|
||||||
int constructed) {
|
|
||||||
uint8_t buf[32];
|
|
||||||
size_t size = 0;
|
|
||||||
int buf_size = cb?sizeof(buf):0;
|
|
||||||
ssize_t tmp;
|
|
||||||
|
|
||||||
/* Serialize tag (T from TLV) into possibly zero-length buffer */
|
|
||||||
tmp = ber_tlv_tag_serialize(tag, buf, buf_size);
|
|
||||||
if(tmp == -1 || tmp > (ssize_t)sizeof(buf)) return -1;
|
|
||||||
size += tmp;
|
|
||||||
|
|
||||||
/* Serialize length (L from TLV) into possibly zero-length buffer */
|
|
||||||
tmp = der_tlv_length_serialize(len, buf+size, buf_size?buf_size-size:0);
|
|
||||||
if(tmp == -1) return -1;
|
|
||||||
size += tmp;
|
|
||||||
|
|
||||||
if(size > sizeof(buf))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If callback is specified, invoke it, and check its return value.
|
|
||||||
*/
|
|
||||||
if(cb) {
|
|
||||||
if(constructed) *buf |= 0x20;
|
|
||||||
if(cb(buf, size, app_key) < 0)
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
return size;
|
|
||||||
}
|
|
|
@ -1,68 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _DER_ENCODER_H_
|
|
||||||
#define _DER_ENCODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The DER encoder of any type. May be invoked by the application.
|
|
||||||
* The ber_decode() function (ber_decoder.h) is an opposite of der_encode().
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t der_encode(struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb,
|
|
||||||
void *app_key /* Arbitrary callback argument */
|
|
||||||
);
|
|
||||||
|
|
||||||
/* A variant of der_encode() which encodes data into the pre-allocated buffer */
|
|
||||||
asn_enc_rval_t der_encode_to_buffer(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
void *buffer, /* Pre-allocated buffer */
|
|
||||||
size_t buffer_size /* Initial buffer size (maximum) */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of the generic DER encoder.
|
|
||||||
*/
|
|
||||||
typedef asn_enc_rval_t (der_type_encoder_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
|
|
||||||
ber_tlv_tag_t tag,
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
|
|
||||||
void *app_key /* Arbitrary callback argument */
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
/*******************************
|
|
||||||
* INTERNALLY USEFUL FUNCTIONS *
|
|
||||||
*******************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Write out leading TL[v] sequence according to the type definition.
|
|
||||||
*/
|
|
||||||
ssize_t der_write_tags(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
size_t struct_length,
|
|
||||||
int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */
|
|
||||||
int last_tag_form, /* {0,!0}: prim, constructed */
|
|
||||||
ber_tlv_tag_t tag,
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb,
|
|
||||||
void *app_key
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _DER_ENCODER_H_ */
|
|
|
@ -1,176 +0,0 @@
|
||||||
#include <asn_application.h>
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <per_decoder.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decode a "Production of a complete encoding", X.691#10.1.
|
|
||||||
* The complete encoding contains at least one byte, and is an integral
|
|
||||||
* multiple of 8 bytes.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
uper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size) {
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
|
|
||||||
rval = uper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
|
|
||||||
if(rval.consumed) {
|
|
||||||
/*
|
|
||||||
* We've always given 8-aligned data,
|
|
||||||
* so convert bits to integral bytes.
|
|
||||||
*/
|
|
||||||
rval.consumed += 7;
|
|
||||||
rval.consumed >>= 3;
|
|
||||||
} else if(rval.code == RC_OK) {
|
|
||||||
if(size) {
|
|
||||||
if(((const uint8_t *)buffer)[0] == 0) {
|
|
||||||
rval.consumed = 1; /* 1 byte */
|
|
||||||
} else {
|
|
||||||
ASN_DEBUG("Expecting single zeroed byte");
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* Must contain at least 8 bits. */
|
|
||||||
rval.code = RC_WMORE;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
aper_decode_complete(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size) {
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
|
|
||||||
rval = aper_decode(opt_codec_ctx, td, sptr, buffer, size, 0, 0);
|
|
||||||
if(rval.consumed) {
|
|
||||||
/*
|
|
||||||
* We've always given 8-aligned data,
|
|
||||||
* so convert bits to integral bytes.
|
|
||||||
*/
|
|
||||||
rval.consumed += 7;
|
|
||||||
rval.consumed >>= 3;
|
|
||||||
} else if(rval.code == RC_OK) {
|
|
||||||
if(size) {
|
|
||||||
if(((uint8_t *)buffer)[0] == 0) {
|
|
||||||
rval.consumed = 1; /* 1 byte */
|
|
||||||
} else {
|
|
||||||
ASN_DEBUG("Expecting single zeroed byte");
|
|
||||||
rval.code = RC_FAIL;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* Must contain at least 8 bits. */
|
|
||||||
rval.code = RC_WMORE;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
uper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size, int skip_bits, int unused_bits) {
|
|
||||||
asn_codec_ctx_t s_codec_ctx;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
asn_per_data_t pd;
|
|
||||||
|
|
||||||
if(skip_bits < 0 || skip_bits > 7
|
|
||||||
|| unused_bits < 0 || unused_bits > 7
|
|
||||||
|| (unused_bits > 0 && !size))
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Stack checker requires that the codec context
|
|
||||||
* must be allocated on the stack.
|
|
||||||
*/
|
|
||||||
if(opt_codec_ctx) {
|
|
||||||
if(opt_codec_ctx->max_stack_size) {
|
|
||||||
s_codec_ctx = *opt_codec_ctx;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* If context is not given, be security-conscious anyway */
|
|
||||||
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
|
|
||||||
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Fill in the position indicator */
|
|
||||||
memset(&pd, 0, sizeof(pd));
|
|
||||||
pd.buffer = (const uint8_t *)buffer;
|
|
||||||
pd.nboff = skip_bits;
|
|
||||||
pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */
|
|
||||||
if(pd.nboff > pd.nbits)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific decoder.
|
|
||||||
*/
|
|
||||||
if(!td->uper_decoder)
|
|
||||||
_ASN_DECODE_FAILED; /* PER is not compiled in */
|
|
||||||
rval = td->uper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
/* Return the number of consumed bits */
|
|
||||||
rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
|
|
||||||
+ pd.nboff - skip_bits;
|
|
||||||
ASN_DEBUG("PER decoding consumed %ld, counted %ld",
|
|
||||||
(long)rval.consumed, (long)pd.moved);
|
|
||||||
assert(rval.consumed == pd.moved);
|
|
||||||
} else {
|
|
||||||
/* PER codec is not a restartable */
|
|
||||||
rval.consumed = 0;
|
|
||||||
}
|
|
||||||
return rval;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
aper_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, void **sptr, const void *buffer, size_t size, int skip_bits, int unused_bits) {
|
|
||||||
asn_codec_ctx_t s_codec_ctx;
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
asn_per_data_t pd;
|
|
||||||
|
|
||||||
if(skip_bits < 0 || skip_bits > 7
|
|
||||||
|| unused_bits < 0 || unused_bits > 7
|
|
||||||
|| (unused_bits > 0 && !size))
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Stack checker requires that the codec context
|
|
||||||
* must be allocated on the stack.
|
|
||||||
*/
|
|
||||||
if(opt_codec_ctx) {
|
|
||||||
if(opt_codec_ctx->max_stack_size) {
|
|
||||||
s_codec_ctx = *opt_codec_ctx;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* If context is not given, be security-conscious anyway */
|
|
||||||
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
|
|
||||||
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Fill in the position indicator */
|
|
||||||
memset(&pd, 0, sizeof(pd));
|
|
||||||
pd.buffer = (const uint8_t *)buffer;
|
|
||||||
pd.nboff = skip_bits;
|
|
||||||
pd.nbits = 8 * size - unused_bits; /* 8 is CHAR_BIT from <limits.h> */
|
|
||||||
if(pd.nboff > pd.nbits)
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific decoder.
|
|
||||||
*/
|
|
||||||
if(!td->aper_decoder)
|
|
||||||
_ASN_DECODE_FAILED; /* PER is not compiled in */
|
|
||||||
rval = td->aper_decoder(opt_codec_ctx, td, 0, sptr, &pd);
|
|
||||||
if(rval.code == RC_OK) {
|
|
||||||
/* Return the number of consumed bits */
|
|
||||||
rval.consumed = ((pd.buffer - (const uint8_t *)buffer) << 3)
|
|
||||||
+ pd.nboff - skip_bits;
|
|
||||||
ASN_DEBUG("PER decoding consumed %d, counted %d",
|
|
||||||
rval.consumed, pd.moved);
|
|
||||||
assert(rval.consumed == pd.moved);
|
|
||||||
} else {
|
|
||||||
/* PER codec is not a restartable */
|
|
||||||
rval.consumed = 0;
|
|
||||||
}
|
|
||||||
return rval;
|
|
||||||
}
|
|
|
@ -1,78 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2005, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _PER_DECODER_H_
|
|
||||||
#define _PER_DECODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <per_support.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Unaligned PER decoder of a "complete encoding" as per X.691#10.1.
|
|
||||||
* On success, this call always returns (.consumed >= 1), as per X.691#10.1.3.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t uper_decode_complete(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size /* Size of data buffer */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Unaligned PER decoder of any ASN.1 type. May be invoked by the application.
|
|
||||||
* WARNING: This call returns the number of BITS read from the stream. Beware.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t uper_decode(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size, /* Size of data buffer */
|
|
||||||
int skip_bits, /* Number of unused leading bits, 0..7 */
|
|
||||||
int unused_bits /* Number of unused tailing bits, 0..7 */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Aligned PER decoder of a "complete encoding" as per X.691#10.1.
|
|
||||||
* On success, this call always returns (.consumed >= 1), as per X.691#10.1.3.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t aper_decode_complete(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size /* Size of data buffer */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Aligned PER decoder of any ASN.1 type. May be invoked by the application.
|
|
||||||
* WARNING: This call returns the number of BITS read from the stream. Beware.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t aper_decode(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor, /* Type to decode */
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size, /* Size of data buffer */
|
|
||||||
int skip_bits, /* Number of unused leading bits, 0..7 */
|
|
||||||
int unused_bits /* Number of unused tailing bits, 0..7 */
|
|
||||||
);
|
|
||||||
/*
|
|
||||||
* Type of the type-specific PER decoder function.
|
|
||||||
*/
|
|
||||||
typedef asn_dec_rval_t (per_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
asn_per_constraints_t *constraints,
|
|
||||||
void **struct_ptr,
|
|
||||||
asn_per_data_t *per_data
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _PER_DECODER_H_ */
|
|
|
@ -1,244 +0,0 @@
|
||||||
#include <asn_application.h>
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <per_encoder.h>
|
|
||||||
|
|
||||||
static asn_enc_rval_t uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *, void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
|
|
||||||
|
|
||||||
static asn_enc_rval_t aper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *, void *sptr, asn_app_consume_bytes_f *cb, void *app_key);
|
|
||||||
asn_enc_rval_t
|
|
||||||
uper_encode(asn_TYPE_descriptor_t *td, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
return uper_encode_internal(td, 0, sptr, cb, app_key);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Argument type and callback necessary for uper_encode_to_buffer().
|
|
||||||
*/
|
|
||||||
typedef struct enc_to_buf_arg {
|
|
||||||
void *buffer;
|
|
||||||
size_t left;
|
|
||||||
} enc_to_buf_arg;
|
|
||||||
static int encode_to_buffer_cb(const void *buffer, size_t size, void *key) {
|
|
||||||
enc_to_buf_arg *arg = (enc_to_buf_arg *)key;
|
|
||||||
|
|
||||||
if(arg->left < size)
|
|
||||||
return -1; /* Data exceeds the available buffer size */
|
|
||||||
|
|
||||||
memcpy(arg->buffer, buffer, size);
|
|
||||||
arg->buffer = ((char *)arg->buffer) + size;
|
|
||||||
arg->left -= size;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
uper_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size) {
|
|
||||||
enc_to_buf_arg key;
|
|
||||||
|
|
||||||
key.buffer = buffer;
|
|
||||||
key.left = buffer_size;
|
|
||||||
|
|
||||||
if(td) ASN_DEBUG("Encoding \"%s\" using UNALIGNED PER", td->name);
|
|
||||||
|
|
||||||
return uper_encode_internal(td, 0, sptr, encode_to_buffer_cb, &key);
|
|
||||||
}
|
|
||||||
|
|
||||||
asn_enc_rval_t
|
|
||||||
aper_encode_to_buffer(asn_TYPE_descriptor_t *td, void *sptr, void *buffer, size_t buffer_size) {
|
|
||||||
enc_to_buf_arg key;
|
|
||||||
|
|
||||||
key.buffer = buffer;
|
|
||||||
key.left = buffer_size;
|
|
||||||
|
|
||||||
if(td) ASN_DEBUG("Encoding \"%s\" using ALIGNED PER", td->name);
|
|
||||||
|
|
||||||
return aper_encode_internal(td, 0, sptr, encode_to_buffer_cb, &key);
|
|
||||||
}
|
|
||||||
|
|
||||||
typedef struct enc_dyn_arg {
|
|
||||||
void *buffer;
|
|
||||||
size_t length;
|
|
||||||
size_t allocated;
|
|
||||||
} enc_dyn_arg;
|
|
||||||
static int
|
|
||||||
encode_dyn_cb(const void *buffer, size_t size, void *key) {
|
|
||||||
enc_dyn_arg *arg = key;
|
|
||||||
if(arg->length + size >= arg->allocated) {
|
|
||||||
void *p;
|
|
||||||
arg->allocated = arg->allocated ? (arg->allocated << 2) : size;
|
|
||||||
p = REALLOC(arg->buffer, arg->allocated);
|
|
||||||
if(!p) {
|
|
||||||
FREEMEM(arg->buffer);
|
|
||||||
memset(arg, 0, sizeof(*arg));
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
arg->buffer = p;
|
|
||||||
}
|
|
||||||
memcpy(((char *)arg->buffer) + arg->length, buffer, size);
|
|
||||||
arg->length += size;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
ssize_t
|
|
||||||
uper_encode_to_new_buffer(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, void **buffer_r) {
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
enc_dyn_arg key;
|
|
||||||
|
|
||||||
memset(&key, 0, sizeof(key));
|
|
||||||
|
|
||||||
er = uper_encode_internal(td, constraints, sptr, encode_dyn_cb, &key);
|
|
||||||
switch(er.encoded) {
|
|
||||||
case -1:
|
|
||||||
FREEMEM(key.buffer);
|
|
||||||
return -1;
|
|
||||||
case 0:
|
|
||||||
FREEMEM(key.buffer);
|
|
||||||
key.buffer = MALLOC(1);
|
|
||||||
if(key.buffer) {
|
|
||||||
*(char *)key.buffer = '\0';
|
|
||||||
*buffer_r = key.buffer;
|
|
||||||
return 1;
|
|
||||||
} else {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
*buffer_r = key.buffer;
|
|
||||||
ASN_DEBUG("Complete encoded in %ld bits", (long)er.encoded);
|
|
||||||
return ((er.encoded + 7) >> 3);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_encode_to_new_buffer(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, void **buffer_r) {
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
enc_dyn_arg key;
|
|
||||||
|
|
||||||
memset(&key, 0, sizeof(key));
|
|
||||||
|
|
||||||
er = aper_encode_internal(td, constraints, sptr, encode_dyn_cb, &key);
|
|
||||||
switch(er.encoded) {
|
|
||||||
case -1:
|
|
||||||
FREEMEM(key.buffer);
|
|
||||||
return -1;
|
|
||||||
case 0:
|
|
||||||
FREEMEM(key.buffer);
|
|
||||||
key.buffer = MALLOC(1);
|
|
||||||
if(key.buffer) {
|
|
||||||
*(char *)key.buffer = '\0';
|
|
||||||
*buffer_r = key.buffer;
|
|
||||||
return 1;
|
|
||||||
} else {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
*buffer_r = key.buffer;
|
|
||||||
ASN_DEBUG("Complete encoded in %d bits", er.encoded);
|
|
||||||
return ((er.encoded + 7) >> 3);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Internally useful functions.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Flush partially filled buffer */
|
|
||||||
static int
|
|
||||||
_uper_encode_flush_outp(asn_per_outp_t *po) {
|
|
||||||
uint8_t *buf;
|
|
||||||
|
|
||||||
if(po->nboff == 0 && po->buffer == po->tmpspace)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
buf = po->buffer + (po->nboff >> 3);
|
|
||||||
/* Make sure we account for the last, partially filled */
|
|
||||||
if(po->nboff & 0x07) {
|
|
||||||
buf[0] &= 0xff << (8 - (po->nboff & 0x07));
|
|
||||||
buf++;
|
|
||||||
}
|
|
||||||
|
|
||||||
return po->outper(po->tmpspace, buf - po->tmpspace, po->op_key);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
_aper_encode_flush_outp(asn_per_outp_t *po) {
|
|
||||||
uint8_t *buf;
|
|
||||||
|
|
||||||
if(po->nboff == 0 && po->buffer == po->tmpspace)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
buf = po->buffer + (po->nboff >> 3);
|
|
||||||
/* Make sure we account for the last, partially filled */
|
|
||||||
if(po->nboff & 0x07) {
|
|
||||||
buf[0] &= 0xff << (8 - (po->nboff & 0x07));
|
|
||||||
buf++;
|
|
||||||
}
|
|
||||||
|
|
||||||
return po->outper(po->tmpspace, buf - po->tmpspace, po->op_key);
|
|
||||||
}
|
|
||||||
|
|
||||||
static asn_enc_rval_t
|
|
||||||
uper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_per_outp_t po;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific encoder.
|
|
||||||
*/
|
|
||||||
if(!td || !td->uper_encoder)
|
|
||||||
_ASN_ENCODE_FAILED; /* PER is not compiled in */
|
|
||||||
|
|
||||||
po.buffer = po.tmpspace;
|
|
||||||
po.nboff = 0;
|
|
||||||
po.nbits = 8 * sizeof(po.tmpspace);
|
|
||||||
po.outper = cb;
|
|
||||||
po.op_key = app_key;
|
|
||||||
po.flushed_bytes = 0;
|
|
||||||
|
|
||||||
er = td->uper_encoder(td, constraints, sptr, &po);
|
|
||||||
if(er.encoded != -1) {
|
|
||||||
size_t bits_to_flush;
|
|
||||||
|
|
||||||
bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff;
|
|
||||||
|
|
||||||
/* Set number of bits encoded to a firm value */
|
|
||||||
er.encoded = (po.flushed_bytes << 3) + bits_to_flush;
|
|
||||||
|
|
||||||
if(_uper_encode_flush_outp(&po))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
return er;
|
|
||||||
}
|
|
||||||
|
|
||||||
static asn_enc_rval_t
|
|
||||||
aper_encode_internal(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_per_outp_t po;
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific encoder.
|
|
||||||
*/
|
|
||||||
if(!td || !td->aper_encoder)
|
|
||||||
_ASN_ENCODE_FAILED; /* PER is not compiled in */
|
|
||||||
|
|
||||||
po.buffer = po.tmpspace;
|
|
||||||
po.nboff = 0;
|
|
||||||
po.nbits = 8 * sizeof(po.tmpspace);
|
|
||||||
po.outper = cb;
|
|
||||||
po.op_key = app_key;
|
|
||||||
po.flushed_bytes = 0;
|
|
||||||
|
|
||||||
er = td->aper_encoder(td, constraints, sptr, &po);
|
|
||||||
if(er.encoded != -1) {
|
|
||||||
size_t bits_to_flush;
|
|
||||||
|
|
||||||
bits_to_flush = ((po.buffer - po.tmpspace) << 3) + po.nboff;
|
|
||||||
|
|
||||||
/* Set number of bits encoded to a firm value */
|
|
||||||
er.encoded = (po.flushed_bytes << 3) + bits_to_flush;
|
|
||||||
|
|
||||||
if(_aper_encode_flush_outp(&po))
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
return er;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,80 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2006, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _PER_ENCODER_H_
|
|
||||||
#define _PER_ENCODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <per_support.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Unaligned PER encoder of any ASN.1 type. May be invoked by the application.
|
|
||||||
* WARNING: This function returns the number of encoded bits in the .encoded
|
|
||||||
* field of the return value. Use the following formula to convert to bytes:
|
|
||||||
* bytes = ((.encoded + 7) / 8)
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t uper_encode(struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb, /* Data collector */
|
|
||||||
void *app_key /* Arbitrary callback argument */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* A variant of uper_encode() which encodes data into the existing buffer
|
|
||||||
* WARNING: This function returns the number of encoded bits in the .encoded
|
|
||||||
* field of the return value.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t uper_encode_to_buffer(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
void *buffer, /* Pre-allocated buffer */
|
|
||||||
size_t buffer_size /* Initial buffer size (max) */
|
|
||||||
);
|
|
||||||
|
|
||||||
asn_enc_rval_t aper_encode_to_buffer(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
void *buffer, /* Pre-allocated buffer */
|
|
||||||
size_t buffer_size /* Initial buffer size (max) */
|
|
||||||
);
|
|
||||||
/*
|
|
||||||
* A variant of uper_encode_to_buffer() which allocates buffer itself.
|
|
||||||
* Returns the number of bytes in the buffer or -1 in case of failure.
|
|
||||||
* WARNING: This function produces a "Production of the complete encoding",
|
|
||||||
* with length of at least one octet. Contrast this to precise bit-packing
|
|
||||||
* encoding of uper_encode() and uper_encode_to_buffer().
|
|
||||||
*/
|
|
||||||
ssize_t uper_encode_to_new_buffer(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
asn_per_constraints_t *constraints,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
void **buffer_r /* Buffer allocated and returned */
|
|
||||||
);
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_encode_to_new_buffer(struct asn_TYPE_descriptor_s *td,
|
|
||||||
asn_per_constraints_t *constraints,
|
|
||||||
void *sptr,
|
|
||||||
void **buffer_r);
|
|
||||||
/*
|
|
||||||
* Type of the generic PER encoder function.
|
|
||||||
*/
|
|
||||||
typedef asn_enc_rval_t (per_type_encoder_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
asn_per_constraints_t *constraints,
|
|
||||||
void *struct_ptr,
|
|
||||||
asn_per_outp_t *per_output
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _PER_ENCODER_H_ */
|
|
|
@ -1,407 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <per_support.h>
|
|
||||||
#include <constr_TYPE.h>
|
|
||||||
#include <per_opentype.h>
|
|
||||||
|
|
||||||
typedef struct uper_ugot_key {
|
|
||||||
asn_per_data_t oldpd; /* Old per data source */
|
|
||||||
size_t unclaimed;
|
|
||||||
size_t ot_moved; /* Number of bits moved by OT processing */
|
|
||||||
int repeat;
|
|
||||||
} uper_ugot_key;
|
|
||||||
|
|
||||||
static int uper_ugot_refill(asn_per_data_t *pd);
|
|
||||||
static int per_skip_bits(asn_per_data_t *pd, int skip_nbits);
|
|
||||||
static asn_dec_rval_t uper_sot_suck(asn_codec_ctx_t *, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encode an "open type field".
|
|
||||||
* #10.1, #10.2
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
uper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
void *buf;
|
|
||||||
void *bptr;
|
|
||||||
ssize_t size;
|
|
||||||
size_t toGo;
|
|
||||||
|
|
||||||
ASN_DEBUG("Open type put %s ...", td->name);
|
|
||||||
|
|
||||||
size = uper_encode_to_new_buffer(td, constraints, sptr, &buf);
|
|
||||||
if(size <= 0) return -1;
|
|
||||||
|
|
||||||
for(bptr = buf, toGo = size; toGo;) {
|
|
||||||
ssize_t maySave = uper_put_length(po, toGo);
|
|
||||||
ASN_DEBUG("Prepending length %d to %s and allowing to save %d",
|
|
||||||
(int)size, td->name, (int)maySave);
|
|
||||||
if(maySave < 0) break;
|
|
||||||
if(per_put_many_bits(po, bptr, maySave * 8)) break;
|
|
||||||
bptr = (char *)bptr + maySave;
|
|
||||||
toGo -= maySave;
|
|
||||||
}
|
|
||||||
|
|
||||||
FREEMEM(buf);
|
|
||||||
if(toGo) return -1;
|
|
||||||
|
|
||||||
ASN_DEBUG("Open type put %s of length %ld + overhead (1byte?)",
|
|
||||||
td->name, (long)size);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
aper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
|
|
||||||
void *buf;
|
|
||||||
void *bptr;
|
|
||||||
ssize_t size;
|
|
||||||
size_t toGo;
|
|
||||||
|
|
||||||
ASN_DEBUG("Open type put %s ...", td->name);
|
|
||||||
|
|
||||||
size = aper_encode_to_new_buffer(td, constraints, sptr, &buf);
|
|
||||||
if(size <= 0) return -1;
|
|
||||||
|
|
||||||
for(bptr = buf, toGo = size; toGo;) {
|
|
||||||
ssize_t maySave = aper_put_length(po, -1, toGo);
|
|
||||||
if(maySave < 0) break;
|
|
||||||
if(per_put_many_bits(po, bptr, maySave * 8)) break;
|
|
||||||
bptr = (char *)bptr + maySave;
|
|
||||||
toGo -= maySave;
|
|
||||||
}
|
|
||||||
|
|
||||||
FREEMEM(buf);
|
|
||||||
if(toGo) return -1;
|
|
||||||
|
|
||||||
ASN_DEBUG("Open type put %s of length %d + overhead (1byte?)",
|
|
||||||
td->name, size);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static asn_dec_rval_t
|
|
||||||
uper_open_type_get_simple(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
asn_dec_rval_t rv;
|
|
||||||
ssize_t chunk_bytes;
|
|
||||||
int repeat;
|
|
||||||
uint8_t *buf = 0;
|
|
||||||
size_t bufLen = 0;
|
|
||||||
size_t bufSize = 0;
|
|
||||||
asn_per_data_t spd;
|
|
||||||
size_t padding;
|
|
||||||
|
|
||||||
_ASN_STACK_OVERFLOW_CHECK(ctx);
|
|
||||||
|
|
||||||
ASN_DEBUG("Getting open type %s...", td->name);
|
|
||||||
|
|
||||||
do {
|
|
||||||
chunk_bytes = uper_get_length(pd, -1, &repeat);
|
|
||||||
if(chunk_bytes < 0) {
|
|
||||||
FREEMEM(buf);
|
|
||||||
_ASN_DECODE_STARVED;
|
|
||||||
}
|
|
||||||
if(bufLen + chunk_bytes > bufSize) {
|
|
||||||
void *ptr;
|
|
||||||
bufSize = chunk_bytes + (bufSize << 2);
|
|
||||||
ptr = REALLOC(buf, bufSize);
|
|
||||||
if(!ptr) {
|
|
||||||
FREEMEM(buf);
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
buf = ptr;
|
|
||||||
}
|
|
||||||
if(per_get_many_bits(pd, buf + bufLen, 0, chunk_bytes << 3)) {
|
|
||||||
FREEMEM(buf);
|
|
||||||
_ASN_DECODE_STARVED;
|
|
||||||
}
|
|
||||||
bufLen += chunk_bytes;
|
|
||||||
} while(repeat);
|
|
||||||
|
|
||||||
ASN_DEBUG("Getting open type %s encoded in %ld bytes", td->name,
|
|
||||||
(long)bufLen);
|
|
||||||
|
|
||||||
memset(&spd, 0, sizeof(spd));
|
|
||||||
spd.buffer = buf;
|
|
||||||
spd.nbits = bufLen << 3;
|
|
||||||
|
|
||||||
ASN_DEBUG_INDENT_ADD(+4);
|
|
||||||
rv = td->uper_decoder(ctx, td, constraints, sptr, &spd);
|
|
||||||
ASN_DEBUG_INDENT_ADD(-4);
|
|
||||||
|
|
||||||
if(rv.code == RC_OK) {
|
|
||||||
/* Check padding validity */
|
|
||||||
padding = spd.nbits - spd.nboff;
|
|
||||||
if ((padding < 8 ||
|
|
||||||
/* X.691#10.1.3 */
|
|
||||||
(spd.nboff == 0 && spd.nbits == 8 && spd.buffer == buf)) &&
|
|
||||||
per_get_few_bits(&spd, padding) == 0) {
|
|
||||||
/* Everything is cool */
|
|
||||||
FREEMEM(buf);
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
FREEMEM(buf);
|
|
||||||
if(padding >= 8) {
|
|
||||||
ASN_DEBUG("Too large padding %d in open type", (int)padding);
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
} else {
|
|
||||||
ASN_DEBUG("Non-zero padding");
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
FREEMEM(buf);
|
|
||||||
/* rv.code could be RC_WMORE, nonsense in this context */
|
|
||||||
rv.code = RC_FAIL; /* Noone would give us more */
|
|
||||||
}
|
|
||||||
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
|
|
||||||
static asn_dec_rval_t GCC_NOTUSED
|
|
||||||
uper_open_type_get_complex(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
uper_ugot_key arg;
|
|
||||||
asn_dec_rval_t rv;
|
|
||||||
ssize_t padding;
|
|
||||||
|
|
||||||
_ASN_STACK_OVERFLOW_CHECK(ctx);
|
|
||||||
|
|
||||||
ASN_DEBUG("Getting open type %s from %s", td->name,
|
|
||||||
per_data_string(pd));
|
|
||||||
arg.oldpd = *pd;
|
|
||||||
arg.unclaimed = 0;
|
|
||||||
arg.ot_moved = 0;
|
|
||||||
arg.repeat = 1;
|
|
||||||
pd->refill = uper_ugot_refill;
|
|
||||||
pd->refill_key = &arg;
|
|
||||||
pd->nbits = pd->nboff; /* 0 good bits at this point, will refill */
|
|
||||||
pd->moved = 0; /* This now counts the open type size in bits */
|
|
||||||
|
|
||||||
ASN_DEBUG_INDENT_ADD(+4);
|
|
||||||
rv = td->uper_decoder(ctx, td, constraints, sptr, pd);
|
|
||||||
ASN_DEBUG_INDENT_ADD(-4);
|
|
||||||
|
|
||||||
#define UPDRESTOREPD do { \
|
|
||||||
/* buffer and nboff are valid, preserve them. */ \
|
|
||||||
pd->nbits = arg.oldpd.nbits - (pd->moved - arg.ot_moved); \
|
|
||||||
pd->moved = arg.oldpd.moved + (pd->moved - arg.ot_moved); \
|
|
||||||
pd->refill = arg.oldpd.refill; \
|
|
||||||
pd->refill_key = arg.oldpd.refill_key; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
if(rv.code != RC_OK) {
|
|
||||||
UPDRESTOREPD;
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
|
|
||||||
per_data_string(pd),
|
|
||||||
per_data_string(&arg.oldpd),
|
|
||||||
(int)arg.unclaimed, (int)arg.repeat);
|
|
||||||
|
|
||||||
padding = pd->moved % 8;
|
|
||||||
if(padding) {
|
|
||||||
int32_t pvalue;
|
|
||||||
if(padding > 7) {
|
|
||||||
ASN_DEBUG("Too large padding %d in open type",
|
|
||||||
(int)padding);
|
|
||||||
rv.code = RC_FAIL;
|
|
||||||
UPDRESTOREPD;
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
padding = 8 - padding;
|
|
||||||
ASN_DEBUG("Getting padding of %d bits", (int)padding);
|
|
||||||
pvalue = per_get_few_bits(pd, padding);
|
|
||||||
switch(pvalue) {
|
|
||||||
case -1:
|
|
||||||
ASN_DEBUG("Padding skip failed");
|
|
||||||
UPDRESTOREPD;
|
|
||||||
_ASN_DECODE_STARVED;
|
|
||||||
case 0: break;
|
|
||||||
default:
|
|
||||||
ASN_DEBUG("Non-blank padding (%d bits 0x%02x)",
|
|
||||||
(int)padding, (int)pvalue);
|
|
||||||
UPDRESTOREPD;
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if(pd->nboff != pd->nbits) {
|
|
||||||
ASN_DEBUG("Open type %s overhead pd%s old%s", td->name,
|
|
||||||
per_data_string(pd), per_data_string(&arg.oldpd));
|
|
||||||
if(1) {
|
|
||||||
UPDRESTOREPD;
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
} else {
|
|
||||||
arg.unclaimed += pd->nbits - pd->nboff;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Adjust pd back so it points to original data */
|
|
||||||
UPDRESTOREPD;
|
|
||||||
|
|
||||||
/* Skip data not consumed by the decoder */
|
|
||||||
if(arg.unclaimed) {
|
|
||||||
ASN_DEBUG("Getting unclaimed %d", (int)arg.unclaimed);
|
|
||||||
switch(per_skip_bits(pd, arg.unclaimed)) {
|
|
||||||
case -1:
|
|
||||||
ASN_DEBUG("Claim of %d failed", (int)arg.unclaimed);
|
|
||||||
_ASN_DECODE_STARVED;
|
|
||||||
case 0:
|
|
||||||
ASN_DEBUG("Got claim of %d", (int)arg.unclaimed);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
/* Padding must be blank */
|
|
||||||
ASN_DEBUG("Non-blank unconsumed padding");
|
|
||||||
_ASN_DECODE_FAILED;
|
|
||||||
}
|
|
||||||
arg.unclaimed = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(arg.repeat) {
|
|
||||||
ASN_DEBUG("Not consumed the whole thing");
|
|
||||||
rv.code = RC_FAIL;
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
asn_dec_rval_t
|
|
||||||
uper_open_type_get(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
|
|
||||||
return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
uper_open_type_skip(asn_codec_ctx_t *ctx, asn_per_data_t *pd) {
|
|
||||||
asn_TYPE_descriptor_t s_td;
|
|
||||||
asn_dec_rval_t rv;
|
|
||||||
|
|
||||||
s_td.name = "<unknown extension>";
|
|
||||||
s_td.uper_decoder = uper_sot_suck;
|
|
||||||
|
|
||||||
rv = uper_open_type_get(ctx, &s_td, 0, 0, pd);
|
|
||||||
if(rv.code != RC_OK)
|
|
||||||
return -1;
|
|
||||||
else
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Internal functions.
|
|
||||||
*/
|
|
||||||
|
|
||||||
static asn_dec_rval_t
|
|
||||||
uper_sot_suck(asn_codec_ctx_t *ctx, asn_TYPE_descriptor_t *td,
|
|
||||||
asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
|
|
||||||
asn_dec_rval_t rv;
|
|
||||||
|
|
||||||
(void)ctx;
|
|
||||||
(void)td;
|
|
||||||
(void)constraints;
|
|
||||||
(void)sptr;
|
|
||||||
|
|
||||||
while(per_get_few_bits(pd, 24) >= 0);
|
|
||||||
|
|
||||||
rv.code = RC_OK;
|
|
||||||
rv.consumed = pd->moved;
|
|
||||||
|
|
||||||
return rv;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
uper_ugot_refill(asn_per_data_t *pd) {
|
|
||||||
uper_ugot_key *arg = pd->refill_key;
|
|
||||||
ssize_t next_chunk_bytes, next_chunk_bits;
|
|
||||||
ssize_t avail;
|
|
||||||
|
|
||||||
asn_per_data_t *oldpd = &arg->oldpd;
|
|
||||||
|
|
||||||
ASN_DEBUG("REFILLING pd->moved=%ld, oldpd->moved=%ld",
|
|
||||||
(long)pd->moved, (long)oldpd->moved);
|
|
||||||
|
|
||||||
/* Advance our position to where pd is */
|
|
||||||
oldpd->buffer = pd->buffer;
|
|
||||||
oldpd->nboff = pd->nboff;
|
|
||||||
oldpd->nbits -= pd->moved - arg->ot_moved;
|
|
||||||
oldpd->moved += pd->moved - arg->ot_moved;
|
|
||||||
arg->ot_moved = pd->moved;
|
|
||||||
|
|
||||||
if(arg->unclaimed) {
|
|
||||||
/* Refill the container */
|
|
||||||
if(per_get_few_bits(oldpd, 1))
|
|
||||||
return -1;
|
|
||||||
if(oldpd->nboff == 0) {
|
|
||||||
assert(0);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
pd->buffer = oldpd->buffer;
|
|
||||||
pd->nboff = oldpd->nboff - 1;
|
|
||||||
pd->nbits = oldpd->nbits;
|
|
||||||
ASN_DEBUG("UNCLAIMED <- return from (pd->moved=%ld)",
|
|
||||||
(long)pd->moved);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if(!arg->repeat) {
|
|
||||||
ASN_DEBUG("Want more but refill doesn't have it");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
next_chunk_bytes = uper_get_length(oldpd, -1, &arg->repeat);
|
|
||||||
ASN_DEBUG("Open type LENGTH %ld bytes at off %ld, repeat %ld",
|
|
||||||
(long)next_chunk_bytes, (long)oldpd->moved, (long)arg->repeat);
|
|
||||||
if(next_chunk_bytes < 0) return -1;
|
|
||||||
if(next_chunk_bytes == 0) {
|
|
||||||
pd->refill = 0; /* No more refills, naturally */
|
|
||||||
assert(!arg->repeat); /* Implementation guarantee */
|
|
||||||
}
|
|
||||||
next_chunk_bits = next_chunk_bytes << 3;
|
|
||||||
avail = oldpd->nbits - oldpd->nboff;
|
|
||||||
if(avail >= next_chunk_bits) {
|
|
||||||
pd->nbits = oldpd->nboff + next_chunk_bits;
|
|
||||||
arg->unclaimed = 0;
|
|
||||||
ASN_DEBUG("!+Parent frame %ld bits, alloting %ld [%ld..%ld] (%ld)",
|
|
||||||
(long)next_chunk_bits, (long)oldpd->moved,
|
|
||||||
(long)oldpd->nboff, (long)oldpd->nbits,
|
|
||||||
(long)(oldpd->nbits - oldpd->nboff));
|
|
||||||
} else {
|
|
||||||
pd->nbits = oldpd->nbits;
|
|
||||||
arg->unclaimed = next_chunk_bits - avail;
|
|
||||||
ASN_DEBUG("!-Parent frame %ld, require %ld, will claim %ld",
|
|
||||||
(long)avail, (long)next_chunk_bits,
|
|
||||||
(long)arg->unclaimed);
|
|
||||||
}
|
|
||||||
pd->buffer = oldpd->buffer;
|
|
||||||
pd->nboff = oldpd->nboff;
|
|
||||||
ASN_DEBUG("Refilled pd%s old%s",
|
|
||||||
per_data_string(pd), per_data_string(oldpd));
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
per_skip_bits(asn_per_data_t *pd, int skip_nbits) {
|
|
||||||
int hasNonZeroBits = 0;
|
|
||||||
while(skip_nbits > 0) {
|
|
||||||
int skip;
|
|
||||||
|
|
||||||
/* per_get_few_bits() is more efficient when nbits <= 24 */
|
|
||||||
if(skip_nbits < 24)
|
|
||||||
skip = skip_nbits;
|
|
||||||
else
|
|
||||||
skip = 24;
|
|
||||||
skip_nbits -= skip;
|
|
||||||
|
|
||||||
switch(per_get_few_bits(pd, skip)) {
|
|
||||||
case -1: return -1; /* Starving */
|
|
||||||
case 0: continue; /* Skipped empty space */
|
|
||||||
default: hasNonZeroBits = 1; continue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return hasNonZeroBits;
|
|
||||||
}
|
|
|
@ -1,24 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _PER_OPENTYPE_H_
|
|
||||||
#define _PER_OPENTYPE_H_
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
asn_dec_rval_t uper_open_type_get(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd);
|
|
||||||
|
|
||||||
int uper_open_type_skip(asn_codec_ctx_t *opt_codec_ctx, asn_per_data_t *pd);
|
|
||||||
|
|
||||||
int uper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po);
|
|
||||||
|
|
||||||
int aper_open_type_put(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _PER_OPENTYPE_H_ */
|
|
|
@ -1,679 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2005-2014 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_system.h>
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <per_support.h>
|
|
||||||
|
|
||||||
char *
|
|
||||||
per_data_string(asn_per_data_t *pd) {
|
|
||||||
static char buf[2][32];
|
|
||||||
static int n;
|
|
||||||
n = (n+1) % 2;
|
|
||||||
snprintf(buf[n], sizeof(buf),
|
|
||||||
"{m=%ld span %+ld[%d..%d] (%d)}",
|
|
||||||
(long)pd->moved,
|
|
||||||
(((long)pd->buffer) & 0xf),
|
|
||||||
(int)pd->nboff, (int)pd->nbits,
|
|
||||||
(int)(pd->nbits - pd->nboff));
|
|
||||||
return buf[n];
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
per_get_undo(asn_per_data_t *pd, int nbits) {
|
|
||||||
if((ssize_t)pd->nboff < nbits) {
|
|
||||||
assert((ssize_t)pd->nboff < nbits);
|
|
||||||
} else {
|
|
||||||
pd->nboff -= nbits;
|
|
||||||
pd->moved -= nbits;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int32_t
|
|
||||||
aper_get_align(asn_per_data_t *pd) {
|
|
||||||
|
|
||||||
if(pd->nboff & 0x7) {
|
|
||||||
ASN_DEBUG("Aligning %d bits", 8 - (pd->nboff & 0x7));
|
|
||||||
return per_get_few_bits(pd, 8 - (pd->nboff & 0x7));
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extract a small number of bits (<= 31) from the specified PER data pointer.
|
|
||||||
*/
|
|
||||||
int32_t
|
|
||||||
per_get_few_bits(asn_per_data_t *pd, int nbits) {
|
|
||||||
size_t off; /* Next after last bit offset */
|
|
||||||
ssize_t nleft; /* Number of bits left in this stream */
|
|
||||||
uint32_t accum;
|
|
||||||
const uint8_t *buf;
|
|
||||||
|
|
||||||
if(nbits < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
nleft = pd->nbits - pd->nboff;
|
|
||||||
if(nbits > nleft) {
|
|
||||||
int32_t tailv, vhead;
|
|
||||||
if(!pd->refill || nbits > 31) return -1;
|
|
||||||
/* Accumulate unused bytes before refill */
|
|
||||||
ASN_DEBUG("Obtain the rest %d bits (want %d)",
|
|
||||||
(int)nleft, (int)nbits);
|
|
||||||
tailv = per_get_few_bits(pd, nleft);
|
|
||||||
if(tailv < 0) return -1;
|
|
||||||
/* Refill (replace pd contents with new data) */
|
|
||||||
if(pd->refill(pd))
|
|
||||||
return -1;
|
|
||||||
nbits -= nleft;
|
|
||||||
vhead = per_get_few_bits(pd, nbits);
|
|
||||||
/* Combine the rest of previous pd with the head of new one */
|
|
||||||
tailv = (tailv << nbits) | vhead; /* Could == -1 */
|
|
||||||
return tailv;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Normalize position indicator.
|
|
||||||
*/
|
|
||||||
if(pd->nboff >= 8) {
|
|
||||||
pd->buffer += (pd->nboff >> 3);
|
|
||||||
pd->nbits -= (pd->nboff & ~0x07);
|
|
||||||
pd->nboff &= 0x07;
|
|
||||||
}
|
|
||||||
pd->moved += nbits;
|
|
||||||
pd->nboff += nbits;
|
|
||||||
off = pd->nboff;
|
|
||||||
buf = pd->buffer;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extract specified number of bits.
|
|
||||||
*/
|
|
||||||
if(off <= 8)
|
|
||||||
accum = nbits ? (buf[0]) >> (8 - off) : 0;
|
|
||||||
else if(off <= 16)
|
|
||||||
accum = ((buf[0] << 8) + buf[1]) >> (16 - off);
|
|
||||||
else if(off <= 24)
|
|
||||||
accum = ((buf[0] << 16) + (buf[1] << 8) + buf[2]) >> (24 - off);
|
|
||||||
else if(off <= 31)
|
|
||||||
accum = ((buf[0] << 24) + (buf[1] << 16)
|
|
||||||
+ (buf[2] << 8) + (buf[3])) >> (32 - off);
|
|
||||||
else if(nbits <= 31) {
|
|
||||||
asn_per_data_t tpd = *pd;
|
|
||||||
/* Here are we with our 31-bits limit plus 1..7 bits offset. */
|
|
||||||
per_get_undo(&tpd, nbits);
|
|
||||||
/* The number of available bits in the stream allow
|
|
||||||
* for the following operations to take place without
|
|
||||||
* invoking the ->refill() function */
|
|
||||||
accum = per_get_few_bits(&tpd, nbits - 24) << 24;
|
|
||||||
accum |= per_get_few_bits(&tpd, 24);
|
|
||||||
} else {
|
|
||||||
per_get_undo(pd, nbits);
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
accum &= (((uint32_t)1 << nbits) - 1);
|
|
||||||
|
|
||||||
ASN_DEBUG(" [PER got %2d<=%2d bits => span %d %+ld[%d..%d]:%02x (%d) => 0x%02x]",
|
|
||||||
(int)nbits, (int)nleft,
|
|
||||||
(int)pd->moved,
|
|
||||||
(((long)pd->buffer) & 0xf),
|
|
||||||
(int)pd->nboff, (int)pd->nbits,
|
|
||||||
pd->buffer[0],
|
|
||||||
(int)(pd->nbits - pd->nboff),
|
|
||||||
(int)accum);
|
|
||||||
|
|
||||||
return accum;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extract a large number of bits from the specified PER data pointer.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int alright, int nbits) {
|
|
||||||
int32_t value;
|
|
||||||
|
|
||||||
ASN_DEBUG("align: %s, nbits %d", alright ? "YES":"NO", nbits);
|
|
||||||
|
|
||||||
if(alright && (nbits & 7)) {
|
|
||||||
/* Perform right alignment of a first few bits */
|
|
||||||
value = per_get_few_bits(pd, nbits & 0x07);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
*dst++ = value; /* value is already right-aligned */
|
|
||||||
nbits &= ~7;
|
|
||||||
}
|
|
||||||
|
|
||||||
while(nbits) {
|
|
||||||
if(nbits >= 24) {
|
|
||||||
value = per_get_few_bits(pd, 24);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
*(dst++) = value >> 16;
|
|
||||||
*(dst++) = value >> 8;
|
|
||||||
*(dst++) = value;
|
|
||||||
nbits -= 24;
|
|
||||||
} else {
|
|
||||||
value = per_get_few_bits(pd, nbits);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
if(nbits & 7) { /* implies left alignment */
|
|
||||||
value <<= 8 - (nbits & 7),
|
|
||||||
nbits += 8 - (nbits & 7);
|
|
||||||
if(nbits > 24)
|
|
||||||
*dst++ = value >> 24;
|
|
||||||
}
|
|
||||||
if(nbits > 16)
|
|
||||||
*dst++ = value >> 16;
|
|
||||||
if(nbits > 8)
|
|
||||||
*dst++ = value >> 8;
|
|
||||||
*dst++ = value;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the length "n" from the stream.
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
uper_get_length(asn_per_data_t *pd, int ebits, int *repeat) {
|
|
||||||
ssize_t value;
|
|
||||||
|
|
||||||
*repeat = 0;
|
|
||||||
|
|
||||||
if(ebits >= 0) return per_get_few_bits(pd, ebits);
|
|
||||||
|
|
||||||
value = per_get_few_bits(pd, 8);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
if((value & 128) == 0) /* #10.9.3.6 */
|
|
||||||
return (value & 0x7F);
|
|
||||||
if((value & 64) == 0) { /* #10.9.3.7 */
|
|
||||||
value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
value &= 63; /* this is "m" from X.691, #10.9.3.8 */
|
|
||||||
if(value < 1 || value > 4)
|
|
||||||
return -1;
|
|
||||||
*repeat = 1;
|
|
||||||
return (16384 * value);
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_get_length(asn_per_data_t *pd, int range, int ebits, int *repeat) {
|
|
||||||
ssize_t value;
|
|
||||||
|
|
||||||
*repeat = 0;
|
|
||||||
|
|
||||||
if (range <= 65536 && range >= 0)
|
|
||||||
return aper_get_nsnnwn(pd, range);
|
|
||||||
|
|
||||||
if (aper_get_align(pd) < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
if(ebits >= 0) return per_get_few_bits(pd, ebits);
|
|
||||||
|
|
||||||
value = per_get_few_bits(pd, 8);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
if((value & 128) == 0) /* #10.9.3.6 */
|
|
||||||
return (value & 0x7F);
|
|
||||||
if((value & 64) == 0) { /* #10.9.3.7 */
|
|
||||||
value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
|
|
||||||
if(value < 0) return -1;
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
value &= 63; /* this is "m" from X.691, #10.9.3.8 */
|
|
||||||
if(value < 1 || value > 4)
|
|
||||||
return -1;
|
|
||||||
*repeat = 1;
|
|
||||||
return (16384 * value);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the normally small length "n".
|
|
||||||
* This procedure used to decode length of extensions bit-maps
|
|
||||||
* for SET and SEQUENCE types.
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
uper_get_nslength(asn_per_data_t *pd) {
|
|
||||||
ssize_t length;
|
|
||||||
|
|
||||||
ASN_DEBUG("Getting normally small length");
|
|
||||||
|
|
||||||
if(per_get_few_bits(pd, 1) == 0) {
|
|
||||||
length = per_get_few_bits(pd, 6) + 1;
|
|
||||||
if(length <= 0) return -1;
|
|
||||||
ASN_DEBUG("l=%d", (int)length);
|
|
||||||
return length;
|
|
||||||
} else {
|
|
||||||
int repeat;
|
|
||||||
length = uper_get_length(pd, -1, &repeat);
|
|
||||||
if(length >= 0 && !repeat) return length;
|
|
||||||
return -1; /* Error, or do not support >16K extensions */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_get_nslength(asn_per_data_t *pd) {
|
|
||||||
ssize_t length;
|
|
||||||
|
|
||||||
ASN_DEBUG("Getting normally small length");
|
|
||||||
|
|
||||||
if(per_get_few_bits(pd, 1) == 0) {
|
|
||||||
length = per_get_few_bits(pd, 6) + 1;
|
|
||||||
if(length <= 0) return -1;
|
|
||||||
ASN_DEBUG("l=%d", length);
|
|
||||||
return length;
|
|
||||||
} else {
|
|
||||||
int repeat;
|
|
||||||
length = aper_get_length(pd, -1, -1, &repeat);
|
|
||||||
if(length >= 0 && !repeat) return length;
|
|
||||||
return -1; /* Error, or do not support >16K extensions */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the normally small non-negative whole number.
|
|
||||||
* X.691, #10.6
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
uper_get_nsnnwn(asn_per_data_t *pd) {
|
|
||||||
ssize_t value;
|
|
||||||
|
|
||||||
value = per_get_few_bits(pd, 7);
|
|
||||||
if(value & 64) { /* implicit (value < 0) */
|
|
||||||
value &= 63;
|
|
||||||
value <<= 2;
|
|
||||||
value |= per_get_few_bits(pd, 2);
|
|
||||||
if(value & 128) /* implicit (value < 0) */
|
|
||||||
return -1;
|
|
||||||
if(value == 0)
|
|
||||||
return 0;
|
|
||||||
if(value >= 3)
|
|
||||||
return -1;
|
|
||||||
value = per_get_few_bits(pd, 8 * value);
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_get_nsnnwn(asn_per_data_t *pd, int range) {
|
|
||||||
ssize_t value;
|
|
||||||
int bytes = 0;
|
|
||||||
|
|
||||||
ASN_DEBUG("getting nsnnwn with range %d", range);
|
|
||||||
|
|
||||||
if(range <= 255) {
|
|
||||||
if (range < 0) return -1;
|
|
||||||
/* 1 -> 8 bits */
|
|
||||||
int i;
|
|
||||||
for (i = 1; i <= 8; i++) {
|
|
||||||
int upper = 1 << i;
|
|
||||||
if (upper >= range)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
value = per_get_few_bits(pd, i);
|
|
||||||
return value;
|
|
||||||
} else if (range == 256){
|
|
||||||
/* 1 byte */
|
|
||||||
bytes = 1;
|
|
||||||
return -1;
|
|
||||||
} else if (range <= 65536) {
|
|
||||||
/* 2 bytes */
|
|
||||||
bytes = 2;
|
|
||||||
} else {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
if (aper_get_align(pd) < 0)
|
|
||||||
return -1;
|
|
||||||
value = per_get_few_bits(pd, 8 * bytes);
|
|
||||||
return value;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* X.691-11/2008, #11.6
|
|
||||||
* Encoding of a normally small non-negative whole number
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
uper_put_nsnnwn(asn_per_outp_t *po, int n) {
|
|
||||||
int bytes;
|
|
||||||
|
|
||||||
ASN_DEBUG("uper put nsnnwn n %d", n);
|
|
||||||
if(n <= 63) {
|
|
||||||
if(n < 0) return -1;
|
|
||||||
return per_put_few_bits(po, n, 7);
|
|
||||||
}
|
|
||||||
if(n < 256)
|
|
||||||
bytes = 1;
|
|
||||||
else if(n < 65536)
|
|
||||||
bytes = 2;
|
|
||||||
else if(n < 256 * 65536)
|
|
||||||
bytes = 3;
|
|
||||||
else
|
|
||||||
return -1; /* This is not a "normally small" value */
|
|
||||||
if(per_put_few_bits(po, bytes, 8))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return per_put_few_bits(po, n, 8 * bytes);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* X.691-2008/11, #11.5.6 -> #11.3 */
|
|
||||||
int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *out_value, int nbits) {
|
|
||||||
unsigned long lhalf; /* Lower half of the number*/
|
|
||||||
long half;
|
|
||||||
|
|
||||||
if(nbits <= 31) {
|
|
||||||
half = per_get_few_bits(pd, nbits);
|
|
||||||
if(half < 0) return -1;
|
|
||||||
*out_value = half;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
if((size_t)nbits > 8 * sizeof(*out_value))
|
|
||||||
return -1; /* RANGE */
|
|
||||||
|
|
||||||
half = per_get_few_bits(pd, 31);
|
|
||||||
if(half < 0) return -1;
|
|
||||||
|
|
||||||
if(uper_get_constrained_whole_number(pd, &lhalf, nbits - 31))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
*out_value = ((unsigned long)half << (nbits - 31)) | lhalf;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* X.691-2008/11, #11.5.6 -> #11.3 */
|
|
||||||
int uper_put_constrained_whole_number_s(asn_per_outp_t *po, long v, int nbits) {
|
|
||||||
/*
|
|
||||||
* Assume signed number can be safely coerced into
|
|
||||||
* unsigned of the same range.
|
|
||||||
* The following testing code will likely be optimized out
|
|
||||||
* by compiler if it is true.
|
|
||||||
*/
|
|
||||||
unsigned long uvalue1 = ULONG_MAX;
|
|
||||||
long svalue = uvalue1;
|
|
||||||
unsigned long uvalue2 = svalue;
|
|
||||||
assert(uvalue1 == uvalue2);
|
|
||||||
return uper_put_constrained_whole_number_u(po, v, nbits);
|
|
||||||
}
|
|
||||||
|
|
||||||
int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits) {
|
|
||||||
if(nbits <= 31) {
|
|
||||||
return per_put_few_bits(po, v, nbits);
|
|
||||||
} else {
|
|
||||||
/* Put higher portion first, followed by lower 31-bit */
|
|
||||||
if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31))
|
|
||||||
return -1;
|
|
||||||
return per_put_few_bits(po, v, 31);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put a small number of bits (<= 31).
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
per_put_few_bits(asn_per_outp_t *po, uint32_t bits, int obits) {
|
|
||||||
size_t off; /* Next after last bit offset */
|
|
||||||
size_t omsk; /* Existing last byte meaningful bits mask */
|
|
||||||
uint8_t *buf;
|
|
||||||
|
|
||||||
if(obits <= 0 || obits >= 32) return obits ? -1 : 0;
|
|
||||||
|
|
||||||
ASN_DEBUG("[PER put %d bits %x to %p+%d bits]",
|
|
||||||
obits, (int)bits, po->buffer, (int)po->nboff);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Normalize position indicator.
|
|
||||||
*/
|
|
||||||
if(po->nboff >= 8) {
|
|
||||||
po->buffer += (po->nboff >> 3);
|
|
||||||
po->nbits -= (po->nboff & ~0x07);
|
|
||||||
po->nboff &= 0x07;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Flush whole-bytes output, if necessary.
|
|
||||||
*/
|
|
||||||
if(po->nboff + obits > po->nbits) {
|
|
||||||
int complete_bytes = (po->buffer - po->tmpspace);
|
|
||||||
ASN_DEBUG("[PER output %ld complete + %ld]",
|
|
||||||
(long)complete_bytes, (long)po->flushed_bytes);
|
|
||||||
if(po->outper(po->tmpspace, complete_bytes, po->op_key) < 0)
|
|
||||||
return -1;
|
|
||||||
if(po->nboff)
|
|
||||||
po->tmpspace[0] = po->buffer[0];
|
|
||||||
po->buffer = po->tmpspace;
|
|
||||||
po->nbits = 8 * sizeof(po->tmpspace);
|
|
||||||
po->flushed_bytes += complete_bytes;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Now, due to sizeof(tmpspace), we are guaranteed large enough space.
|
|
||||||
*/
|
|
||||||
buf = po->buffer;
|
|
||||||
omsk = ~((1 << (8 - po->nboff)) - 1);
|
|
||||||
off = (po->nboff + obits);
|
|
||||||
|
|
||||||
/* Clear data of debris before meaningful bits */
|
|
||||||
bits &= (((uint32_t)1 << obits) - 1);
|
|
||||||
|
|
||||||
ASN_DEBUG("[PER out %d %u/%x (t=%d,o=%d) %x&%x=%x]", obits,
|
|
||||||
(int)bits, (int)bits,
|
|
||||||
(int)po->nboff, (int)off,
|
|
||||||
buf[0], (int)(omsk&0xff),
|
|
||||||
(int)(buf[0] & omsk));
|
|
||||||
|
|
||||||
if(off <= 8) /* Completely within 1 byte */
|
|
||||||
po->nboff = off,
|
|
||||||
bits <<= (8 - off),
|
|
||||||
buf[0] = (buf[0] & omsk) | bits;
|
|
||||||
else if(off <= 16)
|
|
||||||
po->nboff = off,
|
|
||||||
bits <<= (16 - off),
|
|
||||||
buf[0] = (buf[0] & omsk) | (bits >> 8),
|
|
||||||
buf[1] = bits;
|
|
||||||
else if(off <= 24)
|
|
||||||
po->nboff = off,
|
|
||||||
bits <<= (24 - off),
|
|
||||||
buf[0] = (buf[0] & omsk) | (bits >> 16),
|
|
||||||
buf[1] = bits >> 8,
|
|
||||||
buf[2] = bits;
|
|
||||||
else if(off <= 31)
|
|
||||||
po->nboff = off,
|
|
||||||
bits <<= (32 - off),
|
|
||||||
buf[0] = (buf[0] & omsk) | (bits >> 24),
|
|
||||||
buf[1] = bits >> 16,
|
|
||||||
buf[2] = bits >> 8,
|
|
||||||
buf[3] = bits;
|
|
||||||
else {
|
|
||||||
per_put_few_bits(po, bits >> (obits - 24), 24);
|
|
||||||
per_put_few_bits(po, bits, obits - 24);
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("[PER out %u/%x => %02x buf+%ld]",
|
|
||||||
(int)bits, (int)bits, buf[0],
|
|
||||||
(long)(po->buffer - po->tmpspace));
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
aper_put_nsnnwn(asn_per_outp_t *po, int range, int number) {
|
|
||||||
int bytes;
|
|
||||||
|
|
||||||
ASN_DEBUG("aper put nsnnwn %d with range %d", number, range);
|
|
||||||
/* 10.5.7.1 X.691 */
|
|
||||||
if(range < 0) {
|
|
||||||
int i;
|
|
||||||
for (i = 1; ; i++) {
|
|
||||||
int bits = 1 << (8 * i);
|
|
||||||
if (number <= bits)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
bytes = i;
|
|
||||||
assert(i <= 4);
|
|
||||||
}
|
|
||||||
if(range <= 255) {
|
|
||||||
int i;
|
|
||||||
for (i = 1; i <= 8; i++) {
|
|
||||||
int bits = 1 << i;
|
|
||||||
if (range <= bits)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
return per_put_few_bits(po, number, i);
|
|
||||||
} else if(range == 256) {
|
|
||||||
bytes = 1;
|
|
||||||
} else if(range <= 65536) {
|
|
||||||
bytes = 2;
|
|
||||||
} else { /* Ranges > 64K */
|
|
||||||
int i;
|
|
||||||
for (i = 1; ; i++) {
|
|
||||||
int bits = 1 << (8 * i);
|
|
||||||
if (range <= bits)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
assert(i <= 4);
|
|
||||||
bytes = i;
|
|
||||||
}
|
|
||||||
if(aper_put_align(po) < 0) /* Aligning on octet */
|
|
||||||
return -1;
|
|
||||||
// if(per_put_few_bits(po, bytes, 8))
|
|
||||||
// return -1;
|
|
||||||
|
|
||||||
return per_put_few_bits(po, number, 8 * bytes);
|
|
||||||
}
|
|
||||||
|
|
||||||
int aper_put_align(asn_per_outp_t *po) {
|
|
||||||
|
|
||||||
if(po->nboff & 0x7) {
|
|
||||||
ASN_DEBUG("Aligning %d bits", 8 - (po->nboff & 0x7));
|
|
||||||
if(per_put_few_bits(po, 0x00, (8 - (po->nboff & 0x7))))
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Output a large number of bits.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int nbits) {
|
|
||||||
|
|
||||||
while(nbits) {
|
|
||||||
uint32_t value;
|
|
||||||
|
|
||||||
if(nbits >= 24) {
|
|
||||||
value = (src[0] << 16) | (src[1] << 8) | src[2];
|
|
||||||
src += 3;
|
|
||||||
nbits -= 24;
|
|
||||||
if(per_put_few_bits(po, value, 24))
|
|
||||||
return -1;
|
|
||||||
} else {
|
|
||||||
value = src[0];
|
|
||||||
if(nbits > 8)
|
|
||||||
value = (value << 8) | src[1];
|
|
||||||
if(nbits > 16)
|
|
||||||
value = (value << 8) | src[2];
|
|
||||||
if(nbits & 0x07)
|
|
||||||
value >>= (8 - (nbits & 0x07));
|
|
||||||
if(per_put_few_bits(po, value, nbits))
|
|
||||||
return -1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the length "n" (or part of it) into the stream.
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
uper_put_length(asn_per_outp_t *po, size_t length) {
|
|
||||||
|
|
||||||
ASN_DEBUG("UPER put length %d", length);
|
|
||||||
|
|
||||||
if(length <= 127) /* #10.9.3.6 */
|
|
||||||
return per_put_few_bits(po, length, 8)
|
|
||||||
? -1 : (ssize_t)length;
|
|
||||||
else if(length < 16384) /* #10.9.3.7 */
|
|
||||||
return per_put_few_bits(po, length|0x8000, 16)
|
|
||||||
? -1 : (ssize_t)length;
|
|
||||||
|
|
||||||
length >>= 14;
|
|
||||||
if(length > 4) length = 4;
|
|
||||||
|
|
||||||
return per_put_few_bits(po, 0xC0 | length, 8)
|
|
||||||
? -1 : (ssize_t)(length << 14);
|
|
||||||
}
|
|
||||||
|
|
||||||
ssize_t
|
|
||||||
aper_put_length(asn_per_outp_t *po, int range, size_t length) {
|
|
||||||
|
|
||||||
ASN_DEBUG("APER put length %d with range %d", length, range);
|
|
||||||
|
|
||||||
/* 10.9 X.691 Note 2 */
|
|
||||||
if (range <= 65536 && range >= 0)
|
|
||||||
return aper_put_nsnnwn(po, range, length);
|
|
||||||
|
|
||||||
if (aper_put_align(po) < 0)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
if(length <= 127) /* #10.9.3.6 */{
|
|
||||||
return per_put_few_bits(po, length, 8)
|
|
||||||
? -1 : (ssize_t)length;
|
|
||||||
}
|
|
||||||
else if(length < 16384) /* #10.9.3.7 */
|
|
||||||
return per_put_few_bits(po, length|0x8000, 16)
|
|
||||||
? -1 : (ssize_t)length;
|
|
||||||
|
|
||||||
length >>= 14;
|
|
||||||
if(length > 4) length = 4;
|
|
||||||
|
|
||||||
return per_put_few_bits(po, 0xC0 | length, 8)
|
|
||||||
? -1 : (ssize_t)(length << 14);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the normally small length "n" into the stream.
|
|
||||||
* This procedure used to encode length of extensions bit-maps
|
|
||||||
* for SET and SEQUENCE types.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
uper_put_nslength(asn_per_outp_t *po, size_t length) {
|
|
||||||
|
|
||||||
if(length <= 64) {
|
|
||||||
/* #10.9.3.4 */
|
|
||||||
if(length == 0) return -1;
|
|
||||||
return per_put_few_bits(po, length-1, 7) ? -1 : 0;
|
|
||||||
} else {
|
|
||||||
if(uper_put_length(po, length) != (ssize_t)length) {
|
|
||||||
/* This might happen in case of >16K extensions */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
aper_put_nslength(asn_per_outp_t *po, size_t length) {
|
|
||||||
|
|
||||||
if(length <= 64) {
|
|
||||||
/* #10.9.3.4 */
|
|
||||||
if(length == 0) return -1;
|
|
||||||
return per_put_few_bits(po, length-1, 7) ? -1 : 0;
|
|
||||||
} else {
|
|
||||||
if(aper_put_length(po, -1, length) != (ssize_t)length) {
|
|
||||||
/* This might happen in case of >16K extensions */
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
|
@ -1,152 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2005-2014 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _PER_SUPPORT_H_
|
|
||||||
#define _PER_SUPPORT_H_
|
|
||||||
|
|
||||||
#include <asn_system.h> /* Platform-specific types */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Pre-computed PER constraints.
|
|
||||||
*/
|
|
||||||
typedef const struct asn_per_constraint_s {
|
|
||||||
enum asn_per_constraint_flags {
|
|
||||||
APC_UNCONSTRAINED = 0x0, /* No PER visible constraints */
|
|
||||||
APC_SEMI_CONSTRAINED = 0x1, /* Constrained at "lb" */
|
|
||||||
APC_CONSTRAINED = 0x2, /* Fully constrained */
|
|
||||||
APC_EXTENSIBLE = 0x4 /* May have extension */
|
|
||||||
} flags;
|
|
||||||
int range_bits; /* Full number of bits in the range */
|
|
||||||
int effective_bits; /* Effective bits */
|
|
||||||
int64_t lower_bound; /* "lb" value */
|
|
||||||
int64_t upper_bound; /* "ub" value */
|
|
||||||
} asn_per_constraint_t;
|
|
||||||
typedef const struct asn_per_constraints_s {
|
|
||||||
struct asn_per_constraint_s value;
|
|
||||||
struct asn_per_constraint_s size;
|
|
||||||
int (*value2code)(unsigned int value);
|
|
||||||
int (*code2value)(unsigned int code);
|
|
||||||
} asn_per_constraints_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This structure describes a position inside an incoming PER bit stream.
|
|
||||||
*/
|
|
||||||
typedef struct asn_per_data_s {
|
|
||||||
const uint8_t *buffer; /* Pointer to the octet stream */
|
|
||||||
size_t nboff; /* Bit offset to the meaningful bit */
|
|
||||||
size_t nbits; /* Number of bits in the stream */
|
|
||||||
size_t moved; /* Number of bits moved through this bit stream */
|
|
||||||
int (*refill)(struct asn_per_data_s *);
|
|
||||||
void *refill_key;
|
|
||||||
} asn_per_data_t;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extract a small number of bits (<= 31) from the specified PER data pointer.
|
|
||||||
* This function returns -1 if the specified number of bits could not be
|
|
||||||
* extracted due to EOD or other conditions.
|
|
||||||
*/
|
|
||||||
int32_t per_get_few_bits(asn_per_data_t *per_data, int get_nbits);
|
|
||||||
|
|
||||||
/* Undo the immediately preceeding "get_few_bits" operation */
|
|
||||||
void per_get_undo(asn_per_data_t *per_data, int get_nbits);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Extract a large number of bits from the specified PER data pointer.
|
|
||||||
* This function returns -1 if the specified number of bits could not be
|
|
||||||
* extracted due to EOD or other conditions.
|
|
||||||
*/
|
|
||||||
int per_get_many_bits(asn_per_data_t *pd, uint8_t *dst, int right_align,
|
|
||||||
int get_nbits);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the length "n" from the Unaligned PER stream.
|
|
||||||
*/
|
|
||||||
ssize_t uper_get_length(asn_per_data_t *pd,
|
|
||||||
int effective_bound_bits,
|
|
||||||
int *repeat);
|
|
||||||
|
|
||||||
ssize_t aper_get_length(asn_per_data_t *pd,
|
|
||||||
int range,
|
|
||||||
int effective_bound_bits,
|
|
||||||
int *repeat);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the normally small length "n".
|
|
||||||
*/
|
|
||||||
ssize_t uper_get_nslength(asn_per_data_t *pd);
|
|
||||||
ssize_t aper_get_nslength(asn_per_data_t *pd);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the normally small non-negative whole number.
|
|
||||||
*/
|
|
||||||
ssize_t uper_get_nsnnwn(asn_per_data_t *pd);
|
|
||||||
ssize_t aper_get_nsnnwn(asn_per_data_t *pd, int range);
|
|
||||||
|
|
||||||
/* X.691-2008/11, #11.5.6 */
|
|
||||||
int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *v, int nbits);
|
|
||||||
|
|
||||||
/* Non-thread-safe debugging function, don't use it */
|
|
||||||
char *per_data_string(asn_per_data_t *pd);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This structure supports forming PER output.
|
|
||||||
*/
|
|
||||||
typedef struct asn_per_outp_s {
|
|
||||||
uint8_t *buffer; /* Pointer into the (tmpspace) */
|
|
||||||
size_t nboff; /* Bit offset to the meaningful bit */
|
|
||||||
size_t nbits; /* Number of bits left in (tmpspace) */
|
|
||||||
uint8_t tmpspace[32]; /* Preliminary storage to hold data */
|
|
||||||
int (*outper)(const void *data, size_t size, void *op_key);
|
|
||||||
void *op_key; /* Key for (outper) data callback */
|
|
||||||
size_t flushed_bytes; /* Bytes already flushed through (outper) */
|
|
||||||
} asn_per_outp_t;
|
|
||||||
|
|
||||||
/* Output a small number of bits (<= 31) */
|
|
||||||
int per_put_few_bits(asn_per_outp_t *per_data, uint32_t bits, int obits);
|
|
||||||
|
|
||||||
/* Output a large number of bits */
|
|
||||||
int per_put_many_bits(asn_per_outp_t *po, const uint8_t *src, int put_nbits);
|
|
||||||
|
|
||||||
/* X.691-2008/11, #11.5 */
|
|
||||||
int uper_put_constrained_whole_number_s(asn_per_outp_t *po, long v, int nbits);
|
|
||||||
int uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v, int nbits);
|
|
||||||
|
|
||||||
/* Align the current bit position to octet bundary */
|
|
||||||
int aper_put_align(asn_per_outp_t *po);
|
|
||||||
int32_t aper_get_align(asn_per_data_t *pd);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the length "n" to the Unaligned PER stream.
|
|
||||||
* This function returns the number of units which may be flushed
|
|
||||||
* in the next units saving iteration.
|
|
||||||
*/
|
|
||||||
ssize_t uper_put_length(asn_per_outp_t *po, size_t whole_length);
|
|
||||||
|
|
||||||
ssize_t aper_put_length(asn_per_outp_t *po, int range, size_t length);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the normally small length "n" to the Unaligned PER stream.
|
|
||||||
* Returns 0 or -1.
|
|
||||||
*/
|
|
||||||
int uper_put_nslength(asn_per_outp_t *po, size_t length);
|
|
||||||
|
|
||||||
int aper_put_nslength(asn_per_outp_t *po, size_t length);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Put the normally small non-negative whole number.
|
|
||||||
*/
|
|
||||||
int uper_put_nsnnwn(asn_per_outp_t *po, int n);
|
|
||||||
|
|
||||||
int aper_put_nsnnwn(asn_per_outp_t *po, int range, int number);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _PER_SUPPORT_H_ */
|
|
|
@ -1,365 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2004, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_application.h>
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <xer_support.h> /* XER/XML parsing support */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decode the XER encoding of a given type.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
xer_decode(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
|
|
||||||
void **struct_ptr, const void *buffer, size_t size) {
|
|
||||||
asn_codec_ctx_t s_codec_ctx;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Stack checker requires that the codec context
|
|
||||||
* must be allocated on the stack.
|
|
||||||
*/
|
|
||||||
if(opt_codec_ctx) {
|
|
||||||
if(opt_codec_ctx->max_stack_size) {
|
|
||||||
s_codec_ctx = *opt_codec_ctx;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* If context is not given, be security-conscious anyway */
|
|
||||||
memset(&s_codec_ctx, 0, sizeof(s_codec_ctx));
|
|
||||||
s_codec_ctx.max_stack_size = _ASN_DEFAULT_STACK_MAX;
|
|
||||||
opt_codec_ctx = &s_codec_ctx;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Invoke type-specific decoder.
|
|
||||||
*/
|
|
||||||
return td->xer_decoder(opt_codec_ctx, td, struct_ptr, 0, buffer, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
struct xer__cb_arg {
|
|
||||||
pxml_chunk_type_e chunk_type;
|
|
||||||
size_t chunk_size;
|
|
||||||
const void *chunk_buf;
|
|
||||||
int callback_not_invoked;
|
|
||||||
};
|
|
||||||
|
|
||||||
static int
|
|
||||||
xer__token_cb(pxml_chunk_type_e type, const void *_chunk_data, size_t _chunk_size, void *key) {
|
|
||||||
struct xer__cb_arg *arg = (struct xer__cb_arg *)key;
|
|
||||||
arg->chunk_type = type;
|
|
||||||
arg->chunk_size = _chunk_size;
|
|
||||||
arg->chunk_buf = _chunk_data;
|
|
||||||
arg->callback_not_invoked = 0;
|
|
||||||
return -1; /* Terminate the XML parsing */
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fetch the next token from the XER/XML stream.
|
|
||||||
*/
|
|
||||||
ssize_t
|
|
||||||
xer_next_token(int *stateContext, const void *buffer, size_t size, pxer_chunk_type_e *ch_type) {
|
|
||||||
struct xer__cb_arg arg;
|
|
||||||
int new_stateContext = *stateContext;
|
|
||||||
ssize_t ret;
|
|
||||||
|
|
||||||
arg.callback_not_invoked = 1;
|
|
||||||
ret = pxml_parse(&new_stateContext, buffer, size, xer__token_cb, &arg);
|
|
||||||
if(ret < 0) return -1;
|
|
||||||
if(arg.callback_not_invoked) {
|
|
||||||
assert(ret == 0); /* No data was consumed */
|
|
||||||
return 0; /* Try again with more data */
|
|
||||||
} else {
|
|
||||||
assert(arg.chunk_size);
|
|
||||||
assert(arg.chunk_buf == buffer);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Translate the XML chunk types into more convenient ones.
|
|
||||||
*/
|
|
||||||
switch(arg.chunk_type) {
|
|
||||||
case PXML_TEXT:
|
|
||||||
*ch_type = PXER_TEXT;
|
|
||||||
break;
|
|
||||||
case PXML_TAG: return 0; /* Want more */
|
|
||||||
case PXML_TAG_END:
|
|
||||||
*ch_type = PXER_TAG;
|
|
||||||
break;
|
|
||||||
case PXML_COMMENT:
|
|
||||||
case PXML_COMMENT_END:
|
|
||||||
*ch_type = PXER_COMMENT;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
*stateContext = new_stateContext;
|
|
||||||
return arg.chunk_size;
|
|
||||||
}
|
|
||||||
|
|
||||||
#define CSLASH 0x2f /* '/' */
|
|
||||||
#define LANGLE 0x3c /* '<' */
|
|
||||||
#define RANGLE 0x3e /* '>' */
|
|
||||||
|
|
||||||
xer_check_tag_e
|
|
||||||
xer_check_tag(const void *buf_ptr, int size, const char *need_tag) {
|
|
||||||
const char *buf = (const char *)buf_ptr;
|
|
||||||
const char *end;
|
|
||||||
xer_check_tag_e ct = XCT_OPENING;
|
|
||||||
|
|
||||||
if(size < 2 || buf[0] != LANGLE || buf[size-1] != RANGLE) {
|
|
||||||
if(size >= 2)
|
|
||||||
ASN_DEBUG("Broken XML tag: \"%c...%c\"",
|
|
||||||
buf[0], buf[size - 1]);
|
|
||||||
return XCT_BROKEN;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Determine the tag class.
|
|
||||||
*/
|
|
||||||
if(buf[1] == CSLASH) {
|
|
||||||
buf += 2; /* advance past "</" */
|
|
||||||
size -= 3; /* strip "</" and ">" */
|
|
||||||
ct = XCT_CLOSING;
|
|
||||||
if(size > 0 && buf[size-1] == CSLASH)
|
|
||||||
return XCT_BROKEN; /* </abc/> */
|
|
||||||
} else {
|
|
||||||
buf++; /* advance past "<" */
|
|
||||||
size -= 2; /* strip "<" and ">" */
|
|
||||||
if(size > 0 && buf[size-1] == CSLASH) {
|
|
||||||
ct = XCT_BOTH;
|
|
||||||
size--; /* One more, for "/" */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Sometimes we don't care about the tag */
|
|
||||||
if(!need_tag || !*need_tag)
|
|
||||||
return (xer_check_tag_e)(XCT__UNK__MASK | ct);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Determine the tag name.
|
|
||||||
*/
|
|
||||||
for(end = buf + size; buf < end; buf++, need_tag++) {
|
|
||||||
int b = *buf, n = *need_tag;
|
|
||||||
if(b != n) {
|
|
||||||
if(n == 0) {
|
|
||||||
switch(b) {
|
|
||||||
case 0x09: case 0x0a: case 0x0c: case 0x0d:
|
|
||||||
case 0x20:
|
|
||||||
/* "<abc def/>": whitespace is normal */
|
|
||||||
return ct;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return (xer_check_tag_e)(XCT__UNK__MASK | ct);
|
|
||||||
}
|
|
||||||
if(b == 0)
|
|
||||||
return XCT_BROKEN; /* Embedded 0 in buf?! */
|
|
||||||
}
|
|
||||||
if(*need_tag)
|
|
||||||
return (xer_check_tag_e)(XCT__UNK__MASK | ct);
|
|
||||||
|
|
||||||
return ct;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#undef ADVANCE
|
|
||||||
#define ADVANCE(num_bytes) do { \
|
|
||||||
size_t num = (num_bytes); \
|
|
||||||
buf_ptr = ((const char *)buf_ptr) + num; \
|
|
||||||
size -= num; \
|
|
||||||
consumed_myself += num; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
#undef RETURN
|
|
||||||
#define RETURN(_code) do { \
|
|
||||||
rval.code = _code; \
|
|
||||||
rval.consumed = consumed_myself; \
|
|
||||||
if(rval.code != RC_OK) \
|
|
||||||
ASN_DEBUG("Failed with %d", rval.code); \
|
|
||||||
return rval; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
#define XER_GOT_BODY(chunk_buf, chunk_size, size) do { \
|
|
||||||
ssize_t converted_size = body_receiver \
|
|
||||||
(struct_key, chunk_buf, chunk_size, \
|
|
||||||
(size_t)chunk_size < size); \
|
|
||||||
if(converted_size == -1) RETURN(RC_FAIL); \
|
|
||||||
if(converted_size == 0 \
|
|
||||||
&& size == (size_t)chunk_size) \
|
|
||||||
RETURN(RC_WMORE); \
|
|
||||||
chunk_size = converted_size; \
|
|
||||||
} while(0)
|
|
||||||
#define XER_GOT_EMPTY() do { \
|
|
||||||
if(body_receiver(struct_key, 0, 0, size > 0) == -1) \
|
|
||||||
RETURN(RC_FAIL); \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generalized function for decoding the primitive values.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t
|
|
||||||
xer_decode_general(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_struct_ctx_t *ctx, /* Type decoder context */
|
|
||||||
void *struct_key,
|
|
||||||
const char *xml_tag, /* Expected XML tag */
|
|
||||||
const void *buf_ptr, size_t size,
|
|
||||||
int (*opt_unexpected_tag_decoder)
|
|
||||||
(void *struct_key, const void *chunk_buf, size_t chunk_size),
|
|
||||||
ssize_t (*body_receiver)
|
|
||||||
(void *struct_key, const void *chunk_buf, size_t chunk_size,
|
|
||||||
int have_more)
|
|
||||||
) {
|
|
||||||
|
|
||||||
asn_dec_rval_t rval;
|
|
||||||
ssize_t consumed_myself = 0;
|
|
||||||
|
|
||||||
(void)opt_codec_ctx;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Phases of XER/XML processing:
|
|
||||||
* Phase 0: Check that the opening tag matches our expectations.
|
|
||||||
* Phase 1: Processing body and reacting on closing tag.
|
|
||||||
*/
|
|
||||||
if(ctx->phase > 1) RETURN(RC_FAIL);
|
|
||||||
for(;;) {
|
|
||||||
pxer_chunk_type_e ch_type; /* XER chunk type */
|
|
||||||
ssize_t ch_size; /* Chunk size */
|
|
||||||
xer_check_tag_e tcv; /* Tag check value */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the next part of the XML stream.
|
|
||||||
*/
|
|
||||||
ch_size = xer_next_token(&ctx->context, buf_ptr, size,
|
|
||||||
&ch_type);
|
|
||||||
switch(ch_size) {
|
|
||||||
case -1: RETURN(RC_FAIL);
|
|
||||||
case 0:
|
|
||||||
RETURN(RC_WMORE);
|
|
||||||
default:
|
|
||||||
switch(ch_type) {
|
|
||||||
case PXER_COMMENT: /* Got XML comment */
|
|
||||||
ADVANCE(ch_size); /* Skip silently */
|
|
||||||
continue;
|
|
||||||
case PXER_TEXT:
|
|
||||||
if(ctx->phase == 0) {
|
|
||||||
/*
|
|
||||||
* We have to ignore whitespace here,
|
|
||||||
* but in order to be forward compatible
|
|
||||||
* with EXTENDED-XER (EMBED-VALUES, #25)
|
|
||||||
* any text is just ignored here.
|
|
||||||
*/
|
|
||||||
} else {
|
|
||||||
XER_GOT_BODY(buf_ptr, ch_size, size);
|
|
||||||
}
|
|
||||||
ADVANCE(ch_size);
|
|
||||||
continue;
|
|
||||||
case PXER_TAG:
|
|
||||||
break; /* Check the rest down there */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
assert(ch_type == PXER_TAG && size);
|
|
||||||
|
|
||||||
tcv = xer_check_tag(buf_ptr, ch_size, xml_tag);
|
|
||||||
/*
|
|
||||||
* Phase 0:
|
|
||||||
* Expecting the opening tag
|
|
||||||
* for the type being processed.
|
|
||||||
* Phase 1:
|
|
||||||
* Waiting for the closing XML tag.
|
|
||||||
*/
|
|
||||||
switch(tcv) {
|
|
||||||
case XCT_BOTH:
|
|
||||||
if(ctx->phase) break;
|
|
||||||
/* Finished decoding of an empty element */
|
|
||||||
XER_GOT_EMPTY();
|
|
||||||
ADVANCE(ch_size);
|
|
||||||
ctx->phase = 2; /* Phase out */
|
|
||||||
RETURN(RC_OK);
|
|
||||||
case XCT_OPENING:
|
|
||||||
if(ctx->phase) break;
|
|
||||||
ADVANCE(ch_size);
|
|
||||||
ctx->phase = 1; /* Processing body phase */
|
|
||||||
continue;
|
|
||||||
case XCT_CLOSING:
|
|
||||||
if(!ctx->phase) break;
|
|
||||||
ADVANCE(ch_size);
|
|
||||||
ctx->phase = 2; /* Phase out */
|
|
||||||
RETURN(RC_OK);
|
|
||||||
case XCT_UNKNOWN_BO:
|
|
||||||
/*
|
|
||||||
* Certain tags in the body may be expected.
|
|
||||||
*/
|
|
||||||
if(opt_unexpected_tag_decoder
|
|
||||||
&& opt_unexpected_tag_decoder(struct_key,
|
|
||||||
buf_ptr, ch_size) >= 0) {
|
|
||||||
/* Tag's processed fine */
|
|
||||||
ADVANCE(ch_size);
|
|
||||||
if(!ctx->phase) {
|
|
||||||
/* We are not expecting
|
|
||||||
* the closing tag anymore. */
|
|
||||||
ctx->phase = 2; /* Phase out */
|
|
||||||
RETURN(RC_OK);
|
|
||||||
}
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
/* Fall through */
|
|
||||||
default:
|
|
||||||
break; /* Unexpected tag */
|
|
||||||
}
|
|
||||||
|
|
||||||
ASN_DEBUG("Unexpected XML tag (expected \"%s\")", xml_tag);
|
|
||||||
break; /* Dark and mysterious things have just happened */
|
|
||||||
}
|
|
||||||
|
|
||||||
RETURN(RC_FAIL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
size_t
|
|
||||||
xer_whitespace_span(const void *chunk_buf, size_t chunk_size) {
|
|
||||||
const char *p = (const char *)chunk_buf;
|
|
||||||
const char *pend = p + chunk_size;
|
|
||||||
|
|
||||||
for(; p < pend; p++) {
|
|
||||||
switch(*p) {
|
|
||||||
/* X.693, #8.1.4
|
|
||||||
* HORISONTAL TAB (9)
|
|
||||||
* LINE FEED (10)
|
|
||||||
* CARRIAGE RETURN (13)
|
|
||||||
* SPACE (32)
|
|
||||||
*/
|
|
||||||
case 0x09: case 0x0a: case 0x0d: case 0x20:
|
|
||||||
continue;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
return (p - (const char *)chunk_buf);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is a vastly simplified, non-validating XML tree skipper.
|
|
||||||
*/
|
|
||||||
int
|
|
||||||
xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth) {
|
|
||||||
assert(*depth > 0);
|
|
||||||
switch(tcv) {
|
|
||||||
case XCT_BOTH:
|
|
||||||
case XCT_UNKNOWN_BO:
|
|
||||||
/* These negate each other. */
|
|
||||||
return 0;
|
|
||||||
case XCT_OPENING:
|
|
||||||
case XCT_UNKNOWN_OP:
|
|
||||||
++(*depth);
|
|
||||||
return 0;
|
|
||||||
case XCT_CLOSING:
|
|
||||||
case XCT_UNKNOWN_CL:
|
|
||||||
if(--(*depth) == 0)
|
|
||||||
return (tcv == XCT_CLOSING) ? 2 : 1;
|
|
||||||
return 0;
|
|
||||||
default:
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,105 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _XER_DECODER_H_
|
|
||||||
#define _XER_DECODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The XER decoder of any ASN.1 type. May be invoked by the application.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t xer_decode(struct asn_codec_ctx_s *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void **struct_ptr, /* Pointer to a target structure's pointer */
|
|
||||||
const void *buffer, /* Data to be decoded */
|
|
||||||
size_t size /* Size of data buffer */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of the type-specific XER decoder function.
|
|
||||||
*/
|
|
||||||
typedef asn_dec_rval_t (xer_type_decoder_f)(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void **struct_ptr,
|
|
||||||
const char *opt_mname, /* Member name */
|
|
||||||
const void *buf_ptr, size_t size
|
|
||||||
);
|
|
||||||
|
|
||||||
/*******************************
|
|
||||||
* INTERNALLY USEFUL FUNCTIONS *
|
|
||||||
*******************************/
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generalized function for decoding the primitive values.
|
|
||||||
* Used by more specialized functions, such as OCTET_STRING_decode_xer_utf8
|
|
||||||
* and others. This function should not be used by applications, as its API
|
|
||||||
* is subject to changes.
|
|
||||||
*/
|
|
||||||
asn_dec_rval_t xer_decode_general(asn_codec_ctx_t *opt_codec_ctx,
|
|
||||||
asn_struct_ctx_t *ctx, /* Type decoder context */
|
|
||||||
void *struct_key, /* Treated as opaque pointer */
|
|
||||||
const char *xml_tag, /* Expected XML tag name */
|
|
||||||
const void *buf_ptr, size_t size,
|
|
||||||
int (*opt_unexpected_tag_decoder)
|
|
||||||
(void *struct_key, const void *chunk_buf, size_t chunk_size),
|
|
||||||
ssize_t (*body_receiver)
|
|
||||||
(void *struct_key, const void *chunk_buf, size_t chunk_size,
|
|
||||||
int have_more)
|
|
||||||
);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Fetch the next XER (XML) token from the stream.
|
|
||||||
* The function returns the number of bytes occupied by the chunk type,
|
|
||||||
* returned in the _ch_type. The _ch_type is only set (and valid) when
|
|
||||||
* the return value is greater than 0.
|
|
||||||
*/
|
|
||||||
typedef enum pxer_chunk_type {
|
|
||||||
PXER_TAG, /* Complete XER tag */
|
|
||||||
PXER_TEXT, /* Plain text between XER tags */
|
|
||||||
PXER_COMMENT /* A comment, may be part of */
|
|
||||||
} pxer_chunk_type_e;
|
|
||||||
ssize_t xer_next_token(int *stateContext,
|
|
||||||
const void *buffer, size_t size, pxer_chunk_type_e *_ch_type);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This function checks the buffer against the tag name is expected to occur.
|
|
||||||
*/
|
|
||||||
typedef enum xer_check_tag {
|
|
||||||
XCT_BROKEN = 0, /* The tag is broken */
|
|
||||||
XCT_OPENING = 1, /* This is the <opening> tag */
|
|
||||||
XCT_CLOSING = 2, /* This is the </closing> tag */
|
|
||||||
XCT_BOTH = 3, /* This is the <modified/> tag */
|
|
||||||
XCT__UNK__MASK = 4, /* Mask of everything unexpected */
|
|
||||||
XCT_UNKNOWN_OP = 5, /* Unexpected <opening> tag */
|
|
||||||
XCT_UNKNOWN_CL = 6, /* Unexpected </closing> tag */
|
|
||||||
XCT_UNKNOWN_BO = 7 /* Unexpected <modified/> tag */
|
|
||||||
} xer_check_tag_e;
|
|
||||||
xer_check_tag_e xer_check_tag(const void *buf_ptr, int size,
|
|
||||||
const char *need_tag);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Get the number of bytes consisting entirely of XER whitespace characters.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* >=0: Number of whitespace characters in the string.
|
|
||||||
*/
|
|
||||||
size_t xer_whitespace_span(const void *chunk_buf, size_t chunk_size);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Skip the series of anticipated extensions.
|
|
||||||
*/
|
|
||||||
int xer_skip_unknown(xer_check_tag_e tcv, ber_tlv_len_t *depth);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _XER_DECODER_H_ */
|
|
|
@ -1,67 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_internal.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <errno.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The XER encoder of any type. May be invoked by the application.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t
|
|
||||||
xer_encode(asn_TYPE_descriptor_t *td, void *sptr,
|
|
||||||
enum xer_encoder_flags_e xer_flags,
|
|
||||||
asn_app_consume_bytes_f *cb, void *app_key) {
|
|
||||||
asn_enc_rval_t er, tmper;
|
|
||||||
const char *mname;
|
|
||||||
size_t mlen;
|
|
||||||
int xcan = (xer_flags & XER_F_CANONICAL) ? 1 : 2;
|
|
||||||
|
|
||||||
if(!td || !sptr) goto cb_failed;
|
|
||||||
|
|
||||||
mname = td->xml_tag;
|
|
||||||
mlen = strlen(mname);
|
|
||||||
|
|
||||||
_ASN_CALLBACK3("<", 1, mname, mlen, ">", 1);
|
|
||||||
|
|
||||||
tmper = td->xer_encoder(td, sptr, 1, xer_flags, cb, app_key);
|
|
||||||
if(tmper.encoded == -1) return tmper;
|
|
||||||
|
|
||||||
_ASN_CALLBACK3("</", 2, mname, mlen, ">\n", xcan);
|
|
||||||
|
|
||||||
er.encoded = 4 + xcan + (2 * mlen) + tmper.encoded;
|
|
||||||
|
|
||||||
_ASN_ENCODED_OK(er);
|
|
||||||
cb_failed:
|
|
||||||
_ASN_ENCODE_FAILED;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* This is a helper function for xer_fprint, which directs all incoming data
|
|
||||||
* into the provided file descriptor.
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
xer__print2fp(const void *buffer, size_t size, void *app_key) {
|
|
||||||
FILE *stream = (FILE *)app_key;
|
|
||||||
|
|
||||||
if(fwrite(buffer, 1, size, stream) != size)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
int
|
|
||||||
xer_fprint(FILE *stream, asn_TYPE_descriptor_t *td, void *sptr) {
|
|
||||||
asn_enc_rval_t er;
|
|
||||||
|
|
||||||
if(!stream) stream = stdout;
|
|
||||||
if(!td || !sptr)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
er = xer_encode(td, sptr, XER_F_BASIC, xer__print2fp, stream);
|
|
||||||
if(er.encoded == -1)
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
return fflush(stream);
|
|
||||||
}
|
|
|
@ -1,59 +0,0 @@
|
||||||
/*-
|
|
||||||
* Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _XER_ENCODER_H_
|
|
||||||
#define _XER_ENCODER_H_
|
|
||||||
|
|
||||||
#include <asn_application.h>
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct asn_TYPE_descriptor_s; /* Forward declaration */
|
|
||||||
|
|
||||||
/* Flags used by the xer_encode() and (*xer_type_encoder_f), defined below */
|
|
||||||
enum xer_encoder_flags_e {
|
|
||||||
/* Mode of encoding */
|
|
||||||
XER_F_BASIC = 0x01, /* BASIC-XER (pretty-printing) */
|
|
||||||
XER_F_CANONICAL = 0x02 /* Canonical XER (strict rules) */
|
|
||||||
};
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The XER encoder of any type. May be invoked by the application.
|
|
||||||
*/
|
|
||||||
asn_enc_rval_t xer_encode(struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
enum xer_encoder_flags_e xer_flags,
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb,
|
|
||||||
void *app_key /* Arbitrary callback argument */
|
|
||||||
);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* The variant of the above function which dumps the BASIC-XER (XER_F_BASIC)
|
|
||||||
* output into the chosen file pointer.
|
|
||||||
* RETURN VALUES:
|
|
||||||
* 0: The structure is printed.
|
|
||||||
* -1: Problem printing the structure.
|
|
||||||
* WARNING: No sensible errno value is returned.
|
|
||||||
*/
|
|
||||||
int xer_fprint(FILE *stream, struct asn_TYPE_descriptor_s *td, void *sptr);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Type of the generic XER encoder.
|
|
||||||
*/
|
|
||||||
typedef asn_enc_rval_t (xer_type_encoder_f)(
|
|
||||||
struct asn_TYPE_descriptor_s *type_descriptor,
|
|
||||||
void *struct_ptr, /* Structure to be encoded */
|
|
||||||
int ilevel, /* Level of indentation */
|
|
||||||
enum xer_encoder_flags_e xer_flags,
|
|
||||||
asn_app_consume_bytes_f *consume_bytes_cb, /* Callback */
|
|
||||||
void *app_key /* Arbitrary callback argument */
|
|
||||||
);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _XER_ENCODER_H_ */
|
|
|
@ -1,227 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com.
|
|
||||||
* Copyright (c) 2003, 2004, 2005 Lev Walkin <vlm@lionet.info>.
|
|
||||||
* All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#include <asn_system.h>
|
|
||||||
#include <xer_support.h>
|
|
||||||
|
|
||||||
/* Parser states */
|
|
||||||
typedef enum {
|
|
||||||
ST_TEXT,
|
|
||||||
ST_TAG_START,
|
|
||||||
ST_TAG_BODY,
|
|
||||||
ST_TAG_QUOTE_WAIT,
|
|
||||||
ST_TAG_QUOTED_STRING,
|
|
||||||
ST_TAG_UNQUOTED_STRING,
|
|
||||||
ST_COMMENT_WAIT_DASH1, /* "<!--"[1] */
|
|
||||||
ST_COMMENT_WAIT_DASH2, /* "<!--"[2] */
|
|
||||||
ST_COMMENT,
|
|
||||||
ST_COMMENT_CLO_DASH2, /* "-->"[0] */
|
|
||||||
ST_COMMENT_CLO_RT /* "-->"[1] */
|
|
||||||
} pstate_e;
|
|
||||||
|
|
||||||
static const int
|
|
||||||
_charclass[256] = {
|
|
||||||
0,0,0,0,0,0,0,0, 0,1,1,0,1,1,0,0,
|
|
||||||
0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
|
|
||||||
1,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,
|
|
||||||
2,2,2,2,2,2,2,2, 2,2,0,0,0,0,0,0, /* 01234567 89 */
|
|
||||||
0,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, /* ABCDEFG HIJKLMNO */
|
|
||||||
3,3,3,3,3,3,3,3, 3,3,3,0,0,0,0,0, /* PQRSTUVW XYZ */
|
|
||||||
0,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, /* abcdefg hijklmno */
|
|
||||||
3,3,3,3,3,3,3,3, 3,3,3,0,0,0,0,0 /* pqrstuvw xyz */
|
|
||||||
};
|
|
||||||
#define WHITESPACE(c) (_charclass[(unsigned char)(c)] == 1)
|
|
||||||
#define ALNUM(c) (_charclass[(unsigned char)(c)] >= 2)
|
|
||||||
#define ALPHA(c) (_charclass[(unsigned char)(c)] == 3)
|
|
||||||
|
|
||||||
/* Aliases for characters, ASCII/UTF-8 */
|
|
||||||
#define EXCLAM 0x21 /* '!' */
|
|
||||||
#define CQUOTE 0x22 /* '"' */
|
|
||||||
#define CDASH 0x2d /* '-' */
|
|
||||||
#define CSLASH 0x2f /* '/' */
|
|
||||||
#define LANGLE 0x3c /* '<' */
|
|
||||||
#define CEQUAL 0x3d /* '=' */
|
|
||||||
#define RANGLE 0x3e /* '>' */
|
|
||||||
#define CQUEST 0x3f /* '?' */
|
|
||||||
|
|
||||||
/* Invoke token callback */
|
|
||||||
#define TOKEN_CB_CALL(type, _ns, _current_too, _final) do { \
|
|
||||||
int _ret; \
|
|
||||||
pstate_e ns = _ns; \
|
|
||||||
ssize_t _sz = (p - chunk_start) + _current_too; \
|
|
||||||
if (!_sz) { \
|
|
||||||
/* Shortcut */ \
|
|
||||||
state = _ns; \
|
|
||||||
break; \
|
|
||||||
} \
|
|
||||||
_ret = cb(type, chunk_start, _sz, key); \
|
|
||||||
if(_ret < _sz) { \
|
|
||||||
if(_current_too && _ret == -1) \
|
|
||||||
state = ns; \
|
|
||||||
goto finish; \
|
|
||||||
} \
|
|
||||||
chunk_start = p + _current_too; \
|
|
||||||
state = ns; \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
#define TOKEN_CB(_type, _ns, _current_too) \
|
|
||||||
TOKEN_CB_CALL(_type, _ns, _current_too, 0)
|
|
||||||
|
|
||||||
#define PXML_TAG_FINAL_CHUNK_TYPE PXML_TAG_END
|
|
||||||
#define PXML_COMMENT_FINAL_CHUNK_TYPE PXML_COMMENT_END
|
|
||||||
|
|
||||||
#define TOKEN_CB_FINAL(_type, _ns, _current_too) \
|
|
||||||
TOKEN_CB_CALL( _type ## _FINAL_CHUNK_TYPE , _ns, _current_too, 1)
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Parser itself
|
|
||||||
*/
|
|
||||||
ssize_t pxml_parse(int *stateContext, const void *xmlbuf, size_t size, pxml_callback_f *cb, void *key) {
|
|
||||||
pstate_e state = (pstate_e)*stateContext;
|
|
||||||
const char *chunk_start = (const char *)xmlbuf;
|
|
||||||
const char *p = chunk_start;
|
|
||||||
const char *end = p + size;
|
|
||||||
|
|
||||||
for(; p < end; p++) {
|
|
||||||
int C = *(const unsigned char *)p;
|
|
||||||
switch(state) {
|
|
||||||
case ST_TEXT:
|
|
||||||
/*
|
|
||||||
* Initial state: we're in the middle of some text,
|
|
||||||
* or just have started.
|
|
||||||
*/
|
|
||||||
if (C == LANGLE)
|
|
||||||
/* We're now in the tag, probably */
|
|
||||||
TOKEN_CB(PXML_TEXT, ST_TAG_START, 0);
|
|
||||||
break;
|
|
||||||
case ST_TAG_START:
|
|
||||||
if (ALPHA(C) || (C == CSLASH))
|
|
||||||
state = ST_TAG_BODY;
|
|
||||||
else if (C == EXCLAM)
|
|
||||||
state = ST_COMMENT_WAIT_DASH1;
|
|
||||||
else
|
|
||||||
/*
|
|
||||||
* Not characters and not whitespace.
|
|
||||||
* Must be something like "3 < 4".
|
|
||||||
*/
|
|
||||||
TOKEN_CB(PXML_TEXT, ST_TEXT, 1);/* Flush as data */
|
|
||||||
break;
|
|
||||||
case ST_TAG_BODY:
|
|
||||||
switch(C) {
|
|
||||||
case RANGLE:
|
|
||||||
/* End of the tag */
|
|
||||||
TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
|
|
||||||
break;
|
|
||||||
case LANGLE:
|
|
||||||
/*
|
|
||||||
* The previous tag wasn't completed, but still
|
|
||||||
* recognized as valid. (Mozilla-compatible)
|
|
||||||
*/
|
|
||||||
TOKEN_CB_FINAL(PXML_TAG, ST_TAG_START, 0);
|
|
||||||
break;
|
|
||||||
case CEQUAL:
|
|
||||||
state = ST_TAG_QUOTE_WAIT;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_TAG_QUOTE_WAIT:
|
|
||||||
/*
|
|
||||||
* State after the equal sign ("=") in the tag.
|
|
||||||
*/
|
|
||||||
switch(C) {
|
|
||||||
case CQUOTE:
|
|
||||||
state = ST_TAG_QUOTED_STRING;
|
|
||||||
break;
|
|
||||||
case RANGLE:
|
|
||||||
/* End of the tag */
|
|
||||||
TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
if(!WHITESPACE(C))
|
|
||||||
/* Unquoted string value */
|
|
||||||
state = ST_TAG_UNQUOTED_STRING;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_TAG_QUOTED_STRING:
|
|
||||||
/*
|
|
||||||
* Tag attribute's string value in quotes.
|
|
||||||
*/
|
|
||||||
if(C == CQUOTE) {
|
|
||||||
/* Return back to the tag state */
|
|
||||||
state = ST_TAG_BODY;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_TAG_UNQUOTED_STRING:
|
|
||||||
if(C == RANGLE) {
|
|
||||||
/* End of the tag */
|
|
||||||
TOKEN_CB_FINAL(PXML_TAG, ST_TEXT, 1);
|
|
||||||
} else if(WHITESPACE(C)) {
|
|
||||||
/* Return back to the tag state */
|
|
||||||
state = ST_TAG_BODY;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_COMMENT_WAIT_DASH1:
|
|
||||||
if(C == CDASH) {
|
|
||||||
state = ST_COMMENT_WAIT_DASH2;
|
|
||||||
} else {
|
|
||||||
/* Some ordinary tag. */
|
|
||||||
state = ST_TAG_BODY;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_COMMENT_WAIT_DASH2:
|
|
||||||
if(C == CDASH) {
|
|
||||||
/* Seen "<--" */
|
|
||||||
state = ST_COMMENT;
|
|
||||||
} else {
|
|
||||||
/* Some ordinary tag */
|
|
||||||
state = ST_TAG_BODY;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_COMMENT:
|
|
||||||
if(C == CDASH) {
|
|
||||||
state = ST_COMMENT_CLO_DASH2;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_COMMENT_CLO_DASH2:
|
|
||||||
if(C == CDASH) {
|
|
||||||
state = ST_COMMENT_CLO_RT;
|
|
||||||
} else {
|
|
||||||
/* This is not an end of a comment */
|
|
||||||
state = ST_COMMENT;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case ST_COMMENT_CLO_RT:
|
|
||||||
if(C == RANGLE) {
|
|
||||||
TOKEN_CB_FINAL(PXML_COMMENT, ST_TEXT, 1);
|
|
||||||
} else if(C == CDASH) {
|
|
||||||
/* Maintain current state, still waiting for '>' */
|
|
||||||
} else {
|
|
||||||
state = ST_COMMENT;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
} /* switch(*ptr) */
|
|
||||||
} /* for() */
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Flush the partially processed chunk, state permitting.
|
|
||||||
*/
|
|
||||||
if(p - chunk_start) {
|
|
||||||
switch (state) {
|
|
||||||
case ST_COMMENT:
|
|
||||||
TOKEN_CB(PXML_COMMENT, state, 0);
|
|
||||||
break;
|
|
||||||
case ST_TEXT:
|
|
||||||
TOKEN_CB(PXML_TEXT, state, 0);
|
|
||||||
break;
|
|
||||||
default: break; /* a no-op */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
finish:
|
|
||||||
*stateContext = (int)state;
|
|
||||||
return chunk_start - (const char *)xmlbuf;
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,55 +0,0 @@
|
||||||
/*
|
|
||||||
* Copyright (c) 2003, 2004 X/IO Labs, xiolabs.com.
|
|
||||||
* Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
|
|
||||||
* Redistribution and modifications are permitted subject to BSD license.
|
|
||||||
*/
|
|
||||||
#ifndef _XER_SUPPORT_H_
|
|
||||||
#define _XER_SUPPORT_H_
|
|
||||||
|
|
||||||
#include <asn_system.h> /* Platform-specific types */
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
extern "C" {
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Types of data transferred to the application.
|
|
||||||
*/
|
|
||||||
typedef enum {
|
|
||||||
PXML_TEXT, /* Plain text between XML tags. */
|
|
||||||
PXML_TAG, /* A tag, starting with '<'. */
|
|
||||||
PXML_COMMENT, /* An XML comment, including "<!--" and "-->". */
|
|
||||||
/*
|
|
||||||
* The following chunk types are reported if the chunk
|
|
||||||
* terminates the specified XML element.
|
|
||||||
*/
|
|
||||||
PXML_TAG_END, /* Tag ended */
|
|
||||||
PXML_COMMENT_END /* Comment ended */
|
|
||||||
} pxml_chunk_type_e;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Callback function that is called by the parser when parsed data is
|
|
||||||
* available. The _opaque is the pointer to a field containing opaque user
|
|
||||||
* data specified in pxml_create() call. The chunk type is _type and the text
|
|
||||||
* data is the piece of buffer identified by _bufid (as supplied to
|
|
||||||
* pxml_feed() call) starting at offset _offset and of _size bytes size.
|
|
||||||
* The chunk is NOT '\0'-terminated.
|
|
||||||
*/
|
|
||||||
typedef int (pxml_callback_f)(pxml_chunk_type_e _type,
|
|
||||||
const void *_chunk_data, size_t _chunk_size, void *_key);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Parse the given buffer as it were a chunk of XML data.
|
|
||||||
* Invoke the specified callback each time the meaninful data is found.
|
|
||||||
* This function returns number of bytes consumed from the bufer.
|
|
||||||
* It will always be lesser than or equal to the specified _size.
|
|
||||||
* The next invocation of this function must account the difference.
|
|
||||||
*/
|
|
||||||
ssize_t pxml_parse(int *_stateContext, const void *_buf, size_t _size,
|
|
||||||
pxml_callback_f *cb, void *_key);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* _XER_SUPPORT_H_ */
|
|
|
@ -24,6 +24,7 @@
|
||||||
#include "hnbgw_hnbap.h"
|
#include "hnbgw_hnbap.h"
|
||||||
|
|
||||||
static void *tall_hnb_ctx;
|
static void *tall_hnb_ctx;
|
||||||
|
void *talloc_asn1_ctx;
|
||||||
|
|
||||||
struct hnb_gw g_hnb_gw = {
|
struct hnb_gw g_hnb_gw = {
|
||||||
.config = {
|
.config = {
|
||||||
|
@ -132,6 +133,7 @@ int main(int argc, char **argv)
|
||||||
int rc;
|
int rc;
|
||||||
|
|
||||||
tall_hnb_ctx = talloc_named_const(NULL, 0, "hnb_context");
|
tall_hnb_ctx = talloc_named_const(NULL, 0, "hnb_context");
|
||||||
|
talloc_asn1_ctx = talloc_named_const(NULL, 0, "asn1_context");
|
||||||
|
|
||||||
g_hnb_gw.listen_fd.cb = listen_fd_cb;
|
g_hnb_gw.listen_fd.cb = listen_fd_cb;
|
||||||
g_hnb_gw.listen_fd.when = BSC_FD_READ;
|
g_hnb_gw.listen_fd.when = BSC_FD_READ;
|
||||||
|
|
Loading…
Reference in New Issue