diff options
94 files changed, 3257 insertions, 1259 deletions
diff --git a/asn1c/tests/check-22.c b/asn1c/tests/check-22.c index 02227822..6a353803 100644 --- a/asn1c/tests/check-22.c +++ b/asn1c/tests/check-22.c @@ -48,7 +48,8 @@ static void check(int is_ok, uint8_t *buf, int size, size_t consumed) { T1_t t, *tp; ber_dec_rval_t rval; - der_enc_rval_t erval; + asn_enc_rval_t erval; + int ret; int i; tp = memset(&t, 0, sizeof(t)); @@ -104,8 +105,12 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) { assert(buf1[i] == buf2[i]); } - fprintf(stderr, "=== PRINT ===\n"); - asn_fprint(stderr, &asn1_DEF_T1, tp); + fprintf(stderr, "=== asn_fprint() ===\n"); + ret = asn_fprint(stderr, &asn1_DEF_T1, tp); + assert(ret == 0); + fprintf(stderr, "=== xer_fprint() ===\n"); + ret = xer_fprint(stderr, &asn1_DEF_T1, tp); + assert(ret == 0); fprintf(stderr, "=== EOF ===\n"); } diff --git a/asn1c/tests/check-31.c b/asn1c/tests/check-31.c index 4b13f080..b0a47b98 100644 --- a/asn1c/tests/check-31.c +++ b/asn1c/tests/check-31.c @@ -136,6 +136,7 @@ check(int is_ok, uint8_t *buf, int size, size_t consumed) { assert(buf_pos == sizeof(buf1_reconstr)); asn_fprint(stderr, &asn1_DEF_Forest, &t); + xer_fprint(stderr, &asn1_DEF_Forest, &t); asn1_DEF_Forest.free_struct(&asn1_DEF_Forest, &t, 1); } diff --git a/asn1c/tests/check-35.c b/asn1c/tests/check-35.c index 1d260f08..bc223946 100644 --- a/asn1c/tests/check-35.c +++ b/asn1c/tests/check-35.c @@ -131,6 +131,9 @@ check(T_t *tp, uint8_t *buf, int size, size_t consumed) { assert(strcmp(tp->a.buf, "ns") == 0); assert(strcmp(tp->b.choice.b1.buf, "z") == 0 && strcmp(tp->b.choice.b2.buf, "z") == 0); + + asn_fprint(stderr, &asn1_DEF_T, tp); + xer_fprint(stderr, &asn1_DEF_T, tp); } size_t buf_pos; @@ -157,7 +160,7 @@ buf_fill(const void *buffer, size_t size, void *app_key) { static void compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) { - der_enc_rval_t erval; + asn_enc_rval_t erval; int i; buf_size = cmp_buf_size + 100; @@ -268,12 +271,10 @@ main(int ac, char **av) { check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1)); compare(&t, buf1_reconstr, sizeof(buf1_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); check(&t, buf2, sizeof(buf2) + 10, sizeof(buf2)); compare(&t, buf2_reconstr, sizeof(buf2_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Split the buffer in parts and check decoder restartability */ diff --git a/asn1c/tests/check-41.c b/asn1c/tests/check-41.c index fc2ce66f..33634e86 100644 --- a/asn1c/tests/check-41.c +++ b/asn1c/tests/check-41.c @@ -132,10 +132,11 @@ uint8_t buf2_reconstr[] = { static void check(T_t *tp, uint8_t *buf, int size, size_t consumed) { ber_dec_rval_t rval; + int ret; tp = memset(tp, 0, sizeof(*tp)); - fprintf(stderr, "Buf %p (%d)\n", buf, size); + fprintf(stderr, "Buf %p (%d)\n", (int)buf, (int)size); rval = ber_decode(&asn1_DEF_T, (void **)&tp, buf, size); fprintf(stderr, "Returned code %d, consumed %d\n", (int)rval.code, (int)rval.consumed); @@ -143,6 +144,14 @@ check(T_t *tp, uint8_t *buf, int size, size_t consumed) { assert(rval.code == RC_OK); assert(rval.consumed == consumed); + fprintf(stderr, "=== asn_fprint() ===\n"); + ret = asn_fprint(stderr, &asn1_DEF_T, tp); + assert(ret == 0); + fprintf(stderr, "=== xer_fprint() ===\n"); + ret = xer_fprint(stderr, &asn1_DEF_T, tp); + fprintf(stderr, "=== END ===\n"); + assert(ret == 0); + /* assert(tp->string.size == 128); assert(strncmp(tp->string.buf, "zz") == 0); @@ -153,32 +162,33 @@ check(T_t *tp, uint8_t *buf, int size, size_t consumed) { size_t buf_pos; size_t buf_size; -uint8_t *buf; +uint8_t *buffer; static int -buf_fill(const void *buffer, size_t size, void *app_key) { +buf_fill(const void *bufp, size_t size, void *app_key) { (void)app_key; /* Unused argument */ if(buf_pos + size > buf_size) { - fprintf(stderr, "%d + %d > %d\n", buf_pos, (int)size, buf_size); + fprintf(stderr, "%d + %d > %d\n", + (int)buf_pos, (int)size, (int)buf_size); return -1; } - memcpy(buf + buf_pos, buffer, size); + memcpy(buffer + buf_pos, bufp, size); buf_pos += size; - fprintf(stderr, " written %d (%d)\n", (int)size, buf_pos); + fprintf(stderr, " written %d (%d)\n", (int)size, (int)buf_pos); return 0; } static void compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) { - der_enc_rval_t erval; + asn_enc_rval_t erval; int i; buf_size = cmp_buf_size + 100; - buf = alloca(buf_size); + buffer = alloca(buf_size); buf_pos = 0; /* @@ -187,19 +197,19 @@ compare(T_t *tp, uint8_t *cmp_buf, int cmp_buf_size) { erval = der_encode(&asn1_DEF_T, tp, buf_fill, 0); assert(erval.encoded != -1); if(erval.encoded != cmp_buf_size) { - printf("%d != %d\n", erval.encoded, cmp_buf_size); + printf("%d != %d\n", (int)erval.encoded, (int)cmp_buf_size); } assert(erval.encoded == cmp_buf_size); for(i = 0; i < cmp_buf_size; i++) { - if(buf[i] != cmp_buf[i]) { + if(buffer[i] != cmp_buf[i]) { fprintf(stderr, "Recreated buffer content mismatch:\n"); fprintf(stderr, "Byte %d, %x != %x (%d != %d)\n", i, - buf[i], cmp_buf[i], - buf[i], cmp_buf[i] + buffer[i], cmp_buf[i], + buffer[i], cmp_buf[i] ); } - assert(buf[i] == cmp_buf[i]); + assert(buffer[i] == cmp_buf[i]); } } @@ -230,7 +240,7 @@ partial_read(uint8_t *buf, size_t size) { size_t size3 = size - size1 - size2; fprintf(stderr, "\n%d:{%d, %d, %d}...\n", - size, size1, size2, size3); + (int)size, (int)size1, (int)size2, (int)size3); memset(buf1, 0, size); memset(buf2, 0, size); @@ -241,7 +251,7 @@ partial_read(uint8_t *buf, size_t size) { tp = memset(&t, 0, sizeof(t)); - fprintf(stderr, "=> Chunk 1 (%d):\n", size1); + fprintf(stderr, "=> Chunk 1 (%d):\n", (int)size1); rval = ber_decode(&asn1_DEF_T, (void **)&tp, buf1, size1); assert(rval.code == RC_WMORE); @@ -253,7 +263,7 @@ partial_read(uint8_t *buf, size_t size) { size2 += leftover; } - fprintf(stderr, "=> Chunk 2 (%d):\n", size2); + fprintf(stderr, "=> Chunk 2 (%d):\n", (int)size2); rval = ber_decode(&asn1_DEF_T, (void **)&tp, buf2, size2); assert(rval.code == RC_WMORE); @@ -265,7 +275,7 @@ partial_read(uint8_t *buf, size_t size) { size3 += leftover; } - fprintf(stderr, "=> Chunk 3 (%d):\n", size3); + fprintf(stderr, "=> Chunk 3 (%d):\n", (int)size3); rval = ber_decode(&asn1_DEF_T, (void **)&tp, buf3, size3); assert(rval.code == RC_OK); @@ -283,31 +293,26 @@ main() { /* Check exact buf0 */ check(&t, buf0, sizeof(buf0), sizeof(buf0)); compare(&t, buf0_reconstr, sizeof(buf0_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Check exact buf1 */ check(&t, buf1, sizeof(buf1), sizeof(buf1)); compare(&t, buf1_reconstr, sizeof(buf1_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Check slightly more than buf1 */ check(&t, buf1, sizeof(buf1) + 10, sizeof(buf1)); compare(&t, buf1_reconstr, sizeof(buf1_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Check exact buf2 */ check(&t, buf2, sizeof(buf2), sizeof(buf2)); compare(&t, buf2_reconstr, sizeof(buf2_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Check slightly more than buf2 */ check(&t, buf2, sizeof(buf2) + 10, sizeof(buf2)); compare(&t, buf2_reconstr, sizeof(buf2_reconstr)); - asn_fprint(stderr, &asn1_DEF_T, &t); asn1_DEF_T.free_struct(&asn1_DEF_T, &t, 1); /* Split the buffer in parts and check decoder restartability */ diff --git a/asn1c/tests/check-48.c b/asn1c/tests/check-48.c index 8c4f395f..84227680 100644 --- a/asn1c/tests/check-48.c +++ b/asn1c/tests/check-48.c @@ -29,7 +29,7 @@ _buf_writer(const void *buffer, size_t size, void *app_key) { static int save_object(void *bs, asn1_TYPE_descriptor_t *td) { - der_enc_rval_t rval; /* Return value */ + asn_enc_rval_t rval; /* Return value */ int i; rval = der_encode(td, bs, _buf_writer, 0); @@ -44,6 +44,7 @@ save_object(void *bs, asn1_TYPE_descriptor_t *td) { buf[buf_offset++] = 123; /* Finalize with garbage */ asn_fprint(stderr, td, bs); + xer_fprint(stderr, td, bs); printf("OUT: ["); for(i = 0; i < buf_offset; i++) @@ -63,6 +64,7 @@ load_object(void *bs, asn1_TYPE_descriptor_t *td) { assert(rval.code == RC_OK); asn_fprint(stderr, td, bs); + xer_fprint(stderr, td, bs); return (rval.code == RC_OK)?0:-1; } diff --git a/libasn1compiler/asn1c_C.c b/libasn1compiler/asn1c_C.c index a5d04c6b..179161f0 100644 --- a/libasn1compiler/asn1c_C.c +++ b/libasn1compiler/asn1c_C.c @@ -27,6 +27,7 @@ static int asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of); static int _print_tag(arg_t *arg, struct asn1p_type_tag_s *tag_p); static int check_if_extensible(asn1p_expr_t *expr); static int expr_better_indirect(arg_t *arg, asn1p_expr_t *expr); +static int expr_as_xmlvaluelist(arg_t *arg, asn1p_expr_t *expr); static int expr_elements_count(arg_t *arg, asn1p_expr_t *expr); static int emit_member_table(arg_t *arg, asn1p_expr_t *expr); static int emit_tag2member_map(arg_t *arg, tag2el_t *tag2el, int tag2el_count); @@ -156,7 +157,6 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) { asn1p_expr_t *expr = arg->expr; asn1p_expr_t *v; int elements; /* Number of elements */ - int comp_mode = 0; /* {root,ext=1,root,root,...} */ int ext_start = -1; int ext_stop = -1; tag2el_t *tag2el = NULL; @@ -183,22 +183,28 @@ asn1c_lang_C_type_SEQUENCE_def(arg_t *arg) { /* * Print out the table according to which the parsing is performed. */ - p = MKID(expr->Identifier); - OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + if(expr_elements_count(arg, expr)) { + int comp_mode = 0; /* {root,ext=1,root,root,...} */ - elements = 0; - INDENTED(TQ_FOR(v, &(expr->members), next) { - if(v->expr_type == A1TC_EXTENSIBLE) { - if((++comp_mode) == 1) - ext_start = elements - 1; - else - ext_stop = elements - 1; - continue; - } - elements++; - emit_member_table(arg, v); - }); - OUT("};\n"); + p = MKID(expr->Identifier); + OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + + elements = 0; + INDENTED(TQ_FOR(v, &(expr->members), next) { + if(v->expr_type == A1TC_EXTENSIBLE) { + if((++comp_mode) == 1) + ext_start = elements - 1; + else + ext_stop = elements - 1; + continue; + } + elements++; + emit_member_table(arg, v); + }); + OUT("};\n"); + } else { + elements = 0; + } /* * Print out asn1_DEF_<type>_[all_]tags[] vectors. @@ -307,7 +313,6 @@ asn1c_lang_C_type_SET_def(arg_t *arg) { asn1p_expr_t *expr = arg->expr; asn1p_expr_t *v; int elements; - int comp_mode = 0; /* {root,ext=1,root,root,...} */ tag2el_t *tag2el = NULL; int tag2el_count = 0; int tags_count; @@ -332,22 +337,28 @@ asn1c_lang_C_type_SET_def(arg_t *arg) { /* * Print out the table according to which the parsing is performed. */ - p = MKID(expr->Identifier); - OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + if(expr_elements_count(arg, expr)) { + int comp_mode = 0; /* {root,ext=1,root,root,...} */ - elements = 0; - INDENTED(TQ_FOR(v, &(expr->members), next) { - if(v->expr_type == A1TC_EXTENSIBLE) { - if(comp_mode < 3) comp_mode++; - } else { - if(comp_mode == 1 - || expr_better_indirect(arg, v)) - v->marker.flags |= EM_INDIRECT; - elements++; - emit_member_table(arg, v); - } - }); - OUT("};\n"); + p = MKID(expr->Identifier); + OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + + elements = 0; + INDENTED(TQ_FOR(v, &(expr->members), next) { + if(v->expr_type == A1TC_EXTENSIBLE) { + if(comp_mode < 3) comp_mode++; + } else { + if(comp_mode == 1 + || expr_better_indirect(arg, v)) + v->marker.flags |= EM_INDIRECT; + elements++; + emit_member_table(arg, v); + } + }); + OUT("};\n"); + } else { + elements = 0; + } /* * Print out asn1_DEF_<type>_[all_]tags[] vectors. @@ -443,12 +454,15 @@ asn1c_lang_C_type_SEx_OF(arg_t *arg) { tmp.expr = &tmp_memb; tmp_memb = *memb; tmp_memb._anonymous_type = 1; - tmp_memb.Identifier = strdup( - asn1c_make_identifier(0, - expr->Identifier, "member", 0)); - assert(tmp_memb.Identifier); + if(tmp_memb.Identifier == 0) { + tmp_memb.Identifier = strdup( + asn1c_make_identifier(0, + expr->Identifier, "member", 0)); + assert(tmp_memb.Identifier); + } tmp.default_cb(&tmp); - free(tmp_memb.Identifier); + if(tmp_memb.Identifier != memb->Identifier) + free(tmp_memb.Identifier); arg->embed--; assert(arg->target->target == OT_TYPE_DECLS); } else { @@ -496,11 +510,17 @@ asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of) { */ p = MKID(expr->Identifier); OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); - - INDENTED( + INDENT(+1); v = TQ_FIRST(&(expr->members)); + if(!v->Identifier) { + v->Identifier = strdup("member"); + assert(v->Identifier); + } + v->_anonymous_type = 1; + arg->embed++; emit_member_table(arg, v); - ); + arg->embed--; + INDENT(-1); OUT("};\n"); /* @@ -513,6 +533,10 @@ asn1c_lang_C_type_SEx_OF_def(arg_t *arg, int seq_of) { INDENTED( OUT("sizeof(struct %s),\n", p); OUT("offsetof(struct %s, _ber_dec_ctx),\n", p); + if(expr_as_xmlvaluelist(arg, v)) + OUT("1,\t/* XER encoding is XMLValueList */\n"); + else + OUT("0,\t/* XER encoding is XMLDelimitedItemList */\n"); ); OUT("};\n"); @@ -589,7 +613,6 @@ asn1c_lang_C_type_CHOICE_def(arg_t *arg) { asn1p_expr_t *expr = arg->expr; asn1p_expr_t *v; int elements; /* Number of elements */ - int comp_mode = 0; /* {root,ext=1,root,root,...} */ tag2el_t *tag2el = NULL; int tag2el_count = 0; int tags_count; @@ -614,22 +637,28 @@ asn1c_lang_C_type_CHOICE_def(arg_t *arg) { /* * Print out the table according to which the parsing is performed. */ - p = MKID(expr->Identifier); - OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + if(expr_elements_count(arg, expr)) { + int comp_mode = 0; /* {root,ext=1,root,root,...} */ - elements = 0; - INDENTED(TQ_FOR(v, &(expr->members), next) { - if(v->expr_type == A1TC_EXTENSIBLE) { - if(comp_mode < 3) comp_mode++; - } else { - if(comp_mode == 1 - || expr_better_indirect(arg, v)) - v->marker.flags |= EM_INDIRECT; - elements++; - emit_member_table(arg, v); - } - }); - OUT("};\n"); + p = MKID(expr->Identifier); + OUT("static asn1_TYPE_member_t asn1_MBR_%s[] = {\n", p); + + elements = 0; + INDENTED(TQ_FOR(v, &(expr->members), next) { + if(v->expr_type == A1TC_EXTENSIBLE) { + if(comp_mode < 3) comp_mode++; + } else { + if(comp_mode == 1 + || expr_better_indirect(arg, v)) + v->marker.flags |= EM_INDIRECT; + elements++; + emit_member_table(arg, v); + } + }); + OUT("};\n"); + } else { + elements = 0; + } if(arg->embed) { @@ -683,7 +712,7 @@ asn1c_lang_C_type_REFERENCE(arg_t *arg) { arg_t tmp; int ret; - extract = asn1f_class_access_ex(arg->asn, arg->mod, + extract = asn1f_class_access_ex(arg->asn, arg->expr->module, arg->expr, ref); if(extract == NULL) return -1; @@ -808,12 +837,14 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) { OUT("%s_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) {\n", p); INDENT(+1); { - asn1p_expr_t *terminal = asn1f_find_terminal_type_ex(arg->asn, arg->mod, expr); + asn1p_expr_t *terminal = asn1f_find_terminal_type_ex(arg->asn, expr); char *type_name = asn1c_type_name(arg, expr, TNF_SAFE); - OUT("td->ber_decoder = asn1_DEF_%s.ber_decoder;\n", type_name); - OUT("td->der_encoder = asn1_DEF_%s.der_encoder;\n", type_name); OUT("td->free_struct = asn1_DEF_%s.free_struct;\n", type_name); OUT("td->print_struct = asn1_DEF_%s.print_struct;\n", type_name); + OUT("td->ber_decoder = asn1_DEF_%s.ber_decoder;\n", type_name); + OUT("td->der_encoder = asn1_DEF_%s.der_encoder;\n", type_name); + OUT("td->xer_decoder = asn1_DEF_%s.xer_decoder;\n", type_name); + OUT("td->xer_encoder = asn1_DEF_%s.xer_encoder;\n", type_name); if(!terminal && !tags_count) { OUT("/* The next four lines are here because of -fknown-extern-type */\n"); OUT("td->tags = asn1_DEF_%s.tags;\n", type_name); @@ -832,6 +863,28 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) { OUT("\n"); p = MKID(expr->Identifier); + OUT("void\n"); + OUT("%s_free(asn1_TYPE_descriptor_t *td,\n", p); + INDENTED( + OUT("\tvoid *struct_ptr, int contents_only) {\n"); + OUT("%s_inherit_TYPE_descriptor(td);\n", p); + OUT("td->free_struct(td, struct_ptr, contents_only);\n"); + ); + OUT("}\n"); + OUT("\n"); + + p = MKID(expr->Identifier); + OUT("int\n"); + OUT("%s_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr,\n", p); + INDENTED( + OUT("\tint ilevel, asn_app_consume_bytes_f *cb, void *app_key) {\n"); + OUT("%s_inherit_TYPE_descriptor(td);\n", p); + OUT("return td->print_struct(td, struct_ptr, ilevel, cb, app_key);\n"); + ); + OUT("}\n"); + OUT("\n"); + + p = MKID(expr->Identifier); OUT("ber_dec_rval_t\n"); OUT("%s_decode_ber(asn1_TYPE_descriptor_t *td,\n", p); INDENTED( @@ -843,7 +896,7 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) { OUT("\n"); p = MKID(expr->Identifier); - OUT("der_enc_rval_t\n"); + OUT("asn_enc_rval_t\n"); OUT("%s_encode_der(asn1_TYPE_descriptor_t *td,\n", p); INDENTED( OUT("\tvoid *structure, int tag_mode, ber_tlv_tag_t tag,\n"); @@ -855,23 +908,13 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) { OUT("\n"); p = MKID(expr->Identifier); - OUT("int\n"); - OUT("%s_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr,\n", p); - INDENTED( - OUT("\tint ilevel, asn_app_consume_bytes_f *cb, void *app_key) {\n"); - OUT("%s_inherit_TYPE_descriptor(td);\n", p); - OUT("return td->print_struct(td, struct_ptr, ilevel, cb, app_key);\n"); - ); - OUT("}\n"); - OUT("\n"); - - p = MKID(expr->Identifier); - OUT("void\n"); - OUT("%s_free(asn1_TYPE_descriptor_t *td,\n", p); + OUT("asn_enc_rval_t\n"); + OUT("%s_encode_xer(asn1_TYPE_descriptor_t *td, void *structure,\n", p); INDENTED( - OUT("\tvoid *struct_ptr, int contents_only) {\n"); + OUT("\tint ilevel, enum xer_encoder_flags_e flags,\n"); + OUT("\tasn_app_consume_bytes_f *cb, void *app_key) {\n"); OUT("%s_inherit_TYPE_descriptor(td);\n", p); - OUT("td->free_struct(td, struct_ptr, contents_only);\n"); + OUT("return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);\n"); ); OUT("}\n"); OUT("\n"); @@ -883,11 +926,12 @@ asn1c_lang_C_type_SIMPLE_TYPE(arg_t *arg) { OUT("extern asn1_TYPE_descriptor_t asn1_DEF_%s;", p); if(HIDE_INNER_DEFS) OUT(" // (Use -fall-defs-global to expose) */"); OUT("\n"); + OUT("asn_struct_free_f %s_free;\n", p); + OUT("asn_struct_print_f %s_print;\n", p); OUT("asn_constr_check_f %s_constraint;\n", p); OUT("ber_type_decoder_f %s_decode_ber;\n", p); OUT("der_type_encoder_f %s_encode_der;\n", p); - OUT("asn_struct_print_f %s_print;\n", p); - OUT("asn_struct_free_f %s_free;\n", p); + OUT("xer_type_encoder_f %s_encode_xer;\n", p); REDIR(OT_TYPE_DECLS); @@ -1031,7 +1075,8 @@ _add_tag2el_member(arg_t *arg, tag2el_t **tag2el, int *count, int el_no) { assert(el_no >= 0); - ret = asn1f_fetch_outmost_tag(arg->asn, arg->mod, arg->expr, &tag, 1); + ret = asn1f_fetch_outmost_tag(arg->asn, arg->expr->module, + arg->expr, &tag, 1); if(ret == 0) { tag2el_t *te; int new_count = (*count) + 1; @@ -1137,12 +1182,12 @@ emit_tags_vectors(arg_t *arg, asn1p_expr_t *expr, int *tags_count_r, int *all_ta *all_tags_count_r = 0; /* Fetch a chain of tags */ - tags_count = asn1f_fetch_tags(arg->asn, arg->mod, expr, &tags, 0); + tags_count = asn1f_fetch_tags(arg->asn, expr->module, expr, &tags, 0); if(tags_count < 0) return -1; /* Fetch a chain of tags */ - all_tags_count = asn1f_fetch_tags(arg->asn, arg->mod, expr, + all_tags_count = asn1f_fetch_tags(arg->asn, expr->module, expr, &all_tags, AFT_FULL_COLLECT); if(all_tags_count < 0) { if(tags) free(tags); @@ -1207,7 +1252,7 @@ expr_elements_count(arg_t *arg, asn1p_expr_t *expr) { asn1p_expr_t *v; int elements = 0; - topmost_parent = asn1f_find_terminal_type_ex(arg->asn, arg->mod, expr); + topmost_parent = asn1f_find_terminal_type_ex(arg->asn, expr); if(!topmost_parent) return 0; if(!(topmost_parent->expr_type & ASN_CONSTR_MASK)) @@ -1254,15 +1299,15 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) { } else { OUT("0, "); } - if(expr->Identifier) { + if(expr->_anonymous_type) { + assert(arg->expr->expr_type == ASN_CONSTR_SET_OF + || arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF); + OUT("0,\n"); + } else { OUT("offsetof(struct %s, ", MKID(arg->expr->Identifier)); if(arg->expr->expr_type == ASN_CONSTR_CHOICE && (!UNNAMED_UNIONS)) OUT("choice."); OUT("%s),\n", MKID(expr->Identifier)); - } else { - assert(arg->expr->expr_type == ASN_CONSTR_SET_OF - || arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF); - OUT("0,\n"); } INDENT(+1); if(C99_MODE) OUT(".tag = "); @@ -1286,9 +1331,7 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) { OUT("0,\n"); } if(C99_MODE) OUT(".type = "); - if((expr->expr_type & ASN_CONSTR_MASK) - && (arg->expr->expr_type == ASN_CONSTR_SEQUENCE_OF - || arg->expr->expr_type == ASN_CONSTR_SET_OF)) { + if(expr->_anonymous_type && (expr->expr_type & ASN_CONSTR_MASK)) { OUT("(void *)&asn1_DEF_%s_member,\n", MKID(arg->expr->Identifier)); } else if(expr->expr_type & ASN_CONSTR_MASK) { @@ -1301,7 +1344,7 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) { if(C99_MODE) OUT(".memb_constraints = "); if(expr->constraints) { char *id = MKID(expr->Identifier); - if(!expr->Identifier) + if(expr->_anonymous_type && !strcmp(expr->Identifier, "member")) id = asn1c_type_name(arg, expr, TNF_SAFE); OUT("memb_%s_%d_constraint,\n", id, ++global_memb_unique); @@ -1309,7 +1352,7 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) { OUT("0,\t/* Defer to actual type */\n"); } if(C99_MODE) OUT(".name = "); - OUT("\"%s\"\n", expr->Identifier ? expr->Identifier : ""); + OUT("\"%s\"\n", expr->_anonymous_type ? "" : expr->Identifier); OUT("},\n"); INDENT(-1); @@ -1319,10 +1362,10 @@ emit_member_table(arg_t *arg, asn1p_expr_t *expr) { save_target = arg->target->target; REDIR(OT_CODE); - if(expr->Identifier) - p = MKID(expr->Identifier); - else + if(expr->_anonymous_type && !strcmp(expr->Identifier, "member")) p = asn1c_type_name(arg, expr, TNF_SAFE); + else + p = MKID(expr->Identifier); OUT("static int\n"); OUT("memb_%s_%d_constraint(asn1_TYPE_descriptor_t *td, const void *sptr,\n", p, global_memb_unique); INDENT(+1); @@ -1357,11 +1400,13 @@ emit_type_DEF(arg_t *arg, asn1p_expr_t *expr, enum tvm_compat tv_mode, int tags_ p = asn1c_type_name(arg, arg->expr, TNF_SAFE); } + OUT("%s_free,\n", p); + OUT("%s_print,\n", p); OUT("%s_constraint,\n", p); OUT("%s_decode_ber,\n", p); OUT("%s_encode_der,\n", p); - OUT("%s_print,\n", p); - OUT("%s_free,\n", p); + OUT("0, /* Not implemented yet */\n"); + OUT("%s_encode_xer,\n", p); p = MKID(expr->Identifier); @@ -1468,7 +1513,24 @@ expr_better_indirect(arg_t *arg, asn1p_expr_t *expr) { return 0; } - terminal = asn1f_find_terminal_type_ex(arg->asn, arg->mod, expr); + terminal = asn1f_find_terminal_type_ex(arg->asn, expr); return (terminal == top_parent); } + +static int +expr_as_xmlvaluelist(arg_t *arg, asn1p_expr_t *expr) { + expr = asn1f_find_terminal_type_ex(arg->asn, expr); + if(!expr) return 0; + + /* X.680, 25.5, Table 5 */ + switch(expr->expr_type) { + case ASN_CONSTR_CHOICE: + case ASN_BASIC_BOOLEAN: + case ASN_BASIC_ENUMERATED: + case ASN_BASIC_NULL: + return 1; + default: + return 0; + } +} diff --git a/skeletons/ANY.c b/skeletons/ANY.c index 389452cd..a1c77118 100644 --- a/skeletons/ANY.c +++ b/skeletons/ANY.c @@ -2,17 +2,20 @@ * 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 <assert.h> #include <errno.h> asn1_TYPE_descriptor_t asn1_DEF_ANY = { "ANY", + OCTET_STRING_free, + OCTET_STRING_print, asn_generic_no_constraint, OCTET_STRING_decode_ber, OCTET_STRING_encode_der, - OCTET_STRING_print, - OCTET_STRING_free, + 0, /* Not implemented yet */ + ANY_encode_xer, 0, /* Use generic outmost tag fetcher */ 0, 0, 0, 0, -1, /* Both ways are fine (primitive and constructed) */ @@ -21,6 +24,23 @@ asn1_TYPE_descriptor_t asn1_DEF_ANY = { }; +asn_enc_rval_t +ANY_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + + (void)ilevel; + (void)flags; + (void)cb; + (void)app_key; + + /* + * XER-encoding of ANY type is not supported. + */ + + _ASN_ENCODE_FAILED; +} + struct _callback_arg { uint8_t *buffer; size_t offset; @@ -32,7 +52,7 @@ static int ANY__consume_bytes(const void *buffer, size_t size, void *key); int ANY_fromType(ANY_t *st, asn1_TYPE_descriptor_t *td, void *sptr) { struct _callback_arg arg; - der_enc_rval_t erval; + asn_enc_rval_t erval; if(!st || !td) { errno = EINVAL; @@ -53,7 +73,7 @@ ANY_fromType(ANY_t *st, asn1_TYPE_descriptor_t *td, void *sptr) { if(arg.buffer) FREEMEM(arg.buffer); return -1; } - assert(erval.encoded == arg.offset); + assert((size_t)erval.encoded == arg.offset); if(st->buf) FREEMEM(st->buf); st->buf = arg.buffer; diff --git a/skeletons/ANY.h b/skeletons/ANY.h index 719b3a99..d010de4a 100644 --- a/skeletons/ANY.h +++ b/skeletons/ANY.h @@ -17,10 +17,11 @@ typedef struct ANY { extern asn1_TYPE_descriptor_t asn1_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; -asn_struct_print_f ANY_print; -asn_struct_free_f ANY_free; +xer_type_encoder_f ANY_encode_xer; /****************************** * Handy conversion routines. * diff --git a/skeletons/BIT_STRING.c b/skeletons/BIT_STRING.c index a43a22aa..b6da3aea 100644 --- a/skeletons/BIT_STRING.c +++ b/skeletons/BIT_STRING.c @@ -2,6 +2,7 @@ * 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> /* @@ -12,11 +13,13 @@ static ber_tlv_tag_t asn1_DEF_BIT_STRING_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_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 */ - BIT_STRING_print, - OCTET_STRING_free, /* Implemented in terms of OCTET STRING */ + 0, /* Not implemented yet */ + BIT_STRING_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_BIT_STRING_tags, sizeof(asn1_DEF_BIT_STRING_tags) @@ -61,6 +64,66 @@ BIT_STRING_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, 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(asn1_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; + 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++; buf < end; buf++) { + int v = *buf; + int nline = (flags & XER_F_CANONICAL) + ?0:((((buf - st->buf) - 1) % 16) == 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; + } + + er.encoded += p - scratch; + _ASN_CALLBACK(scratch, p - scratch); + + if(buf < end + 1) { + int v = *buf; + int mbit = st->buf[0]; /* bits to skip from the right */ + int i; + for(i = 7; i >= mbit; i--) + *p++ = (v & (1 << i)) ? '1' : '0'; + er.encoded += p - scratch; + _ASN_CALLBACK(scratch, p - scratch); + } + + return er; +} + + /* * BIT STRING specific contents printer. */ @@ -99,6 +162,7 @@ BIT_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, *p++ = h2c[*buf & 0x0F]; *p++ = 0x20; } + if(p > scratch) p--; /* Eat the tailing space */ /* Dump the incomplete 16-bytes row */ return cb(scratch, p - scratch, app_key); diff --git a/skeletons/BIT_STRING.h b/skeletons/BIT_STRING.h index 1def8bb2..f9ebf9b7 100644 --- a/skeletons/BIT_STRING.h +++ b/skeletons/BIT_STRING.h @@ -14,5 +14,6 @@ extern asn1_TYPE_descriptor_t asn1_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; #endif /* _BIT_STRING_H_ */ diff --git a/skeletons/BMPString.c b/skeletons/BMPString.c index 3e779cce..bdbd40d6 100644 --- a/skeletons/BMPString.c +++ b/skeletons/BMPString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <BMPString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_BMPString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_BMPString = { "BMPString", + OCTET_STRING_free, /* Implemented in terms of OCTET STRING */ + BMPString_print, asn_generic_no_constraint, /* No constraint by default */ OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - BMPString_print, - OCTET_STRING_free, /* -//- */ + 0, /* Not implemented yet */ + BMPString_encode_xer, /* Conver to UTF8 */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_BMPString_tags, sizeof(asn1_DEF_BMPString_tags) @@ -33,27 +36,22 @@ asn1_TYPE_descriptor_t asn1_DEF_BMPString = { /* * BMPString specific contents printer. */ -int -BMPString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, +static ssize_t +BMPString__dump(const BMPString_t *st, asn_app_consume_bytes_f *cb, void *app_key) { - const BMPString_t *st = (const BMPString_t *)sptr; - uint16_t *wchar; - uint16_t *wend; char scratch[128]; /* Scratchpad buffer */ - char *p; + char *p = scratch; + ssize_t wrote = 0; + uint8_t *ch; + uint8_t *end; - (void)td; /* Unused argument */ - (void)ilevel; /* Unused argument */ - - if(!st || !st->buf) return cb("<absent>", 8, app_key); - - wchar = (uint16_t *)st->buf; - wend = (uint16_t *)(st->buf + st->size); - for(p = scratch; wchar < wend; wchar++) { - uint16_t wc = (((uint8_t *)wchar)[0] << 8) - | ((uint8_t *)wchar)[1]; /* 2 bytes */ + ch = st->buf; + end = (st->buf + st->size); + for(end--; ch < end; ch += 2) { + uint16_t wc = (ch[0] << 8) | ch[1]; /* 2 bytes */ if(sizeof(scratch) - (p - scratch) < 3) { - if(cb(scratch, p - scratch, app_key)) + wrote += p - scratch; + if(cb(scratch, p - scratch, app_key) < 0) return -1; p = scratch; } @@ -69,5 +67,45 @@ BMPString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, } } - return cb(scratch, p - scratch, app_key); + wrote += p - scratch; + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + + return wrote; } + +asn_enc_rval_t +BMPString_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const BMPString_t *st = (const BMPString_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = BMPString__dump(st, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + return er; +} + +int +BMPString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const BMPString_t *st = (const BMPString_t *)sptr; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(!st || !st->buf) return cb("<absent>", 8, app_key); + + if(BMPString__dump(st, cb, app_key) < 0) + return -1; + + return 0; +} + diff --git a/skeletons/BMPString.h b/skeletons/BMPString.h index e3957ca0..31d67eae 100644 --- a/skeletons/BMPString.h +++ b/skeletons/BMPString.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. + * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ #ifndef _BMPString_H_ @@ -13,5 +13,6 @@ typedef OCTET_STRING_t BMPString_t; /* Implemented in terms of OCTET STRING */ extern asn1_TYPE_descriptor_t asn1_DEF_BMPString; asn_struct_print_f BMPString_print; /* Human-readable output */ +xer_type_encoder_f BMPString_encode_xer; #endif /* _BMPString_H_ */ diff --git a/skeletons/BOOLEAN.c b/skeletons/BOOLEAN.c index 5ba2e4f8..9609a19e 100644 --- a/skeletons/BOOLEAN.c +++ b/skeletons/BOOLEAN.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <BOOLEAN.h> /* @@ -12,11 +13,13 @@ static ber_tlv_tag_t asn1_DEF_BOOLEAN_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_BOOLEAN = { "BOOLEAN", + BOOLEAN_free, + BOOLEAN_print, asn_generic_no_constraint, BOOLEAN_decode_ber, BOOLEAN_encode_der, - BOOLEAN_print, - BOOLEAN_free, + 0, /* Not implemented yet */ + BOOLEAN_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_BOOLEAN_tags, sizeof(asn1_DEF_BOOLEAN_tags) / sizeof(asn1_DEF_BOOLEAN_tags[0]), @@ -93,11 +96,11 @@ BOOLEAN_decode_ber(asn1_TYPE_descriptor_t *td, return rval; } -der_enc_rval_t +asn_enc_rval_t BOOLEAN_encode_der(asn1_TYPE_descriptor_t *td, void *sptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; BOOLEAN_t *st = (BOOLEAN_t *)sptr; erval.encoded = der_write_tags(td, 1, tag_mode, tag, cb, app_key); @@ -126,6 +129,29 @@ BOOLEAN_encode_der(asn1_TYPE_descriptor_t *td, void *sptr, return erval; } +asn_enc_rval_t +BOOLEAN_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const BOOLEAN_t *st = (const BOOLEAN_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st) _ASN_ENCODE_FAILED; + + if(*st) { + _ASN_CALLBACK("<true/>", 7); + er.encoded = 7; + } else { + _ASN_CALLBACK("<false/>", 8); + er.encoded = 8; + } + + return er; +} + int BOOLEAN_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/BOOLEAN.h b/skeletons/BOOLEAN.h index 6ad69a45..b9b836ee 100644 --- a/skeletons/BOOLEAN.h +++ b/skeletons/BOOLEAN.h @@ -16,9 +16,10 @@ typedef int BOOLEAN_t; extern asn1_TYPE_descriptor_t asn1_DEF_BOOLEAN; +asn_struct_free_f BOOLEAN_free; +asn_struct_print_f BOOLEAN_print; ber_type_decoder_f BOOLEAN_decode_ber; der_type_encoder_f BOOLEAN_encode_der; -asn_struct_print_f BOOLEAN_print; -asn_struct_free_f BOOLEAN_free; +xer_type_encoder_f BOOLEAN_encode_xer; #endif /* _BOOLEAN_H_ */ diff --git a/skeletons/ENUMERATED.c b/skeletons/ENUMERATED.c index ed908b56..158119d6 100644 --- a/skeletons/ENUMERATED.c +++ b/skeletons/ENUMERATED.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <ENUMERATED.h> /* @@ -12,11 +13,13 @@ static ber_tlv_tag_t asn1_DEF_ENUMERATED_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_ENUMERATED = { "ENUMERATED", + INTEGER_free, /* Implemented in terms of INTEGER */ + INTEGER_print, /* Implemented in terms of INTEGER */ asn_generic_no_constraint, INTEGER_decode_ber, /* Implemented in terms of INTEGER */ INTEGER_encode_der, /* Implemented in terms of INTEGER */ - INTEGER_print, /* Implemented in terms of INTEGER */ - INTEGER_free, /* Implemented in terms of INTEGER */ + 0, /* Not implemented yet */ + INTEGER_encode_xer, /* Implemented in terms of INTEGER */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_ENUMERATED_tags, sizeof(asn1_DEF_ENUMERATED_tags) / sizeof(asn1_DEF_ENUMERATED_tags[0]), diff --git a/skeletons/GeneralString.c b/skeletons/GeneralString.c index dfca2cac..c9d82480 100644 --- a/skeletons/GeneralString.c +++ b/skeletons/GeneralString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <GeneralString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_GeneralString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_GeneralString = { "GeneralString", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii string */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print, /* non-ascii string */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, /* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_GeneralString_tags, sizeof(asn1_DEF_GeneralString_tags) diff --git a/skeletons/GeneralizedTime.c b/skeletons/GeneralizedTime.c index 88806f91..8f8fff21 100644 --- a/skeletons/GeneralizedTime.c +++ b/skeletons/GeneralizedTime.c @@ -2,6 +2,7 @@ * 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 <GeneralizedTime.h> #include <time.h> #include <errno.h> @@ -113,11 +114,13 @@ static ber_tlv_tag_t asn1_DEF_GeneralizedTime_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_GeneralizedTime = { "GeneralizedTime", + OCTET_STRING_free, + GeneralizedTime_print, GeneralizedTime_constraint, /* Check validity of time */ OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ GeneralizedTime_encode_der, /* Implemented in terms of OCTET STRING */ - GeneralizedTime_print, - OCTET_STRING_free, + 0, /* Not implemented yet */ + GeneralizedTime_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_GeneralizedTime_tags, sizeof(asn1_DEF_GeneralizedTime_tags) @@ -153,12 +156,12 @@ GeneralizedTime_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, return 0; } -der_enc_rval_t +asn_enc_rval_t GeneralizedTime_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { GeneralizedTime_t *st = (GeneralizedTime_t *)ptr; - der_enc_rval_t erval; + asn_enc_rval_t erval; /* If not canonical DER, re-encode into canonical DER. */ if(st->size && st->buf[st->size-1] != 'Z') { @@ -194,6 +197,36 @@ GeneralizedTime_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, return erval; } +asn_enc_rval_t +GeneralizedTime_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + OCTET_STRING_t st; + + if(flags & XER_F_CANONICAL) { + char buf[32]; + struct tm tm; + ssize_t ret; + + errno = EPERM; + if(asn_GT2time((GeneralizedTime_t *)sptr, &tm, 1) == -1 + && errno != EPERM) + _ASN_ENCODE_FAILED; + + ret = snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d%02dZ", + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec); + assert(ret > 0 && ret < (int)sizeof(buf)); + + st.buf = (uint8_t *)buf; + st.size = ret; + sptr = &st; + } + + return OCTET_STRING_encode_xer_ascii(td, sptr, ilevel, flags, + cb, app_key); +} + int GeneralizedTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/GeneralizedTime.h b/skeletons/GeneralizedTime.h index a7a8a4a2..06b4ca5f 100644 --- a/skeletons/GeneralizedTime.h +++ b/skeletons/GeneralizedTime.h @@ -12,9 +12,10 @@ typedef OCTET_STRING_t GeneralizedTime_t; /* Implemented using OCTET STRING */ extern asn1_TYPE_descriptor_t asn1_DEF_GeneralizedTime; +asn_struct_print_f GeneralizedTime_print; asn_constr_check_f GeneralizedTime_constraint; der_type_encoder_f GeneralizedTime_encode_der; -asn_struct_print_f GeneralizedTime_print; +xer_type_encoder_f GeneralizedTime_encode_xer; /*********************** * Some handy helpers. * diff --git a/skeletons/GraphicString.c b/skeletons/GraphicString.c index ceb247d6..e8fa7975 100644 --- a/skeletons/GraphicString.c +++ b/skeletons/GraphicString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <GraphicString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_GraphicString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_GraphicString = { "GraphicString", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii string */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print, /* non-ascii string */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, /* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_GraphicString_tags, sizeof(asn1_DEF_GraphicString_tags) diff --git a/skeletons/IA5String.c b/skeletons/IA5String.c index 9fc308b1..a2c828dd 100644 --- a/skeletons/IA5String.c +++ b/skeletons/IA5String.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <IA5String.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_IA5String_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_IA5String = { "IA5String", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* ASCII subset */ IA5String_constraint, /* Constraint on the alphabet */ OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* ASCII subset */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_IA5String_tags, sizeof(asn1_DEF_IA5String_tags) @@ -63,3 +66,4 @@ IA5String_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, return 0; } + diff --git a/skeletons/INTEGER.c b/skeletons/INTEGER.c index 5bfcf1fb..75782a68 100644 --- a/skeletons/INTEGER.c +++ b/skeletons/INTEGER.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 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 <assert.h> #include <errno.h> @@ -14,11 +15,13 @@ static ber_tlv_tag_t asn1_DEF_INTEGER_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_INTEGER = { "INTEGER", + INTEGER_free, + INTEGER_print, asn_generic_no_constraint, INTEGER_decode_ber, INTEGER_encode_der, - INTEGER_print, - INTEGER_free, + 0, /* Not implemented yet */ + INTEGER_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_INTEGER_tags, sizeof(asn1_DEF_INTEGER_tags) / sizeof(asn1_DEF_INTEGER_tags[0]), @@ -100,11 +103,11 @@ INTEGER_decode_ber(asn1_TYPE_descriptor_t *td, /* * Encode INTEGER type using DER. */ -der_enc_rval_t +asn_enc_rval_t INTEGER_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; INTEGER_t *st = (INTEGER_t *)ptr; ASN_DEBUG("%s %s as INTEGER (tm=%d)", @@ -185,24 +188,19 @@ INTEGER_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, /* * INTEGER specific human-readable output. */ -int -INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, - asn_app_consume_bytes_f *cb, void *app_key) { +static ssize_t +INTEGER__dump(const INTEGER_t *st, asn_app_consume_bytes_f *cb, void *app_key) { char scratch[32]; /* Enough for 64-bit integer */ - const INTEGER_t *st = (const INTEGER_t *)sptr; uint8_t *buf = st->buf; uint8_t *buf_end = st->buf + st->size; signed long accum; + ssize_t wrote = 0; char *p; int ret; - (void)td; /* Unused argument */ - (void)ilevel; /* Unused argument */ - - if(!st && !st->buf) return cb("<absent>", 8, app_key); - - if(st->size == 0) - return cb("0", 1, app_key); + if(st->size == 0) { + return (cb("0", 1, app_key) < 0) ? -1 : 1; + } /* * Advance buf pointer until the start of the value's body. @@ -226,7 +224,7 @@ INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, accum = (accum << 8) | *buf; ret = snprintf(scratch, sizeof(scratch), "%ld", accum); assert(ret > 0 && ret < (int)sizeof(scratch)); - return cb(scratch, ret, app_key); + return (cb(scratch, ret, app_key) < 0) ? -1 : ret; } /* Output in the long xx:yy:zz... format */ @@ -235,8 +233,9 @@ INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, static const char *h2c = "0123456789ABCDEF"; if((p - scratch) >= (ssize_t)(sizeof(scratch) - 4)) { /* Flush buffer */ - if(cb(scratch, p - scratch, app_key)) + if(cb(scratch, p - scratch, app_key) < 0) return -1; + wrote += p - scratch; p = scratch; } *p++ = h2c[*buf >> 4]; @@ -246,7 +245,43 @@ INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, if(p != scratch) p--; /* Remove the last ':' */ - return cb(scratch, p - scratch, app_key); + wrote += p - scratch; + return (cb(scratch, p - scratch, app_key) < 0) ? -1 : wrote; +} + +/* + * INTEGER specific human-readable output. + */ +int +INTEGER_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + + (void)td; + (void)ilevel; + + if(!st && !st->buf) return cb("<absent>", 8, app_key); + + return (INTEGER__dump(st, cb, app_key) < 0) ? -1 : 0; +} + +asn_enc_rval_t +INTEGER_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const INTEGER_t *st = (const INTEGER_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st && !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = INTEGER__dump(st, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + return er; } void diff --git a/skeletons/INTEGER.h b/skeletons/INTEGER.h index ef4d3f25..8e3c5458 100644 --- a/skeletons/INTEGER.h +++ b/skeletons/INTEGER.h @@ -14,10 +14,11 @@ typedef struct INTEGER { extern asn1_TYPE_descriptor_t asn1_DEF_INTEGER; +asn_struct_free_f INTEGER_free; +asn_struct_print_f INTEGER_print; ber_type_decoder_f INTEGER_decode_ber; der_type_encoder_f INTEGER_encode_der; -asn_struct_print_f INTEGER_print; -asn_struct_free_f INTEGER_free; +xer_type_encoder_f INTEGER_encode_xer; /*********************************** * Some handy conversion routines. * diff --git a/skeletons/ISO646String.c b/skeletons/ISO646String.c index 8a99cbcb..e5a4d444 100644 --- a/skeletons/ISO646String.c +++ b/skeletons/ISO646String.c @@ -2,6 +2,7 @@ * 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 <ISO646String.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_ISO646String_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_ISO646String = { "ISO646String", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* ASCII subset */ VisibleString_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* ASCII subset */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_ISO646String_tags, sizeof(asn1_DEF_ISO646String_tags) diff --git a/skeletons/NULL.c b/skeletons/NULL.c index 36796b8a..e15b9af8 100644 --- a/skeletons/NULL.c +++ b/skeletons/NULL.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <NULL.h> #include <BOOLEAN.h> /* Implemented in terms of BOOLEAN type */ @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_NULL_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_NULL = { "NULL", + BOOLEAN_free, + NULL_print, asn_generic_no_constraint, BOOLEAN_decode_ber, /* Implemented in terms of BOOLEAN */ NULL_encode_der, /* Special handling of DER encoding */ - NULL_print, - BOOLEAN_free, + 0, /* Not implemented yet */ + NULL_encode_xer, /* Special handling of DER encoding */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_NULL_tags, sizeof(asn1_DEF_NULL_tags) / sizeof(asn1_DEF_NULL_tags[0]), @@ -28,21 +31,40 @@ asn1_TYPE_descriptor_t asn1_DEF_NULL = { 0 /* No specifics */ }; -der_enc_rval_t -NULL_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, +asn_enc_rval_t +NULL_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; - erval.encoded = der_write_tags(sd, 0, tag_mode, tag, cb, app_key); + erval.encoded = der_write_tags(td, 0, tag_mode, tag, cb, app_key); if(erval.encoded == -1) { - erval.failed_type = sd; + erval.failed_type = td; erval.structure_ptr = ptr; } return erval; } +asn_enc_rval_t +NULL_encode_xer(asn1_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; + + (void)td; + (void)sptr; + (void)ilevel; + (void)flags; + (void)cb; + (void)app_key; + + /* XMLNullValue is empty */ + er.encoded = 0; + + return er; +} + int NULL_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/NULL.h b/skeletons/NULL.h index 003a5a63..0c07ffe8 100644 --- a/skeletons/NULL.h +++ b/skeletons/NULL.h @@ -15,7 +15,8 @@ typedef int NULL_t; extern asn1_TYPE_descriptor_t asn1_DEF_NULL; -der_type_encoder_f NULL_encode_der; asn_struct_print_f NULL_print; +der_type_encoder_f NULL_encode_der; +xer_type_encoder_f NULL_encode_xer; #endif /* NULL_H */ diff --git a/skeletons/NativeEnumerated.c b/skeletons/NativeEnumerated.c index 53ce5012..ec4dd88d 100644 --- a/skeletons/NativeEnumerated.c +++ b/skeletons/NativeEnumerated.c @@ -9,6 +9,7 @@ * implementation deals with the standard (machine-specific) representation * of them instead of using the platform-independent buffer. */ +#include <asn_internal.h> #include <NativeEnumerated.h> /* @@ -19,11 +20,13 @@ static ber_tlv_tag_t asn1_DEF_NativeEnumerated_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_NativeEnumerated = { "ENUMERATED", /* The ASN.1 type is still ENUMERATED */ + NativeInteger_free, + NativeInteger_print, asn_generic_no_constraint, NativeInteger_decode_ber, NativeInteger_encode_der, - NativeInteger_print, - NativeInteger_free, + 0, /* Not implemented yet */ + NativeInteger_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_NativeEnumerated_tags, sizeof(asn1_DEF_NativeEnumerated_tags) / sizeof(asn1_DEF_NativeEnumerated_tags[0]), diff --git a/skeletons/NativeInteger.c b/skeletons/NativeInteger.c index 98fee965..b0872a2e 100644 --- a/skeletons/NativeInteger.c +++ b/skeletons/NativeInteger.c @@ -9,6 +9,7 @@ * implementation deals with the standard (machine-specific) representation * of them instead of using the platform-independent buffer. */ +#include <asn_internal.h> #include <NativeInteger.h> #include <INTEGER.h> #include <assert.h> @@ -21,11 +22,13 @@ static ber_tlv_tag_t asn1_DEF_NativeInteger_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_NativeInteger = { "INTEGER", /* The ASN.1 type is still INTEGER */ + NativeInteger_free, + NativeInteger_print, asn_generic_no_constraint, NativeInteger_decode_ber, NativeInteger_encode_der, - NativeInteger_print, - NativeInteger_free, + 0, /* Not implemented yet */ + NativeInteger_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_NativeInteger_tags, sizeof(asn1_DEF_NativeInteger_tags) / sizeof(asn1_DEF_NativeInteger_tags[0]), @@ -127,17 +130,17 @@ NativeInteger_decode_ber(asn1_TYPE_descriptor_t *td, /* * Encode the NativeInteger using the standard INTEGER type DER encoder. */ -der_enc_rval_t +asn_enc_rval_t NativeInteger_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { unsigned int Int = *(unsigned int *)ptr; /* Disable sign ext. */ - der_enc_rval_t erval; + asn_enc_rval_t erval; INTEGER_t tmp; #ifdef WORDS_BIGENDIAN /* Opportunistic optimization */ - tmp.buf = ∬ + tmp.buf = (uint8_t *)∬ tmp.size = sizeof(Int); #else /* Works even if WORDS_BIGENDIAN is not set where should've been */ @@ -161,6 +164,27 @@ NativeInteger_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, return erval; } +asn_enc_rval_t +NativeInteger_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + char scratch[32]; /* Enough for 64-bit int */ + asn_enc_rval_t er; + const int *Int = (const int *)sptr; + + (void)ilevel; + (void)flags; + + if(!Int) _ASN_ENCODE_FAILED; + + er.encoded = snprintf(scratch, sizeof(scratch), "%d", *Int); + if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch) + || cb(scratch, er.encoded, app_key) < 0) + _ASN_ENCODE_FAILED; + + return er; +} + /* * INTEGER specific human-readable output. */ diff --git a/skeletons/NativeInteger.h b/skeletons/NativeInteger.h index e0f26c78..2d0cddaa 100644 --- a/skeletons/NativeInteger.h +++ b/skeletons/NativeInteger.h @@ -16,9 +16,10 @@ extern asn1_TYPE_descriptor_t asn1_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; -asn_struct_print_f NativeInteger_print; -asn_struct_free_f NativeInteger_free; +xer_type_encoder_f NativeInteger_encode_xer; #endif /* _NativeInteger_H_ */ diff --git a/skeletons/NativeReal.c b/skeletons/NativeReal.c index e7cc28f9..1566a7fb 100644 --- a/skeletons/NativeReal.c +++ b/skeletons/NativeReal.c @@ -9,6 +9,7 @@ * implementation deals with the standard (machine-specific) representation * of them instead of using the platform-independent buffer. */ +#include <asn_internal.h> #include <NativeReal.h> #include <INTEGER.h> #include <REAL.h> @@ -22,11 +23,13 @@ static ber_tlv_tag_t asn1_DEF_NativeReal_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_NativeReal = { "REAL", /* The ASN.1 type is still REAL */ + NativeReal_free, + NativeReal_print, asn_generic_no_constraint, NativeReal_decode_ber, NativeReal_encode_der, - NativeReal_print, - NativeReal_free, + 0, /* Not implemented yet */ + NativeReal_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_NativeReal_tags, sizeof(asn1_DEF_NativeReal_tags) / sizeof(asn1_DEF_NativeReal_tags[0]), @@ -116,12 +119,12 @@ NativeReal_decode_ber(asn1_TYPE_descriptor_t *td, /* * Encode the NativeReal using the standard REAL type DER encoder. */ -der_enc_rval_t +asn_enc_rval_t NativeReal_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { double Dbl = *(const double *)ptr; - der_enc_rval_t erval; + asn_enc_rval_t erval; REAL_t tmp; if(asn1_double2REAL(&tmp, Dbl)) { @@ -140,6 +143,25 @@ NativeReal_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, return erval; } + +asn_enc_rval_t +NativeReal_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const double *Dbl = (const double *)sptr; + asn_enc_rval_t er; + double d; + + (void)ilevel; + + if(!Dbl) _ASN_ENCODE_FAILED; + + er.encoded = REAL__dump(d, flags & XER_F_CANONICAL, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + return er; +} + /* * REAL specific human-readable output. */ @@ -147,32 +169,13 @@ int NativeReal_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { const double *Dbl = (const double *)sptr; - char scratch[64]; - int ret; (void)td; /* Unused argument */ (void)ilevel; /* Unused argument */ - if(Dbl) { - char *p = scratch; - int buf_size = sizeof(scratch); - for(;;) { - ret = snprintf(p, buf_size, "%f", *Dbl); - if(ret >= 0 && ret < buf_size) { - ret = cb(p, ret, app_key); - if(p != scratch) free(p); - return ret; - } else { - if(p != scratch) free(p); - } - if(ret < 0) buf_size <<= 2; /* Old libc. */ - else buf_size = ret + 1; - (void *)p = MALLOC(ret); - if(!p) return -1; - } - } else { - return cb("<absent>", 8, app_key); - } + if(!Dbl) return cb("<absent>", 8, app_key); + + return (REAL__dump(*Dbl, 0, cb, app_key) < 0) ? -1 : 0; } void diff --git a/skeletons/NativeReal.h b/skeletons/NativeReal.h index 1a5436df..a130a334 100644 --- a/skeletons/NativeReal.h +++ b/skeletons/NativeReal.h @@ -15,9 +15,10 @@ extern asn1_TYPE_descriptor_t asn1_DEF_NativeReal; +asn_struct_free_f NativeReal_free; +asn_struct_print_f NativeReal_print; ber_type_decoder_f NativeReal_decode_ber; der_type_encoder_f NativeReal_encode_der; -asn_struct_print_f NativeReal_print; -asn_struct_free_f NativeReal_free; +xer_type_encoder_f NativeReal_encode_xer; #endif /* ASN_TYPE_NativeReal_H */ diff --git a/skeletons/NumericString.c b/skeletons/NumericString.c index a23e39f1..b4a6df92 100644 --- a/skeletons/NumericString.c +++ b/skeletons/NumericString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <NumericString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_NumericString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_NumericString = { "NumericString", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* ASCII subset */ NumericString_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* ASCII subset */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_NumericString_tags, sizeof(asn1_DEF_NumericString_tags) diff --git a/skeletons/OBJECT_IDENTIFIER.c b/skeletons/OBJECT_IDENTIFIER.c index c55410d5..43ced796 100644 --- a/skeletons/OBJECT_IDENTIFIER.c +++ b/skeletons/OBJECT_IDENTIFIER.c @@ -2,6 +2,7 @@ * 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 <OBJECT_IDENTIFIER.h> #include <limits.h> /* for CHAR_BIT */ #include <assert.h> @@ -15,11 +16,13 @@ static ber_tlv_tag_t asn1_DEF_OBJECT_IDENTIFIER_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_OBJECT_IDENTIFIER = { "OBJECT IDENTIFIER", + INTEGER_free, + OBJECT_IDENTIFIER_print, OBJECT_IDENTIFIER_constraint, INTEGER_decode_ber, /* Implemented in terms of INTEGER type */ OBJECT_IDENTIFIER_encode_der, - OBJECT_IDENTIFIER_print, - INTEGER_free, + 0, /* Not implemented yet */ + OBJECT_IDENTIFIER_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_OBJECT_IDENTIFIER_tags, sizeof(asn1_DEF_OBJECT_IDENTIFIER_tags) @@ -36,11 +39,11 @@ asn1_TYPE_descriptor_t asn1_DEF_OBJECT_IDENTIFIER = { /* * Encode OBJECT IDENTIFIER type using DER. */ -der_enc_rval_t +asn_enc_rval_t OBJECT_IDENTIFIER_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; OBJECT_IDENTIFIER_t *st = (OBJECT_IDENTIFIER_t *)ptr; ASN_DEBUG("%s %s as OBJECT IDENTIFIER (tm=%d)", @@ -57,10 +60,8 @@ OBJECT_IDENTIFIER_encode_der(asn1_TYPE_descriptor_t *sd, void *ptr, } if(cb && st->buf) { - ssize_t ret; - - ret = cb(st->buf, st->size, app_key); - if(ret == -1) { + int ret = cb(st->buf, st->size, app_key); + if(ret < 0) { erval.encoded = -1; erval.failed_type = sd; erval.structure_ptr = ptr; @@ -215,9 +216,8 @@ OBJECT_IDENTIFIER_get_single_arc(uint8_t *arcbuf, unsigned int arclen, signed in return 0; } - -int -OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add, +ssize_t +OBJECT_IDENTIFIER__dump_arc(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 */ @@ -228,35 +228,41 @@ OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add, 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; + *(--p) = (char)(accum % 10) + 0x30; /* Put a digit */ - return cb(p, sizeof(scratch) - (p - scratch), app_key); + len = sizeof(scratch) - (p - scratch); + if(cb(p, len, app_key) < 0) + return -1; + return len; } else { *scratch = 0x30; - return cb(scratch, 1, app_key); + if(cb(scratch, 1, app_key) < 0) + return -1; + return 1; } } int -OBJECT_IDENTIFIER_print(asn1_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; - int startn; - int add = 0; - int i; +OBJECT_IDENTIFIER_print_arc(uint8_t *arcbuf, int arclen, int add, + asn_app_consume_bytes_f *cb, void *app_key) { - (void)td; /* Unused argument */ - (void)ilevel; /* Unused argument */ + if(OBJECT_IDENTIFIER__dump_arc(arcbuf, arclen, add, cb, app_key) < 0) + return -1; - if(!st || !st->buf) - return cb("<absent>", 8, app_key); + return 0; +} - /* Dump preamble */ - if(cb("{ ", 2, app_key)) - return -1; +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]; @@ -269,30 +275,71 @@ OBJECT_IDENTIFIER_print(asn1_TYPE_descriptor_t *td, const void *sptr, */ if(i) { add = -80; - if(cb("2", 1, app_key)) return -1; + if(cb("2", 1, app_key) < 0) return -1; } else if(b <= 39) { add = 0; - if(cb("0", 1, app_key)) return -1; + if(cb("0", 1, app_key) < 0) return -1; } else if(b < 79) { add = -40; - if(cb("1", 1, app_key)) return -1; + if(cb("1", 1, app_key) < 0) return -1; } else { add = -80; - if(cb("2", 1, app_key)) return -1; + if(cb("2", 1, app_key) < 0) return -1; } + wrote_len += 1; } - if(cb(" ", 1, app_key)) /* Separate arcs */ + if(cb(".", 1, app_key) < 0) /* Separate arcs */ return -1; - if(OBJECT_IDENTIFIER_print_arc(&st->buf[startn], - i - startn + 1, add, - cb, app_key)) - 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; +} + +asn_enc_rval_t +OBJECT_IDENTIFIER_encode_xer(asn1_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; + + return er; +} + +int +OBJECT_IDENTIFIER_print(asn1_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); + + /* Dump preamble */ + if(cb("{ ", 2, app_key)) + return -1; + + if(OBJECT_IDENTIFIER__dump_body(st, cb, app_key) < 0) + return -1; + return cb(" }", 2, app_key); } diff --git a/skeletons/OBJECT_IDENTIFIER.h b/skeletons/OBJECT_IDENTIFIER.h index 8d43c997..4f45090c 100644 --- a/skeletons/OBJECT_IDENTIFIER.h +++ b/skeletons/OBJECT_IDENTIFIER.h @@ -12,9 +12,10 @@ typedef INTEGER_t OBJECT_IDENTIFIER_t; /* Implemented in terms of INTEGER */ extern asn1_TYPE_descriptor_t asn1_DEF_OBJECT_IDENTIFIER; -der_type_encoder_f OBJECT_IDENTIFIER_encode_der; -asn_constr_check_f OBJECT_IDENTIFIER_constraint; asn_struct_print_f OBJECT_IDENTIFIER_print; +asn_constr_check_f OBJECT_IDENTIFIER_constraint; +der_type_encoder_f OBJECT_IDENTIFIER_encode_der; +xer_type_encoder_f OBJECT_IDENTIFIER_encode_xer; /********************************** * Some handy conversion routines * @@ -27,6 +28,10 @@ int OBJECT_IDENTIFIER_print_arc(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(uint8_t *arcbuf, int arclen, int add, + asn_app_consume_bytes_f *cb, void *app_key); + /* * This function fills an (_arcs) array with OBJECT IDENTIFIER arcs * up to specified (_arc_slots) elements. diff --git a/skeletons/OCTET_STRING.c b/skeletons/OCTET_STRING.c index e0af730a..4b7bd66e 100644 --- a/skeletons/OCTET_STRING.c +++ b/skeletons/OCTET_STRING.c @@ -2,6 +2,7 @@ * 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 <OCTET_STRING.h> #include <assert.h> #include <errno.h> @@ -14,11 +15,13 @@ static ber_tlv_tag_t asn1_DEF_OCTET_STRING_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_OCTET_STRING = { "OCTET STRING", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii stuff, generally */ asn_generic_no_constraint, OCTET_STRING_decode_ber, OCTET_STRING_encode_der, - OCTET_STRING_print, /* non-ascii stuff, generally */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_OCTET_STRING_tags, sizeof(asn1_DEF_OCTET_STRING_tags) @@ -440,11 +443,11 @@ OCTET_STRING_decode_ber(asn1_TYPE_descriptor_t *td, /* * Encode OCTET STRING type using DER. */ -der_enc_rval_t +asn_enc_rval_t OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; OCTET_STRING_t *st = (OCTET_STRING_t *)ptr; int add_byte = 0; int is_bit_str = (td->specifics == (void *)-1); @@ -514,6 +517,84 @@ OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, return erval; } +asn_enc_rval_t +OCTET_STRING_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + static const char *h2c = "0123456789ABCDEF"; + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + asn_enc_rval_t er; + char scratch[16 * 3 + 4]; + char *p = scratch; + uint8_t *buf; + uint8_t *end; + size_t i; + + if(!st || !st->buf) { + er.encoded = -1; + er.failed_type = td; + er.structure_ptr = sptr; + return er; + } + + er.encoded = 0; + + /* + * Dump the contents of the buffer in hexadecimal. + */ + buf = st->buf; + end = buf + st->size; + if(flags & XER_F_CANONICAL) { + char *scend = scratch + (sizeof(scratch) - 2); + for(; buf < end; buf++) { + if(p >= scend) { + _ASN_CALLBACK(scratch, p - scratch); + er.encoded += p - scratch; + p = scratch; + } + *p++ = h2c[(*buf >> 4) & 0x0F]; + *p++ = h2c[*buf & 0x0F]; + } + } else { + for(i = 0; buf < end; buf++, i++) { + if(!(i % 16) && (i || st->size > 16)) { + _ASN_CALLBACK(scratch, p-scratch); + er.encoded += (p-scratch); + p = scratch; + _i_ASN_TEXT_INDENT(1, ilevel); + } + *p++ = h2c[(*buf >> 4) & 0x0F]; + *p++ = h2c[*buf & 0x0F]; + *p++ = 0x20; + } + if(i) p--; /* Remove the tail space */ + } + + _ASN_CALLBACK(scratch, p-scratch); /* Dump the rest */ + er.encoded += p - scratch; + + return er; +} + +asn_enc_rval_t +OCTET_STRING_encode_xer_ascii(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; /* Unused argument */ + (void)flags; /* Unused argument */ + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + _ASN_CALLBACK(st->buf, st->size); + er.encoded = st->size; + + return er; +} + int OCTET_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { @@ -524,7 +605,7 @@ OCTET_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, uint8_t *buf; uint8_t *end; size_t i; - int ret; + int lvl; (void)td; /* Unused argument */ @@ -540,14 +621,15 @@ OCTET_STRING_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, if(cb(scratch, p - scratch, app_key) || cb("\n", 1, app_key)) return -1; - for(ret = 0; ret < ilevel; ret++) + for(lvl = 0; lvl < ilevel; lvl++) cb(" ", 1, app_key); p = scratch; } *p++ = h2c[(*buf >> 4) & 0x0F]; *p++ = h2c[*buf & 0x0F]; - *p++ = ' '; + *p++ = 0x20; } + if(i) p--; /* Remove the tail space */ return cb(scratch, p - scratch, app_key); } diff --git a/skeletons/OCTET_STRING.h b/skeletons/OCTET_STRING.h index df6ff4f2..a67cef94 100644 --- a/skeletons/OCTET_STRING.h +++ b/skeletons/OCTET_STRING.h @@ -16,11 +16,13 @@ typedef struct OCTET_STRING { extern asn1_TYPE_descriptor_t asn1_DEF_OCTET_STRING; -ber_type_decoder_f OCTET_STRING_decode_ber; -der_type_encoder_f OCTET_STRING_encode_der; +asn_struct_free_f OCTET_STRING_free; asn_struct_print_f OCTET_STRING_print; asn_struct_print_f OCTET_STRING_print_ascii; -asn_struct_free_f OCTET_STRING_free; +ber_type_decoder_f OCTET_STRING_decode_ber; +der_type_encoder_f OCTET_STRING_encode_der; +xer_type_encoder_f OCTET_STRING_encode_xer; +xer_type_encoder_f OCTET_STRING_encode_xer_ascii; /*********************************** * Some handy conversion routines. * diff --git a/skeletons/ObjectDescriptor.c b/skeletons/ObjectDescriptor.c index 5017918e..4ddcaac7 100644 --- a/skeletons/ObjectDescriptor.c +++ b/skeletons/ObjectDescriptor.c @@ -2,6 +2,7 @@ * 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 <ObjectDescriptor.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_ObjectDescriptor_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_ObjectDescriptor = { "ObjectDescriptor", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* Treat as ASCII subset (it's not) */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* Treat as ASCII subset (it's not) */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_ObjectDescriptor_tags, sizeof(asn1_DEF_ObjectDescriptor_tags) diff --git a/skeletons/PrintableString.c b/skeletons/PrintableString.c index c37de497..1368447f 100644 --- a/skeletons/PrintableString.c +++ b/skeletons/PrintableString.c @@ -2,6 +2,7 @@ * 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 <PrintableString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_PrintableString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_PrintableString = { "PrintableString", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* ASCII subset */ PrintableString_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* ASCII subset */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_PrintableString_tags, sizeof(asn1_DEF_PrintableString_tags) diff --git a/skeletons/REAL.c b/skeletons/REAL.c index e42a0613..7c230103 100644 --- a/skeletons/REAL.c +++ b/skeletons/REAL.c @@ -2,6 +2,7 @@ * 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 <REAL.h> #include <INTEGER.h> #include <stdlib.h> /* for strtod(3) */ @@ -29,11 +30,13 @@ static ber_tlv_tag_t asn1_DEF_REAL_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_REAL = { "REAL", + INTEGER_free, + REAL_print, asn_generic_no_constraint, INTEGER_decode_ber, /* Implemented in terms of INTEGER type */ INTEGER_encode_der, - REAL_print, - INTEGER_free, + 0, /* Not implemented yet */ + REAL_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_REAL_tags, sizeof(asn1_DEF_REAL_tags) / sizeof(asn1_DEF_REAL_tags[0]), @@ -44,33 +47,113 @@ asn1_TYPE_descriptor_t asn1_DEF_REAL = { 0 /* No specifics */ }; +ssize_t +REAL__dump(double d, int canonical, asn_app_consume_bytes_f *cb, void *app_key) { + char local_buf[32]; + char *buf = local_buf; + ssize_t buflen = sizeof(local_buf); + const char *fmt = canonical?"%15E":"f"; + ssize_t ret; + + do { + ret = snprintf(buf, buflen, fmt, d); + if(ret < 0) { + buflen <<= 1; + } else if(ret >= buflen) { + buflen = ret + 1; + } else { + buflen = ret; + break; + } + if(buf != local_buf) free(buf); + (void *)buf = MALLOC(buflen); + if(!buf) return -1; + } while(1); + + /* + * Transform the "[-]d.dddE+-dd" output into "[-]d.dddE[-]d" + */ + if(canonical) { + char *dot, *E; + char *end = buf + buflen; + + dot = (buf[0] == '-') ? (buf + 2) : (buf + 1); + if(*dot >= 0x30) { + errno = EINVAL; + return -1; /* Not a dot, really */ + } + *dot = '.'; /* Replace possible comma */ + + for(E = dot; dot < end; E++) { + if(*E == 'E') { + char *s = ++E; + if(*E == '+') { + /* Skip the "+" too */ + buflen -= 2; + } else { + buflen -= 1; + s++; + } + E += 2; + if(E[-1] != '0' || E > end) { + errno = EINVAL; + return -1; + } + for(; E <= end; s++, E++) + *s = *E; + } + } + if(E == end) { + errno = EINVAL; + return -1; /* No promised E */ + } + } + + ret = cb(buf, buflen, app_key); + if(buf != local_buf) free(buf); + return (ret < 0) ? -1 : buflen; +} + int REAL_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { const REAL_t *st = (const REAL_t *)sptr; - char buf[128]; double d; - int ret; (void)td; /* Unused argument */ (void)ilevel; /* Unused argument */ - if(!st) + if(!st || !st->buf) return cb("<absent>", 8, app_key); if(asn1_REAL2double(st, &d)) return cb("<error>", 7, app_key); - ret = snprintf(buf, sizeof(buf), "%f", d); - if(ret < 0 || ret >= sizeof(buf)) - return cb("<error>", 7, app_key); + return (REAL__dump(d, 0, cb, app_key) < 0) ? -1 : 0; +} + +asn_enc_rval_t +REAL_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + REAL_t *st = (REAL_t *)sptr; + asn_enc_rval_t er; + double d; + + (void)ilevel; + + if(!st || !st->buf || asn1_REAL2double(st, &d)) + _ASN_ENCODE_FAILED; + + er.encoded = REAL__dump(d, flags & XER_F_CANONICAL, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; - return cb(buf, ret, app_key); + return er; } int asn1_REAL2double(const REAL_t *st, double *dbl_value) { - unsigned long octv; + unsigned int octv; if(!st || !st->buf) { errno = EINVAL; @@ -158,7 +241,7 @@ asn1_REAL2double(const REAL_t *st, double *dbl_value) { sign = (octv & 0x40); /* bit 7 */ scaleF = (octv & 0x0C) >> 2; /* bits 4 to 3 */ - if(st->size <= (1 + (octv & 0x03))) { + if(st->size <= (int)(1 + (octv & 0x03))) { errno = EINVAL; return -1; } @@ -166,7 +249,7 @@ asn1_REAL2double(const REAL_t *st, double *dbl_value) { if((octv & 0x03) == 0x11) { /* 8.5.6.4, case d) */ elen = st->buf[1]; /* unsigned binary number */ - if(elen == 0 || st->size <= (2 + elen)) { + if(elen == 0 || st->size <= (int)(2 + elen)) { errno = EINVAL; return -1; } diff --git a/skeletons/REAL.h b/skeletons/REAL.h index 751000b8..83f96d01 100644 --- a/skeletons/REAL.h +++ b/skeletons/REAL.h @@ -15,11 +15,14 @@ typedef struct REAL { extern asn1_TYPE_descriptor_t asn1_DEF_REAL; asn_struct_print_f REAL_print; +xer_type_encoder_f REAL_encode_xer; /*********************************** * Some handy conversion routines. * ***********************************/ +ssize_t REAL__dump(double d, int canonical, asn_app_consume_bytes_f *cb, void *app_key); + /* * Convert between native double type and REAL representation (DER). * RETURN VALUES: diff --git a/skeletons/RELATIVE-OID.c b/skeletons/RELATIVE-OID.c index bee795c4..5d1e1a9d 100644 --- a/skeletons/RELATIVE-OID.c +++ b/skeletons/RELATIVE-OID.c @@ -2,6 +2,7 @@ * 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 <RELATIVE-OID.h> #include <limits.h> /* for CHAR_BIT */ #include <assert.h> @@ -15,11 +16,13 @@ static ber_tlv_tag_t asn1_DEF_RELATIVE_OID_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_RELATIVE_OID = { "RELATIVE-OID", + INTEGER_free, + RELATIVE_OID_print, asn_generic_no_constraint, INTEGER_decode_ber, /* Implemented in terms of INTEGER type */ OBJECT_IDENTIFIER_encode_der, - RELATIVE_OID_print, - INTEGER_free, + 0, /* Not implemented yet */ + RELATIVE_OID_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_RELATIVE_OID_tags, sizeof(asn1_DEF_RELATIVE_OID_tags) @@ -32,12 +35,39 @@ asn1_TYPE_descriptor_t asn1_DEF_RELATIVE_OID = { 0 /* No specifics */ }; +static ssize_t +RELATIVE_OID__dump_body(const RELATIVE_OID_t *st, asn_app_consume_bytes_f *cb, void *app_key) { + ssize_t wrote = 0; + ssize_t ret; + int startn; + 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) { + /* Separate arcs */ + if(cb(".", 1, app_key) < 0) + return -1; + wrote++; + } + + ret = OBJECT_IDENTIFIER__dump_arc(&st->buf[startn], + i - startn + 1, 0, cb, app_key); + if(ret < 0) return -1; + wrote += ret; + + startn = i + 1; + } + + return wrote; +} + int RELATIVE_OID_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { const RELATIVE_OID_t *st = (const RELATIVE_OID_t *)sptr; - int startn; - int i; (void)td; /* Unused argument */ (void)ilevel; /* Unused argument */ @@ -49,21 +79,30 @@ RELATIVE_OID_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, if(cb("{ ", 2, app_key)) return -1; - for(i = 0, startn = 0; i < st->size; i++) { - uint8_t b = st->buf[i]; - if((b & 0x80)) /* Continuation expected */ - continue; - if(startn && cb(" ", 1, app_key)) /* Separate arcs */ - return -1; - if(OBJECT_IDENTIFIER_print_arc(&st->buf[startn], - i - startn + 1, 0, cb, app_key)) - return -1; - startn = i + 1; - } + if(RELATIVE_OID__dump_body(st, cb, app_key) < 0) + return -1; return cb(" }", 2, app_key); } +asn_enc_rval_t +RELATIVE_OID_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + RELATIVE_OID_t *st = (RELATIVE_OID_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; /* Unused argument */ + (void)flags; /* Unused argument */ + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = RELATIVE_OID__dump_body(st, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + return er; +} int RELATIVE_OID_get_arcs(RELATIVE_OID_t *roid, diff --git a/skeletons/RELATIVE-OID.h b/skeletons/RELATIVE-OID.h index 1dafb62d..e6af9346 100644 --- a/skeletons/RELATIVE-OID.h +++ b/skeletons/RELATIVE-OID.h @@ -14,6 +14,7 @@ typedef OBJECT_IDENTIFIER_t RELATIVE_OID_t; extern asn1_TYPE_descriptor_t asn1_DEF_RELATIVE_OID; asn_struct_print_f RELATIVE_OID_print; +xer_type_encoder_f RELATIVE_OID_encode_xer; /********************************** * Some handy conversion routines * diff --git a/skeletons/T61String.c b/skeletons/T61String.c index b306a5ba..d2ac2d5f 100644 --- a/skeletons/T61String.c +++ b/skeletons/T61String.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <T61String.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_T61String_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T61String = { "T61String", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii string */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print, /* non-ascii string */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, /* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_T61String_tags, sizeof(asn1_DEF_T61String_tags) diff --git a/skeletons/TeletexString.c b/skeletons/TeletexString.c index 09f3eb6a..7a569534 100644 --- a/skeletons/TeletexString.c +++ b/skeletons/TeletexString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <TeletexString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_TeletexString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_TeletexString = { "TeletexString", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii string */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print, /* non-ascii string */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, /* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_TeletexString_tags, sizeof(asn1_DEF_TeletexString_tags) diff --git a/skeletons/UTCTime.c b/skeletons/UTCTime.c index 029a43e4..22e5498f 100644 --- a/skeletons/UTCTime.c +++ b/skeletons/UTCTime.c @@ -2,6 +2,7 @@ * 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 <UTCTime.h> #include <GeneralizedTime.h> #include <time.h> @@ -18,11 +19,13 @@ static ber_tlv_tag_t asn1_DEF_UTCTime_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_UTCTime = { "UTCTime", + OCTET_STRING_free, + UTCTime_print, UTCTime_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - UTCTime_print, - OCTET_STRING_free, + 0, /* Not implemented yet */ + UTCTime_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_UTCTime_tags, sizeof(asn1_DEF_UTCTime_tags) @@ -58,6 +61,36 @@ UTCTime_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, return 0; } +asn_enc_rval_t +UTCTime_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + OCTET_STRING_t st; + + if(flags & XER_F_CANONICAL) { + char buf[32]; + struct tm tm; + ssize_t ret; + + errno = EPERM; + if(asn_UT2time((UTCTime_t *)sptr, &tm, 1) == -1 + && errno != EPERM) + _ASN_ENCODE_FAILED; + + ret = snprintf(buf, sizeof(buf), "%02d%02d%02d%02d%02d%02dZ", + tm.tm_year % 100, tm.tm_mon + 1, tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec); + assert(ret > 0 && ret < (int)sizeof(buf)); + + st.buf = (uint8_t *)buf; + st.size = ret; + sptr = &st; + } + + return OCTET_STRING_encode_xer_ascii(td, sptr, ilevel, flags, + cb, app_key); +} + int UTCTime_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/UTCTime.h b/skeletons/UTCTime.h index d00dafb5..b026dedd 100644 --- a/skeletons/UTCTime.h +++ b/skeletons/UTCTime.h @@ -12,8 +12,9 @@ typedef OCTET_STRING_t UTCTime_t; /* Implemented using OCTET STRING */ extern asn1_TYPE_descriptor_t asn1_DEF_UTCTime; -asn_constr_check_f UTCTime_constraint; asn_struct_print_f UTCTime_print; +asn_constr_check_f UTCTime_constraint; +xer_type_encoder_f UTCTime_encode_xer; /*********************** * Some handy helpers. * diff --git a/skeletons/UTF8String.c b/skeletons/UTF8String.c index 40fef39b..7220a674 100644 --- a/skeletons/UTF8String.c +++ b/skeletons/UTF8String.c @@ -2,6 +2,7 @@ * 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 <UTF8String.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_UTF8String_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_UTF8String = { "UTF8String", + OCTET_STRING_free, + UTF8String_print, UTF8String_constraint, /* Check for invalid codes, etc. */ OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - UTF8String_print, - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii, /* Already in UTF-8 format */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_UTF8String_tags, sizeof(asn1_DEF_UTF8String_tags) diff --git a/skeletons/UTF8String.h b/skeletons/UTF8String.h index f18bf703..543d3196 100644 --- a/skeletons/UTF8String.h +++ b/skeletons/UTF8String.h @@ -12,8 +12,8 @@ typedef OCTET_STRING_t UTF8String_t; /* Implemented in terms of OCTET STRING */ extern asn1_TYPE_descriptor_t asn1_DEF_UTF8String; -asn_constr_check_f UTF8String_constraint; asn_struct_print_f UTF8String_print; +asn_constr_check_f UTF8String_constraint; /* Returns length of UTF-8 string in characters or -1 if error. */ ssize_t UTF8String_length(const UTF8String_t *st, const char *opt_type_name, diff --git a/skeletons/UniversalString.c b/skeletons/UniversalString.c index 14988966..d56cd925 100644 --- a/skeletons/UniversalString.c +++ b/skeletons/UniversalString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <UniversalString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_UniversalString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_UniversalString = { "UniversalString", + OCTET_STRING_free, + UniversalString_print, /* Convert into UTF8 and print */ asn_generic_no_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - UniversalString_print, /* Convert into UTF8 and print */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + UniversalString_encode_xer, /* Conver into UTF8 */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_UniversalString_tags, sizeof(asn1_DEF_UniversalString_tags) @@ -31,29 +34,25 @@ asn1_TYPE_descriptor_t asn1_DEF_UniversalString = { }; -int -UniversalString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, - asn_app_consume_bytes_f *cb, void *app_key) { - const UniversalString_t *st = (const UniversalString_t *)sptr; - uint32_t *wchar; - uint32_t *wend; +static ssize_t +UniversalString__dump(const UniversalString_t *st, + asn_app_consume_bytes_f *cb, void *app_key) { char scratch[128]; /* Scratchpad buffer */ - char *p; - - (void)td; /* Unused argument */ - (void)ilevel; /* Unused argument */ + char *p = scratch; + ssize_t wrote = 0; + uint8_t *ch; + uint8_t *end; - if(!st || !st->buf) return cb("<absent>", 8, app_key); - - wchar = (uint32_t *)st->buf; - wend = (uint32_t *)(st->buf + st->size); - for(p = scratch; wchar < wend; wchar++) { - uint32_t wc = (((uint8_t *)wchar)[0] << 24) - | (((uint8_t *)wchar)[1] << 16) - | (((uint8_t *)wchar)[2] << 8) - | ((uint8_t *)wchar)[3]; /* 4 bytes */ + ch = st->buf; + end = (st->buf + st->size); + for(end -= 3; ch < end; ch += 4) { + uint32_t wc = (ch[0] << 24) + | (ch[1] << 16) + | (ch[2] << 8) + | ch[3]; /* 4 bytes */ if(sizeof(scratch) - (p - scratch) < 6) { - if(cb(scratch, p - scratch, app_key)) + wrote += p - scratch; + if(cb(scratch, p - scratch, app_key) < 0) return -1; p = scratch; } @@ -87,5 +86,45 @@ UniversalString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, } } - return cb(scratch, p - scratch, app_key); + wrote += p - scratch; + if(cb(scratch, p - scratch, app_key) < 0) + return -1; + + return wrote; } + +asn_enc_rval_t +UniversalString_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + const UniversalString_t *st = (const UniversalString_t *)sptr; + asn_enc_rval_t er; + + (void)ilevel; + (void)flags; + + if(!st || !st->buf) + _ASN_ENCODE_FAILED; + + er.encoded = UniversalString__dump(st, cb, app_key); + if(er.encoded < 0) _ASN_ENCODE_FAILED; + + return er; +} + +int +UniversalString_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, + asn_app_consume_bytes_f *cb, void *app_key) { + const UniversalString_t *st = (const UniversalString_t *)sptr; + + (void)td; /* Unused argument */ + (void)ilevel; /* Unused argument */ + + if(!st || !st->buf) return cb("<absent>", 8, app_key); + + if(UniversalString__dump(st, cb, app_key) < 0) + return -1; + + return 0; +} + diff --git a/skeletons/UniversalString.h b/skeletons/UniversalString.h index cafbc80c..88875236 100644 --- a/skeletons/UniversalString.h +++ b/skeletons/UniversalString.h @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. + * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ #ifndef _UniversalString_H_ @@ -13,5 +13,6 @@ typedef OCTET_STRING_t UniversalString_t; /* Implemented in terms of OCTET STRIN extern asn1_TYPE_descriptor_t asn1_DEF_UniversalString; asn_struct_print_f UniversalString_print; /* Human-readable output */ +xer_type_encoder_f UniversalString_encode_xer; #endif /* _UniversalString_H_ */ diff --git a/skeletons/VideotexString.c b/skeletons/VideotexString.c index 6d2eaeb6..f313ecb6 100644 --- a/skeletons/VideotexString.c +++ b/skeletons/VideotexString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <VideotexString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_VideotexString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_VideotexString = { "VideotexString", + OCTET_STRING_free, + OCTET_STRING_print, /* non-ascii string */ asn_generic_unknown_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print, /* non-ascii string */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer, /* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_VideotexString_tags, sizeof(asn1_DEF_VideotexString_tags) diff --git a/skeletons/VisibleString.c b/skeletons/VisibleString.c index 9ddb0f1c..dbd0e92e 100644 --- a/skeletons/VisibleString.c +++ b/skeletons/VisibleString.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ +#include <asn_internal.h> #include <VisibleString.h> /* @@ -13,11 +14,13 @@ static ber_tlv_tag_t asn1_DEF_VisibleString_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_VisibleString = { "VisibleString", + OCTET_STRING_free, + OCTET_STRING_print_ascii, /* ASCII subset */ VisibleString_constraint, OCTET_STRING_decode_ber, /* Implemented in terms of OCTET STRING */ OCTET_STRING_encode_der, /* Implemented in terms of OCTET STRING */ - OCTET_STRING_print_ascii, /* ASCII subset */ - OCTET_STRING_free, + 0, /* Not implemented yet */ + OCTET_STRING_encode_xer_ascii,/* Implemented in terms of OCTET STRING */ 0, /* Use generic outmost tag fetcher */ asn1_DEF_VisibleString_tags, sizeof(asn1_DEF_VisibleString_tags) diff --git a/skeletons/asn_SEQUENCE_OF.c b/skeletons/asn_SEQUENCE_OF.c index 7cfd45f3..b2d5f1fa 100644 --- a/skeletons/asn_SEQUENCE_OF.c +++ b/skeletons/asn_SEQUENCE_OF.c @@ -2,6 +2,7 @@ * 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_types.h> /* for MALLOC/REALLOC/FREEMEM */ #include <asn_SEQUENCE_OF.h> diff --git a/skeletons/asn_SET_OF.c b/skeletons/asn_SET_OF.c index c6afc30f..7aeafddb 100644 --- a/skeletons/asn_SET_OF.c +++ b/skeletons/asn_SET_OF.c @@ -2,6 +2,7 @@ * 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_types.h> /* for MALLOC/REALLOC/FREEMEM */ #include <asn_SET_OF.h> #include <errno.h> diff --git a/skeletons/asn_internal.h b/skeletons/asn_internal.h new file mode 100644 index 00000000..6a44cab5 --- /dev/null +++ b/skeletons/asn_internal.h @@ -0,0 +1,72 @@ +/*- + * Copyright (c) 2003, 2004 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_ + +#define ASN1C_ENVIRONMENT_VERSION 96 /* Compile-time version */ +int get_asn1c_environment_version(void); /* Run-time version */ + +#include <asn_types.h> +#include <constr_TYPE.h> + +#define CALLOC(nmemb, size) calloc(nmemb, size) +#define MALLOC(size) malloc(size) +#define REALLOC(oldptr, size) realloc(oldptr, size) +#define FREEMEM(ptr) free(ptr) + +/* + * 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__ +#define ASN_DEBUG(fmt, args...) do { \ + fprintf(stderr, fmt, ##args); \ + fprintf(stderr, "\n"); \ + } while(0) +#else /* !__GNUC__ */ +extern void ASN_DEBUG_f(const char *fmt, ...); +#define ASN_DEBUG ASN_DEBUG_f +#endif /* __GNUC__ */ +#else /* EMIT_ASN_DEBUG != 1 */ +#ifdef __GNUC__ +#define ASN_DEBUG(fmt, args...) ((void)0) /* Emit a no-op operator */ +#else /* __GNUC__ */ +static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }; +#endif /* __GNUC__ */ +#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) == -1) +#define _ASN_E_CALLBACK(foo) do { \ + if(foo) _ASN_ENCODE_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); \ + for(__i = 0; __i < __level; __i++) \ + _ASN_CALLBACK(" ", 4); \ + er.encoded += __nl + 4 * __level; \ +} while(0) + +#endif /* _ASN_INTERNAL_H_ */ diff --git a/skeletons/asn_types.h b/skeletons/asn_types.h index a5620b55..80ab061e 100644 --- a/skeletons/asn_types.h +++ b/skeletons/asn_types.h @@ -43,11 +43,6 @@ #define offsetof(s, m) ((ptrdiff_t)&(((s *)0)->m) - (ptrdiff_t)((s *)0)) #endif /* offsetof */ -#define CALLOC(nmemb, size) calloc(nmemb, size) -#define MALLOC(size) malloc(size) -#define REALLOC(oldptr, size) realloc(oldptr, size) -#define FREEMEM(ptr) free(ptr) - #ifndef MIN /* Suitable for comparing primitive types (integers) */ #if defined(__GNUC__) #define MIN(a,b) ({ __typeof a _a = a; __typeof b _b = b; \ @@ -58,31 +53,6 @@ #endif /* MIN */ /* - * 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__ -#define ASN_DEBUG(fmt, args...) do { \ - fprintf(stderr, fmt, ##args); \ - fprintf(stderr, "\n"); \ - } while(0) -#else /* !__GNUC__ */ -extern void ASN_DEBUG_f(const char *fmt, ...); -#define ASN_DEBUG ASN_DEBUG_f -#endif /* __GNUC__ */ -#else /* EMIT_ASN_DEBUG != 1 */ -#ifdef __GNUC__ -#define ASN_DEBUG(fmt, args...) ((void)0) /* Emit a no-op operator */ -#else /* __GNUC__ */ -static void ASN_DEBUG(const char *fmt, ...) { (void)fmt; }; -#endif /* __GNUC__ */ -#endif /* EMIT_ASN_DEBUG */ -#endif /* ASN_DEBUG */ - - -/* * Generic type of an application-defined callback to return various * types of data to the application. * EXPECTED RETURN VALUES: diff --git a/skeletons/ber_decoder.c b/skeletons/ber_decoder.c index 24a47ac9..cd407283 100644 --- a/skeletons/ber_decoder.c +++ b/skeletons/ber_decoder.c @@ -2,6 +2,7 @@ * Copyright (c) 2003 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 <assert.h> diff --git a/skeletons/ber_tlv_length.c b/skeletons/ber_tlv_length.c index 508bc39f..7daaaef6 100644 --- a/skeletons/ber_tlv_length.c +++ b/skeletons/ber_tlv_length.c @@ -2,6 +2,7 @@ * 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 <ber_tlv_length.h> #include <ber_tlv_tag.h> diff --git a/skeletons/ber_tlv_tag.c b/skeletons/ber_tlv_tag.c index c0a0d6a6..d66b7883 100644 --- a/skeletons/ber_tlv_tag.c +++ b/skeletons/ber_tlv_tag.c @@ -2,6 +2,7 @@ * 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 <ber_tlv_tag.h> #include <errno.h> diff --git a/skeletons/constr_CHOICE.c b/skeletons/constr_CHOICE.c index b7d38fba..ac2bbd68 100644 --- a/skeletons/constr_CHOICE.c +++ b/skeletons/constr_CHOICE.c @@ -2,6 +2,7 @@ * 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_CHOICE.h> #include <assert.h> @@ -348,14 +349,14 @@ CHOICE_decode_ber(asn1_TYPE_descriptor_t *td, RETURN(RC_OK); } -der_enc_rval_t +asn_enc_rval_t CHOICE_encode_der(asn1_TYPE_descriptor_t *td, void *struct_ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { asn1_CHOICE_specifics_t *specs = (asn1_CHOICE_specifics_t *)td->specifics; asn1_TYPE_member_t *elm; /* CHOICE element */ - der_enc_rval_t erval; + asn_enc_rval_t erval; void *memb_ptr; size_t computed_size = 0; int present; @@ -536,6 +537,57 @@ CHOICE_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, } } +asn_enc_rval_t +CHOICE_encode_xer(asn1_TYPE_descriptor_t *td, void *sptr, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { + asn1_CHOICE_specifics_t *specs=(asn1_CHOICE_specifics_t *)td->specifics; + asn_enc_rval_t er; + int present; + + if(!sptr) + _ASN_ENCODE_FAILED; + + /* + * Figure out which CHOICE element is encoded. + */ + present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size); + + if(present <= 0 || present > td->elements_count) { + _ASN_ENCODE_FAILED; + } else { + asn_enc_rval_t tmper; + asn1_TYPE_member_t *elm = &td->elements[present-1]; + void *memb_ptr; + const char *mname = elm->name; + unsigned int mlen = strlen(mname); + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) _ASN_ENCODE_FAILED; + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + er.encoded = 0; + + if(!(flags & XER_F_CANONICAL)) _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; + + _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1); + + er.encoded += 5 + (2 * mlen) + tmper.encoded; + } + + if(!(flags & XER_F_CANONICAL)) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + return er; +} + int CHOICE_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { @@ -550,7 +602,7 @@ CHOICE_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, present = _fetch_present_idx(sptr, specs->pres_offset,specs->pres_size); /* - * Free that element. + * Print that element. */ if(present > 0 && present <= td->elements_count) { asn1_TYPE_member_t *elm = &td->elements[present-1]; diff --git a/skeletons/constr_CHOICE.h b/skeletons/constr_CHOICE.h index 327bae2e..35b95110 100644 --- a/skeletons/constr_CHOICE.h +++ b/skeletons/constr_CHOICE.h @@ -31,11 +31,12 @@ typedef struct asn1_CHOICE_specifics_s { /* * 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_encoder_f CHOICE_encode_xer; asn_outmost_tag_f CHOICE_outmost_tag; -asn_struct_print_f CHOICE_print; -asn_struct_free_f CHOICE_free; #endif /* _CONSTR_CHOICE_H_ */ diff --git a/skeletons/constr_SEQUENCE.c b/skeletons/constr_SEQUENCE.c index 36412a65..9057ac03 100644 --- a/skeletons/constr_SEQUENCE.c +++ b/skeletons/constr_SEQUENCE.c @@ -2,6 +2,7 @@ * 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_SEQUENCE.h> #include <assert.h> @@ -490,12 +491,12 @@ SEQUENCE_decode_ber(asn1_TYPE_descriptor_t *td, /* * The DER encoder of the SEQUENCE type. */ -der_enc_rval_t +asn_enc_rval_t SEQUENCE_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { size_t computed_size = 0; - der_enc_rval_t erval; + asn_enc_rval_t erval; ssize_t ret; int edx; @@ -544,7 +545,7 @@ SEQUENCE_encode_der(asn1_TYPE_descriptor_t *td, */ for(edx = 0; edx < td->elements_count; edx++) { asn1_TYPE_member_t *elm = &td->elements[edx]; - der_enc_rval_t tmperval; + asn_enc_rval_t tmperval; void *memb_ptr; if(elm->flags & ATF_POINTER) { @@ -575,6 +576,50 @@ SEQUENCE_encode_der(asn1_TYPE_descriptor_t *td, return erval; } +asn_enc_rval_t +SEQUENCE_encode_xer(asn1_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; + int xcan = (flags & XER_F_CANONICAL); + int edx; + + if(!sptr) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + for(edx = 0; edx < td->elements_count; edx++) { + asn_enc_rval_t tmper; + asn1_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; + const char *mname = elm->name; + unsigned int mlen = strlen(mname); + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) continue; /* OPTIONAL element? */ + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + + /* Print the member itself */ + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1); + er.encoded += 5 + (2 * mlen) + tmper.encoded; + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + return er; +} + int SEQUENCE_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/constr_SEQUENCE.h b/skeletons/constr_SEQUENCE.h index 1e282c2b..156db8c7 100644 --- a/skeletons/constr_SEQUENCE.h +++ b/skeletons/constr_SEQUENCE.h @@ -31,10 +31,11 @@ typedef struct asn1_SEQUENCE_specifics_s { /* * 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; -asn_struct_print_f SEQUENCE_print; -asn_struct_free_f SEQUENCE_free; +xer_type_encoder_f SEQUENCE_encode_xer; #endif /* _CONSTR_SEQUENCE_H_ */ diff --git a/skeletons/constr_SEQUENCE_OF.c b/skeletons/constr_SEQUENCE_OF.c index 0a58f09a..7330f659 100644 --- a/skeletons/constr_SEQUENCE_OF.c +++ b/skeletons/constr_SEQUENCE_OF.c @@ -2,13 +2,14 @@ * 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_SEQUENCE_OF.h> #include <asn_SEQUENCE_OF.h> /* * The DER encoder of the SEQUENCE OF type. */ -der_enc_rval_t +asn_enc_rval_t SEQUENCE_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -16,7 +17,7 @@ SEQUENCE_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, A_SEQUENCE_OF(void) *list; size_t computed_size = 0; ssize_t encoding_size = 0; - der_enc_rval_t erval; + asn_enc_rval_t erval; int edx; ASN_DEBUG("Estimating size of SEQUENCE OF %s", td->name); @@ -82,3 +83,50 @@ SEQUENCE_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, return erval; } +asn_enc_rval_t +SEQUENCE_OF_encode_xer(asn1_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; + asn1_SET_OF_specifics_t *specs = (asn1_SET_OF_specifics_t *)td->specifics; + asn1_TYPE_member_t *element = td->elements; + A_SEQUENCE_OF(void) *list; + const char *mname = specs->as_XMLValueList + ? 0 : ((*element->name) ? element->name : element->type->name); + unsigned int mlen = mname ? strlen(mname) : 0; + int xcan = (flags & XER_F_CANONICAL); + int i; + + if(!sptr) _ASN_ENCODE_FAILED; + + er.encoded = 0; + + (void *)list = sptr; + 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 = element->type->xer_encoder(element->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + 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); + + return er; +} + diff --git a/skeletons/constr_SEQUENCE_OF.h b/skeletons/constr_SEQUENCE_OF.h index d2560c6a..ee117508 100644 --- a/skeletons/constr_SEQUENCE_OF.h +++ b/skeletons/constr_SEQUENCE_OF.h @@ -12,10 +12,11 @@ * A set specialized functions dealing with the SEQUENCE OF type. * 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 der_type_encoder_f SEQUENCE_OF_encode_der; -#define SEQUENCE_OF_print SET_OF_print -#define SEQUENCE_OF_free SET_OF_free +xer_type_encoder_f SEQUENCE_OF_encode_xer; #endif /* _CONSTR_SET_OF_H_ */ diff --git a/skeletons/constr_SET.c b/skeletons/constr_SET.c index 7a313340..4c0c3b77 100644 --- a/skeletons/constr_SET.c +++ b/skeletons/constr_SET.c @@ -2,6 +2,7 @@ * 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_SET.h> #include <assert.h> /* for assert() */ @@ -430,13 +431,13 @@ SET_decode_ber(asn1_TYPE_descriptor_t *td, /* * The DER encoder of the SET type. */ -der_enc_rval_t +asn_enc_rval_t SET_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { asn1_SET_specifics_t *specs = (asn1_SET_specifics_t *)td->specifics; size_t computed_size = 0; - der_enc_rval_t my_erval; + asn_enc_rval_t my_erval; int t2m_build_own = (specs->tag2el_count != td->elements_count); asn1_TYPE_tag2member_t *t2m; int t2m_count; @@ -469,7 +470,7 @@ SET_encode_der(asn1_TYPE_descriptor_t *td, */ for(edx = 0; edx < td->elements_count; edx++) { asn1_TYPE_member_t *elm = &td->elements[edx]; - der_enc_rval_t erval; + asn_enc_rval_t erval; void *memb_ptr; /* @@ -545,7 +546,7 @@ SET_encode_der(asn1_TYPE_descriptor_t *td, */ for(edx = 0; edx < td->elements_count; edx++) { asn1_TYPE_member_t *elm; - der_enc_rval_t erval; + asn_enc_rval_t erval; void *memb_ptr; /* Encode according to the tag order */ @@ -577,6 +578,52 @@ SET_encode_der(asn1_TYPE_descriptor_t *td, return my_erval; } +asn_enc_rval_t +SET_encode_xer(asn1_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; + int xcan = (flags & XER_F_CANONICAL); + int edx; + + if(!sptr) + _ASN_ENCODE_FAILED; + + er.encoded = 0; + + for(edx = 0; edx < td->elements_count; edx++) { + asn_enc_rval_t tmper; + asn1_TYPE_member_t *elm = &td->elements[edx]; + void *memb_ptr; + const char *mname = elm->name; + unsigned int mlen = strlen(elm->name); + + if(elm->flags & ATF_POINTER) { + memb_ptr = *(void **)((char *)sptr + elm->memb_offset); + if(!memb_ptr) continue; /* OPTIONAL element? */ + } else { + memb_ptr = (void *)((char *)sptr + elm->memb_offset); + } + + if(!xcan) + _i_ASN_TEXT_INDENT(1, ilevel); + _ASN_CALLBACK3("<", 1, mname, mlen, ">", 1); + + /* Print the member itself */ + tmper = elm->type->xer_encoder(elm->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + _ASN_CALLBACK3("</", 2, mname, mlen, ">", 1); + + er.encoded += 5 + (2 * mlen) + tmper.encoded; + } + + if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1); + + return er; +} + int SET_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/constr_SET.h b/skeletons/constr_SET.h index eab2c307..eaf7df0a 100644 --- a/skeletons/constr_SET.h +++ b/skeletons/constr_SET.h @@ -32,11 +32,12 @@ typedef struct asn1_SET_specifics_s { /* * A set specialized functions dealing with the SET type. */ +asn_struct_free_f SET_free; +asn_struct_print_f SET_print; asn_constr_check_f SET_constraint; ber_type_decoder_f SET_decode_ber; der_type_encoder_f SET_encode_der; -asn_struct_print_f SET_print; -asn_struct_free_f SET_free; +xer_type_encoder_f SET_encode_xer; /*********************** * Some handy helpers. * diff --git a/skeletons/constr_SET_OF.c b/skeletons/constr_SET_OF.c index d8dadf50..0a8ee281 100644 --- a/skeletons/constr_SET_OF.c +++ b/skeletons/constr_SET_OF.c @@ -2,6 +2,7 @@ * 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_SET_OF.h> #include <asn_SET_OF.h> @@ -304,7 +305,7 @@ static int _el_buf_cmp(const void *ap, const void *bp) { /* * The DER encoder of the SET OF type. */ -der_enc_rval_t +asn_enc_rval_t SET_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -316,7 +317,7 @@ SET_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, ssize_t encoding_size = 0; struct _el_buffer *encoded_els; size_t max_encoded_len = 1; - der_enc_rval_t erval; + asn_enc_rval_t erval; int ret; int edx; @@ -444,6 +445,53 @@ SET_OF_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, return erval; } +asn_enc_rval_t +SET_OF_encode_xer(asn1_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; + asn1_SET_OF_specifics_t *specs=(asn1_SET_OF_specifics_t *)td->specifics; + asn1_TYPE_member_t *element = td->elements; + A_SET_OF(void) *list; + const char *mname = specs->as_XMLValueList + ? 0 : ((*element->name) ? element->name : element->type->name); + size_t mlen = mname ? strlen(mname) : 0; + int xcan = (flags & XER_F_CANONICAL); + int i; + + if(!sptr) _ASN_ENCODE_FAILED; + + er.encoded = 0; + + (void *)list = sptr; + 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 = element->type->xer_encoder(element->type, memb_ptr, + ilevel + 1, flags, cb, app_key); + if(tmper.encoded == -1) return tmper; + + 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); + + return er; +} + int SET_OF_print(asn1_TYPE_descriptor_t *td, const void *sptr, int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { diff --git a/skeletons/constr_SET_OF.h b/skeletons/constr_SET_OF.h index 0dd6040b..1a1384da 100644 --- a/skeletons/constr_SET_OF.h +++ b/skeletons/constr_SET_OF.h @@ -13,15 +13,19 @@ typedef struct asn1_SET_OF_specifics_s { */ int struct_size; /* Size of the target structure. */ int ctx_offset; /* Offset of the ber_dec_ctx_t member */ + + /* XER-specific stuff */ + int as_XMLValueList; /* The member type must be encoded like this */ } asn1_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; -asn_struct_print_f SET_OF_print; -asn_struct_free_f SET_OF_free; +xer_type_encoder_f SET_OF_encode_xer; #endif /* _CONSTR_SET_OF_H_ */ diff --git a/skeletons/constr_TYPE.c b/skeletons/constr_TYPE.c index 68cc50fa..5085e4aa 100644 --- a/skeletons/constr_TYPE.c +++ b/skeletons/constr_TYPE.c @@ -2,9 +2,15 @@ * 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; /* diff --git a/skeletons/constr_TYPE.h b/skeletons/constr_TYPE.h index 15a67261..28e8e2cd 100644 --- a/skeletons/constr_TYPE.h +++ b/skeletons/constr_TYPE.h @@ -2,19 +2,53 @@ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved. * Redistribution and modifications are permitted subject to BSD license. */ -#ifndef _CONSTR_TYPE_H_ -#define _CONSTR_TYPE_H_ +/* + * 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 <asn_types.h> /* System-dependent types */ + +struct asn1_TYPE_descriptor_s; /* Forward declaration */ +struct asn1_TYPE_member_s; /* Forward declaration */ + +/* + * 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 asn1_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 __er = { -1, td, sptr }; \ + return __er; \ +} while(0) + #include <ber_tlv_length.h> #include <ber_tlv_tag.h> #include <ber_decoder.h> #include <der_encoder.h> +#include <xer_encoder.h> #include <constraints.h> -struct asn1_TYPE_descriptor_s; /* Forward declaration */ -struct asn1_TYPE_member_s; /* Forward declaration */ - /* * Free the structure according to its specification. * If (free_contents_only) is set, the wrapper structure itself (struct_ptr) @@ -58,11 +92,13 @@ typedef struct asn1_TYPE_descriptor_s { * 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; /* Free-form BER decoder */ der_type_encoder_f *der_encoder; /* Canonical DER encoder */ - asn_struct_print_f *print_struct; /* Human readable output */ - asn_struct_free_f *free_struct; /* Free the structure */ + int (*xer_decoder);/* PLACEHOLDER */ /* Free-form XER decoder */ + xer_type_encoder_f *xer_encoder; /* [Canonical] XER encoder */ /* * Functions used internally. Should not be used by applications. @@ -129,6 +165,7 @@ typedef struct asn1_TYPE_tag2member_s { * 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 */ asn1_TYPE_descriptor_t *td, /* ASN.1 type descriptor */ diff --git a/skeletons/constraints.c b/skeletons/constraints.c index 862d8f1e..d95e3cbd 100644 --- a/skeletons/constraints.c +++ b/skeletons/constraints.c @@ -1,3 +1,4 @@ +#include <asn_internal.h> #include <constraints.h> #include <constr_TYPE.h> diff --git a/skeletons/der_encoder.c b/skeletons/der_encoder.c index be714925..4f1936f8 100644 --- a/skeletons/der_encoder.c +++ b/skeletons/der_encoder.c @@ -2,6 +2,7 @@ * 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 <assert.h> #include <errno.h> @@ -12,7 +13,7 @@ static ssize_t der_write_TL(ber_tlv_tag_t tag, ber_tlv_len_t len, /* * The DER encoder of any type. */ -der_enc_rval_t +asn_enc_rval_t der_encode(asn1_TYPE_descriptor_t *type_descriptor, void *struct_ptr, asn_app_consume_bytes_f *consume_bytes, void *app_key) { diff --git a/skeletons/der_encoder.h b/skeletons/der_encoder.h index 052d9f4c..fe64bccf 100644 --- a/skeletons/der_encoder.h +++ b/skeletons/der_encoder.h @@ -10,32 +10,9 @@ struct asn1_TYPE_descriptor_s; /* Forward declaration */ /* - * Type of the return value of the der_encode function. - */ -typedef struct der_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 asn1_TYPE_descriptor_s *failed_type; - - /* Pointer to the structure of that type */ - void *structure_ptr; -} der_enc_rval_t; - - -/* * The DER encoder of any type. May be invoked by the application. */ -der_enc_rval_t der_encode(struct asn1_TYPE_descriptor_s *type_descriptor, +asn_enc_rval_t der_encode(struct asn1_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 */ @@ -44,7 +21,7 @@ der_enc_rval_t der_encode(struct asn1_TYPE_descriptor_s *type_descriptor, /* * Type of the generic DER encoder. */ -typedef der_enc_rval_t (der_type_encoder_f)( +typedef asn_enc_rval_t (der_type_encoder_f)( struct asn1_TYPE_descriptor_s *type_descriptor, void *struct_ptr, /* Structure to be encoded */ int tag_mode, /* {-1,0,1}: IMPLICIT, no, EXPLICIT */ diff --git a/skeletons/file-dependencies b/skeletons/file-dependencies index 2fdb5818..25d10a07 100644 --- a/skeletons/file-dependencies +++ b/skeletons/file-dependencies @@ -44,6 +44,7 @@ constr_SET_OF.h constr_SET_OF.c asn_SET_OF.h COMMON-FILES: # This is a special section asn_types.h +asn_internal.h OCTET_STRING.h OCTET_STRING.c # This one is used too widely ber_decoder.h ber_decoder.c ber_tlv_length.h ber_tlv_length.c @@ -51,3 +52,4 @@ ber_tlv_tag.h ber_tlv_tag.c constr_TYPE.h constr_TYPE.c constraints.h constraints.c der_encoder.h der_encoder.c +xer_encoder.h xer_encoder.c diff --git a/skeletons/tests/check-GeneralizedTime.c b/skeletons/tests/check-GeneralizedTime.c index 59474e42..40008f0b 100644 --- a/skeletons/tests/check-GeneralizedTime.c +++ b/skeletons/tests/check-GeneralizedTime.c @@ -97,9 +97,9 @@ main(int ac, char **av) { * Dummy function. */ -der_enc_rval_t +asn_enc_rval_t OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; (void)td; (void)ptr; @@ -110,3 +110,17 @@ OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber return erval; } + +asn_enc_rval_t +OCTET_STRING_encode_xer_ascii(asn1_TYPE_descriptor_t *td, void *ptr, int ilevel, enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t erval; + + (void)td; + (void)ptr; + (void)ilevel; + (void)flags; + (void)cb; + (void)app_key; + + return erval; +} diff --git a/skeletons/tests/check-UTCTime.c b/skeletons/tests/check-UTCTime.c index 1bd49b3c..b8ad57b3 100644 --- a/skeletons/tests/check-UTCTime.c +++ b/skeletons/tests/check-UTCTime.c @@ -64,9 +64,9 @@ main(int ac, char **av) { * Dummy function. */ -der_enc_rval_t +asn_enc_rval_t OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { - der_enc_rval_t erval; + asn_enc_rval_t erval; (void)td; (void)ptr; @@ -77,3 +77,17 @@ OCTET_STRING_encode_der(asn1_TYPE_descriptor_t *td, void *ptr, int tag_mode, ber return erval; } + +asn_enc_rval_t +OCTET_STRING_encode_xer_ascii(asn1_TYPE_descriptor_t *td, void *ptr, int ilevel, enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb, void *app_key) { + asn_enc_rval_t erval; + + (void)td; + (void)ptr; + (void)ilevel; + (void)flags; + (void)cb; + (void)app_key; + + return erval; +} diff --git a/skeletons/tests/check-length.c b/skeletons/tests/check-length.c index 7746bcf3..6176ddd9 100644 --- a/skeletons/tests/check-length.c +++ b/skeletons/tests/check-length.c @@ -36,7 +36,7 @@ static void check(int size) { OCTET_STRING_t *os; OCTET_STRING_t *nos = 0; - der_enc_rval_t erval; + asn_enc_rval_t erval; ber_dec_rval_t rval; int i; diff --git a/skeletons/xer_encoder.c b/skeletons/xer_encoder.c new file mode 100644 index 00000000..51f8d1d5 --- /dev/null +++ b/skeletons/xer_encoder.c @@ -0,0 +1,71 @@ +/*- + * 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 <stdio.h> +#include <assert.h> +#include <errno.h> + +/* + * The XER encoder of any type. May be invoked by the application. + */ +asn_enc_rval_t +xer_encode(asn1_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) { + er.encoded = -1; + er.failed_type = td; + er.structure_ptr = sptr; + return er; + } + + mname = td->name; + 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("</", xcan, mname, mlen, ">\n",xcan); + + er.encoded = 2 + (2 * xcan) + (2 * mlen) + tmper.encoded; + + return er; +} + +static int _print2fp(const void *buffer, size_t size, void *app_key); + +int +xer_fprint(FILE *stream, asn1_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, _print2fp, stream); + if(er.encoded == -1) + return -1; + + return fflush(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; +} + diff --git a/skeletons/xer_encoder.h b/skeletons/xer_encoder.h new file mode 100644 index 00000000..43c192d3 --- /dev/null +++ b/skeletons/xer_encoder.h @@ -0,0 +1,51 @@ +/*- + * 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 <constr_TYPE.h> + +struct asn1_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, unreadable) */ +}; + +/* + * The XER encoder of any type. May be invoked by the application. + */ +asn_enc_rval_t xer_encode(struct asn1_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 asn1_TYPE_descriptor_s *td, void *sptr); + +/* + * Type of the generic XER encoder. + */ +typedef asn_enc_rval_t (xer_type_encoder_f)( + struct asn1_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 */ + ); + +#endif /* _XER_ENCODER_H_ */ diff --git a/tests/19-param-OK.asn1.-P b/tests/19-param-OK.asn1.-P index e980f1c5..fa6aaf31 100644 --- a/tests/19-param-OK.asn1.-P +++ b/tests/19-param-OK.asn1.-P @@ -108,11 +108,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_toBeSigned_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_toBeSigned = { "toBeSigned", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_toBeSigned_tags, sizeof(asn1_DEF_toBeSigned_tags) @@ -167,11 +169,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_Certificate_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Certificate = { "Certificate", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Certificate_tags, sizeof(asn1_DEF_Certificate_tags) @@ -223,14 +227,17 @@ static ber_tlv_tag_t asn1_DEF_Name_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_Name_specs = { sizeof(struct Name), offsetof(struct Name, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; asn1_TYPE_descriptor_t asn1_DEF_Name = { "Name", + SEQUENCE_OF_free, + SEQUENCE_OF_print, SEQUENCE_OF_constraint, SEQUENCE_OF_decode_ber, SEQUENCE_OF_encode_der, - SEQUENCE_OF_print, - SEQUENCE_OF_free, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Name_tags, sizeof(asn1_DEF_Name_tags) @@ -337,14 +344,17 @@ static ber_tlv_tag_t asn1_DEF_RelativeDistinguishedName_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_RelativeDistinguishedName_specs = { sizeof(struct RelativeDistinguishedName), offsetof(struct RelativeDistinguishedName, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; asn1_TYPE_descriptor_t asn1_DEF_RelativeDistinguishedName = { "RelativeDistinguishedName", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_RelativeDistinguishedName_tags, sizeof(asn1_DEF_RelativeDistinguishedName_tags) diff --git a/tests/31-set-of-OK.asn1.-P b/tests/31-set-of-OK.asn1.-P index d1675127..ce284dfc 100644 --- a/tests/31-set-of-OK.asn1.-P +++ b/tests/31-set-of-OK.asn1.-P @@ -36,14 +36,17 @@ static ber_tlv_tag_t asn1_DEF_Forest_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_Forest_specs = { sizeof(struct Forest), offsetof(struct Forest, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; asn1_TYPE_descriptor_t asn1_DEF_Forest = { "Forest", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Forest_tags, sizeof(asn1_DEF_Forest_tags) @@ -113,11 +116,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_Tree_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Tree = { "Tree", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Tree_tags, sizeof(asn1_DEF_Tree_tags) @@ -205,15 +210,18 @@ static ber_tlv_tag_t asn1_DEF_trees_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_trees_specs = { sizeof(struct trees), offsetof(struct trees, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_trees = { "trees", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_trees_tags, sizeof(asn1_DEF_trees_tags) @@ -253,11 +261,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_anything_member_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_anything_member = { "", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_anything_member_tags, sizeof(asn1_DEF_anything_member_tags) @@ -287,15 +297,18 @@ static ber_tlv_tag_t asn1_DEF_anything_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_anything_specs = { sizeof(struct anything), offsetof(struct anything, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_anything = { "anything", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_anything_tags, sizeof(asn1_DEF_anything_tags) @@ -346,11 +359,13 @@ static asn1_SET_specifics_t asn1_DEF_Stuff_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Stuff = { "Stuff", + SET_free, + SET_print, SET_constraint, SET_decode_ber, SET_encode_der, - SET_print, - SET_free, + 0, /* Not implemented yet */ + SET_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Stuff_tags, sizeof(asn1_DEF_Stuff_tags) diff --git a/tests/32-sequence-of-OK.asn1.-P b/tests/32-sequence-of-OK.asn1.-P new file mode 100644 index 00000000..5b3d606c --- /dev/null +++ b/tests/32-sequence-of-OK.asn1.-P @@ -0,0 +1,182 @@ + +/*** <<< INCLUDES [Programming] >>> ***/ + +#include <Fault.h> +#include <asn_SEQUENCE_OF.h> +#include <constr_SEQUENCE_OF.h> + +/*** <<< DEPS [Programming] >>> ***/ + +extern asn1_TYPE_descriptor_t asn1_DEF_Programming; + +/*** <<< TYPE-DECLS [Programming] >>> ***/ + + +typedef struct Programming { + A_SEQUENCE_OF(Fault_t) list; + + /* Context for parsing across buffer boundaries */ + ber_dec_ctx_t _ber_dec_ctx; +} Programming_t; + +/*** <<< STAT-DEFS [Programming] >>> ***/ + +static asn1_TYPE_member_t asn1_MBR_Programming[] = { + { ATF_NOFLAGS, 0, 0, + .tag = (ASN_TAG_CLASS_CONTEXT | (0 << 2)), + .tag_mode = -1, /* IMPLICIT tag at current level */ + .type = (void *)&asn1_DEF_Fault, + .memb_constraints = 0, /* Defer to actual type */ + .name = "" + }, +}; +static ber_tlv_tag_t asn1_DEF_Programming_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn1_SET_OF_specifics_t asn1_DEF_Programming_specs = { + sizeof(struct Programming), + offsetof(struct Programming, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn1_TYPE_descriptor_t asn1_DEF_Programming = { + "Programming", + SEQUENCE_OF_free, + SEQUENCE_OF_print, + SEQUENCE_OF_constraint, + SEQUENCE_OF_decode_ber, + SEQUENCE_OF_encode_der, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, + 0, /* Use generic outmost tag fetcher */ + asn1_DEF_Programming_tags, + sizeof(asn1_DEF_Programming_tags) + /sizeof(asn1_DEF_Programming_tags[0]), /* 1 */ + asn1_DEF_Programming_tags, /* Same as above */ + sizeof(asn1_DEF_Programming_tags) + /sizeof(asn1_DEF_Programming_tags[0]), /* 1 */ + 1, /* Whether CONSTRUCTED */ + asn1_MBR_Programming, + 1, /* Single element */ + &asn1_DEF_Programming_specs /* Additional specs */ +}; + + +/*** <<< INCLUDES [Fault] >>> ***/ + +#include <Error.h> +#include <asn_SET_OF.h> +#include <constr_SET_OF.h> + +/*** <<< DEPS [Fault] >>> ***/ + +extern asn1_TYPE_descriptor_t asn1_DEF_Fault; + +/*** <<< TYPE-DECLS [Fault] >>> ***/ + + +typedef struct Fault { + A_SET_OF(Error_t) list; + + /* Context for parsing across buffer boundaries */ + ber_dec_ctx_t _ber_dec_ctx; +} Fault_t; + +/*** <<< STAT-DEFS [Fault] >>> ***/ + +static asn1_TYPE_member_t asn1_MBR_Fault[] = { + { ATF_NOFLAGS, 0, 0, + .tag = (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), + .tag_mode = 0, + .type = (void *)&asn1_DEF_Error, + .memb_constraints = 0, /* Defer to actual type */ + .name = "" + }, +}; +static ber_tlv_tag_t asn1_DEF_Fault_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (17 << 2)) +}; +static asn1_SET_OF_specifics_t asn1_DEF_Fault_specs = { + sizeof(struct Fault), + offsetof(struct Fault, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ +}; +asn1_TYPE_descriptor_t asn1_DEF_Fault = { + "Fault", + SET_OF_free, + SET_OF_print, + SET_OF_constraint, + SET_OF_decode_ber, + SET_OF_encode_der, + 0, /* Not implemented yet */ + SET_OF_encode_xer, + 0, /* Use generic outmost tag fetcher */ + asn1_DEF_Fault_tags, + sizeof(asn1_DEF_Fault_tags) + /sizeof(asn1_DEF_Fault_tags[0]), /* 1 */ + asn1_DEF_Fault_tags, /* Same as above */ + sizeof(asn1_DEF_Fault_tags) + /sizeof(asn1_DEF_Fault_tags[0]), /* 1 */ + 1, /* Whether CONSTRUCTED */ + asn1_MBR_Fault, + 1, /* Single element */ + &asn1_DEF_Fault_specs /* Additional specs */ +}; + + +/*** <<< INCLUDES [Error] >>> ***/ + +#include <constr_SEQUENCE.h> + +/*** <<< DEPS [Error] >>> ***/ + +extern asn1_TYPE_descriptor_t asn1_DEF_Error; + +/*** <<< TYPE-DECLS [Error] >>> ***/ + + +typedef struct Error { + /* + * This type is extensible, + * possible extensions are below. + */ + + /* Context for parsing across buffer boundaries */ + ber_dec_ctx_t _ber_dec_ctx; +} Error_t; + +/*** <<< STAT-DEFS [Error] >>> ***/ + +static ber_tlv_tag_t asn1_DEF_Error_tags[] = { + (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)) +}; +static asn1_TYPE_tag2member_t asn1_DEF_Error_tag2el[] = { +}; +static asn1_SEQUENCE_specifics_t asn1_DEF_Error_specs = { + sizeof(struct Error), + offsetof(struct Error, _ber_dec_ctx), + asn1_DEF_Error_tag2el, + 0, /* Count of tags in the map */ + -1, /* Start extensions */ + -1 /* Stop extensions */ +}; +asn1_TYPE_descriptor_t asn1_DEF_Error = { + "Error", + SEQUENCE_free, + SEQUENCE_print, + SEQUENCE_constraint, + SEQUENCE_decode_ber, + SEQUENCE_encode_der, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, + 0, /* Use generic outmost tag fetcher */ + asn1_DEF_Error_tags, + sizeof(asn1_DEF_Error_tags) + /sizeof(asn1_DEF_Error_tags[0]), /* 1 */ + asn1_DEF_Error_tags, /* Same as above */ + sizeof(asn1_DEF_Error_tags) + /sizeof(asn1_DEF_Error_tags[0]), /* 1 */ + 1, /* Whether CONSTRUCTED */ + 0, 0, /* No members */ + &asn1_DEF_Error_specs /* Additional specs */ +}; + diff --git a/tests/39-sequence-of-OK.asn1.-P b/tests/39-sequence-of-OK.asn1.-P index 04b9948d..bd13dfd3 100644 --- a/tests/39-sequence-of-OK.asn1.-P +++ b/tests/39-sequence-of-OK.asn1.-P @@ -44,15 +44,18 @@ static ber_tlv_tag_t asn1_DEF_collection_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_collection_specs = { sizeof(struct collection), offsetof(struct collection, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_collection = { "collection", + SEQUENCE_OF_free, + SEQUENCE_OF_print, SEQUENCE_OF_constraint, SEQUENCE_OF_decode_ber, SEQUENCE_OF_encode_der, - SEQUENCE_OF_print, - SEQUENCE_OF_free, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_collection_tags, sizeof(asn1_DEF_collection_tags) @@ -99,11 +102,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_T_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) @@ -174,11 +179,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_T2_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T2 = { "T2", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T2_tags, sizeof(asn1_DEF_T2_tags) diff --git a/tests/42-real-life-OK.asn1.-PR b/tests/42-real-life-OK.asn1.-PR index 72044d3f..ef05fa51 100644 --- a/tests/42-real-life-OK.asn1.-PR +++ b/tests/42-real-life-OK.asn1.-PR @@ -80,15 +80,18 @@ static ber_tlv_tag_t asn1_DEF_varsets_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_varsets_specs = { sizeof(struct varsets), offsetof(struct varsets, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_varsets = { "varsets", + SEQUENCE_OF_free, + SEQUENCE_OF_print, SEQUENCE_OF_constraint, SEQUENCE_OF_decode_ber, SEQUENCE_OF_encode_der, - SEQUENCE_OF_print, - SEQUENCE_OF_free, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_varsets_tags, sizeof(asn1_DEF_varsets_tags) @@ -135,11 +138,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_LogLine_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_LogLine = { "LogLine", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_LogLine_tags, sizeof(asn1_DEF_LogLine_tags) @@ -226,15 +231,18 @@ static ber_tlv_tag_t asn1_DEF_vparts_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_vparts_specs = { sizeof(struct vparts), offsetof(struct vparts, _ber_dec_ctx), + 1, /* XER encoding is XMLValueList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_vparts = { "vparts", + SEQUENCE_OF_free, + SEQUENCE_OF_print, SEQUENCE_OF_constraint, SEQUENCE_OF_decode_ber, SEQUENCE_OF_encode_der, - SEQUENCE_OF_print, - SEQUENCE_OF_free, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_vparts_tags, sizeof(asn1_DEF_vparts_tags) @@ -281,11 +289,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_VariablePartSet_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_VariablePartSet = { "VariablePartSet", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_VariablePartSet_tags, sizeof(asn1_DEF_VariablePartSet_tags) @@ -400,15 +410,18 @@ static ber_tlv_tag_t asn1_DEF_vset_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_vset_specs = { sizeof(struct vset), offsetof(struct vset, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_vset = { "vset", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_vset_tags, sizeof(asn1_DEF_vset_tags) @@ -456,11 +469,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_vrange_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_vrange = { "vrange", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_vrange_tags, sizeof(asn1_DEF_vrange_tags) @@ -505,11 +520,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_VariablePart_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_VariablePart = { "VariablePart", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ @@ -590,15 +607,18 @@ static ber_tlv_tag_t asn1_DEF_email_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_email_specs = { sizeof(struct email), offsetof(struct email, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_email = { "email", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_email_tags, sizeof(asn1_DEF_email_tags) @@ -646,11 +666,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_notify_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_notify = { "notify", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_notify_tags, sizeof(asn1_DEF_notify_tags) @@ -697,11 +719,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_ActionItem_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_ActionItem = { "ActionItem", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_ActionItem_tags, sizeof(asn1_DEF_ActionItem_tags) diff --git a/tests/43-recursion-OK.asn1.-P b/tests/43-recursion-OK.asn1.-P index 1f935240..9c5945d2 100644 --- a/tests/43-recursion-OK.asn1.-P +++ b/tests/43-recursion-OK.asn1.-P @@ -53,15 +53,18 @@ static ber_tlv_tag_t asn1_DEF_t_member1_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_t_member1_specs = { sizeof(struct t_member1), offsetof(struct t_member1, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_t_member1 = { "t-member1", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_t_member1_tags, sizeof(asn1_DEF_t_member1_tags) @@ -90,15 +93,18 @@ static ber_tlv_tag_t asn1_DEF_t_member2_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_t_member2_specs = { sizeof(struct t_member2), offsetof(struct t_member2, _ber_dec_ctx), + 0, /* XER encoding is XMLDelimitedItemList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_t_member2 = { "t-member2", + SEQUENCE_OF_free, + SEQUENCE_OF_print, SEQUENCE_OF_constraint, SEQUENCE_OF_decode_ber, SEQUENCE_OF_encode_der, - SEQUENCE_OF_print, - SEQUENCE_OF_free, + 0, /* Not implemented yet */ + SEQUENCE_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_t_member2_tags, sizeof(asn1_DEF_t_member2_tags) @@ -161,11 +167,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_Test_structure_1_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Test_structure_1 = { "Test-structure-1", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Test_structure_1_tags, sizeof(asn1_DEF_Test_structure_1_tags) @@ -238,15 +246,18 @@ static ber_tlv_tag_t asn1_DEF_or_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_or_specs = { sizeof(struct or), offsetof(struct or, _ber_dec_ctx), + 1, /* XER encoding is XMLValueList */ }; static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_or = { "or", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_or_tags, sizeof(asn1_DEF_or_tags) @@ -307,11 +318,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_Choice_1_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Choice_1 = { "Choice-1", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ diff --git a/tests/44-choice-in-sequence-OK.asn1.-P b/tests/44-choice-in-sequence-OK.asn1.-P index 5ac269d3..4fcddc4b 100644 --- a/tests/44-choice-in-sequence-OK.asn1.-P +++ b/tests/44-choice-in-sequence-OK.asn1.-P @@ -100,11 +100,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_e_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_e = { "e", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ @@ -148,11 +150,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_h_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_h = { "h", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ @@ -213,11 +217,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_b_specs = { static /* Use -fall-defs-global to expose */ asn1_TYPE_descriptor_t asn1_DEF_b = { "b", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ @@ -267,11 +273,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_T_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) diff --git a/tests/46-redefine-OK.asn1.-PR b/tests/46-redefine-OK.asn1.-PR index 9104df85..f89085e1 100644 --- a/tests/46-redefine-OK.asn1.-PR +++ b/tests/46-redefine-OK.asn1.-PR @@ -11,11 +11,12 @@ typedef OCTET_STRING_t PrimitiveType_t; /*** <<< FUNC-DECLS [PrimitiveType] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_PrimitiveType; +asn_struct_free_f PrimitiveType_free; +asn_struct_print_f PrimitiveType_print; asn_constr_check_f PrimitiveType_constraint; ber_type_decoder_f PrimitiveType_decode_ber; der_type_encoder_f PrimitiveType_encode_der; -asn_struct_print_f PrimitiveType_print; -asn_struct_free_f PrimitiveType_free; +xer_type_encoder_f PrimitiveType_encode_xer; /*** <<< CODE [PrimitiveType] >>> ***/ @@ -35,16 +36,32 @@ PrimitiveType_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void PrimitiveType_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_OCTET_STRING.ber_decoder; - td->der_encoder = asn1_DEF_OCTET_STRING.der_encoder; td->free_struct = asn1_DEF_OCTET_STRING.free_struct; td->print_struct = asn1_DEF_OCTET_STRING.print_struct; + td->ber_decoder = asn1_DEF_OCTET_STRING.ber_decoder; + td->der_encoder = asn1_DEF_OCTET_STRING.der_encoder; + td->xer_decoder = asn1_DEF_OCTET_STRING.xer_decoder; + td->xer_encoder = asn1_DEF_OCTET_STRING.xer_encoder; td->last_tag_form = asn1_DEF_OCTET_STRING.last_tag_form; td->elements = asn1_DEF_OCTET_STRING.elements; td->elements_count = asn1_DEF_OCTET_STRING.elements_count; td->specifics = asn1_DEF_OCTET_STRING.specifics; } +void +PrimitiveType_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + PrimitiveType_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +PrimitiveType_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + PrimitiveType_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t PrimitiveType_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -52,7 +69,7 @@ PrimitiveType_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t PrimitiveType_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -60,18 +77,12 @@ PrimitiveType_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -PrimitiveType_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - PrimitiveType_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -PrimitiveType_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +PrimitiveType_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { PrimitiveType_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -82,11 +93,13 @@ static ber_tlv_tag_t asn1_DEF_PrimitiveType_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_PrimitiveType = { "PrimitiveType", + PrimitiveType_free, + PrimitiveType_print, PrimitiveType_constraint, PrimitiveType_decode_ber, PrimitiveType_encode_der, - PrimitiveType_print, - PrimitiveType_free, + 0, /* Not implemented yet */ + PrimitiveType_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_PrimitiveType_tags, sizeof(asn1_DEF_PrimitiveType_tags) @@ -146,11 +159,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_ConstructedType_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_ConstructedType = { "ConstructedType", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_ConstructedType_tags, sizeof(asn1_DEF_ConstructedType_tags) @@ -177,11 +192,12 @@ typedef ConstructedType_t T_t; /*** <<< FUNC-DECLS [T] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T; +asn_struct_free_f T_free; +asn_struct_print_f T_print; asn_constr_check_f T_constraint; ber_type_decoder_f T_decode_ber; der_type_encoder_f T_encode_der; -asn_struct_print_f T_print; -asn_struct_free_f T_free; +xer_type_encoder_f T_encode_xer; /*** <<< CODE [T] >>> ***/ @@ -201,16 +217,32 @@ T_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_ConstructedType.ber_decoder; - td->der_encoder = asn1_DEF_ConstructedType.der_encoder; td->free_struct = asn1_DEF_ConstructedType.free_struct; td->print_struct = asn1_DEF_ConstructedType.print_struct; + td->ber_decoder = asn1_DEF_ConstructedType.ber_decoder; + td->der_encoder = asn1_DEF_ConstructedType.der_encoder; + td->xer_decoder = asn1_DEF_ConstructedType.xer_decoder; + td->xer_encoder = asn1_DEF_ConstructedType.xer_encoder; td->last_tag_form = asn1_DEF_ConstructedType.last_tag_form; td->elements = asn1_DEF_ConstructedType.elements; td->elements_count = asn1_DEF_ConstructedType.elements_count; td->specifics = asn1_DEF_ConstructedType.specifics; } +void +T_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -218,7 +250,7 @@ T_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -226,18 +258,12 @@ T_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -249,11 +275,13 @@ static ber_tlv_tag_t asn1_DEF_T_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + T_free, + T_print, T_constraint, T_decode_ber, T_encode_der, - T_print, - T_free, + 0, /* Not implemented yet */ + T_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) diff --git a/tests/47-set-ext-OK.asn1.-P b/tests/47-set-ext-OK.asn1.-P index 51b77acd..bcc364b0 100644 --- a/tests/47-set-ext-OK.asn1.-P +++ b/tests/47-set-ext-OK.asn1.-P @@ -64,11 +64,13 @@ static asn1_SET_specifics_t asn1_DEF_T1_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T1 = { "T1", + SET_free, + SET_print, SET_constraint, SET_decode_ber, SET_encode_der, - SET_print, - SET_free, + 0, /* Not implemented yet */ + SET_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T1_tags, sizeof(asn1_DEF_T1_tags) @@ -148,11 +150,13 @@ static asn1_SET_specifics_t asn1_DEF_T2_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T2 = { "T2", + SET_free, + SET_print, SET_constraint, SET_decode_ber, SET_encode_der, - SET_print, - SET_free, + 0, /* Not implemented yet */ + SET_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T2_tags, sizeof(asn1_DEF_T2_tags) @@ -223,11 +227,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_T3_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T3 = { "T3", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ @@ -296,11 +302,13 @@ static asn1_CHOICE_specifics_t asn1_DEF_T4_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T4 = { "T4", + CHOICE_free, + CHOICE_print, CHOICE_constraint, CHOICE_decode_ber, CHOICE_encode_der, - CHOICE_print, - CHOICE_free, + 0, /* Not implemented yet */ + CHOICE_encode_xer, CHOICE_outmost_tag, 0, /* No effective tags (pointer) */ 0, /* No effective tags (count) */ diff --git a/tests/50-constraint-OK.asn1.-P b/tests/50-constraint-OK.asn1.-P index 305dc502..a03652fb 100644 --- a/tests/50-constraint-OK.asn1.-P +++ b/tests/50-constraint-OK.asn1.-P @@ -11,11 +11,12 @@ typedef INTEGER_t Int1_t; /*** <<< FUNC-DECLS [Int1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Int1; +asn_struct_free_f Int1_free; +asn_struct_print_f Int1_print; asn_constr_check_f Int1_constraint; ber_type_decoder_f Int1_decode_ber; der_type_encoder_f Int1_encode_der; -asn_struct_print_f Int1_print; -asn_struct_free_f Int1_free; +xer_type_encoder_f Int1_encode_xer; /*** <<< CODE [Int1] >>> ***/ @@ -35,16 +36,32 @@ Int1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Int1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_INTEGER.ber_decoder; - td->der_encoder = asn1_DEF_INTEGER.der_encoder; td->free_struct = asn1_DEF_INTEGER.free_struct; td->print_struct = asn1_DEF_INTEGER.print_struct; + td->ber_decoder = asn1_DEF_INTEGER.ber_decoder; + td->der_encoder = asn1_DEF_INTEGER.der_encoder; + td->xer_decoder = asn1_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn1_DEF_INTEGER.xer_encoder; td->last_tag_form = asn1_DEF_INTEGER.last_tag_form; td->elements = asn1_DEF_INTEGER.elements; td->elements_count = asn1_DEF_INTEGER.elements_count; td->specifics = asn1_DEF_INTEGER.specifics; } +void +Int1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Int1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Int1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Int1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Int1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -52,7 +69,7 @@ Int1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Int1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -60,18 +77,12 @@ Int1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Int1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Int1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Int1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Int1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Int1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -82,11 +93,13 @@ static ber_tlv_tag_t asn1_DEF_Int1_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Int1 = { "Int1", + Int1_free, + Int1_print, Int1_constraint, Int1_decode_ber, Int1_encode_der, - Int1_print, - Int1_free, + 0, /* Not implemented yet */ + Int1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Int1_tags, sizeof(asn1_DEF_Int1_tags) @@ -112,11 +125,12 @@ typedef Int1_t Int2_t; /*** <<< FUNC-DECLS [Int2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Int2; +asn_struct_free_f Int2_free; +asn_struct_print_f Int2_print; asn_constr_check_f Int2_constraint; ber_type_decoder_f Int2_decode_ber; der_type_encoder_f Int2_encode_der; -asn_struct_print_f Int2_print; -asn_struct_free_f Int2_free; +xer_type_encoder_f Int2_encode_xer; /*** <<< CODE [Int2] >>> ***/ @@ -154,16 +168,32 @@ Int2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Int2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Int1.ber_decoder; - td->der_encoder = asn1_DEF_Int1.der_encoder; td->free_struct = asn1_DEF_Int1.free_struct; td->print_struct = asn1_DEF_Int1.print_struct; + td->ber_decoder = asn1_DEF_Int1.ber_decoder; + td->der_encoder = asn1_DEF_Int1.der_encoder; + td->xer_decoder = asn1_DEF_Int1.xer_decoder; + td->xer_encoder = asn1_DEF_Int1.xer_encoder; td->last_tag_form = asn1_DEF_Int1.last_tag_form; td->elements = asn1_DEF_Int1.elements; td->elements_count = asn1_DEF_Int1.elements_count; td->specifics = asn1_DEF_Int1.specifics; } +void +Int2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Int2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Int2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Int2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Int2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -171,7 +201,7 @@ Int2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Int2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -179,18 +209,12 @@ Int2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Int2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Int2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Int2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Int2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Int2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -201,11 +225,13 @@ static ber_tlv_tag_t asn1_DEF_Int2_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Int2 = { "Int2", + Int2_free, + Int2_print, Int2_constraint, Int2_decode_ber, Int2_encode_der, - Int2_print, - Int2_free, + 0, /* Not implemented yet */ + Int2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Int2_tags, sizeof(asn1_DEF_Int2_tags) @@ -231,11 +257,12 @@ typedef Int2_t Int3_t; /*** <<< FUNC-DECLS [Int3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Int3; +asn_struct_free_f Int3_free; +asn_struct_print_f Int3_print; asn_constr_check_f Int3_constraint; ber_type_decoder_f Int3_decode_ber; der_type_encoder_f Int3_encode_der; -asn_struct_print_f Int3_print; -asn_struct_free_f Int3_free; +xer_type_encoder_f Int3_encode_xer; /*** <<< CODE [Int3] >>> ***/ @@ -277,16 +304,32 @@ Int3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Int3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Int2.ber_decoder; - td->der_encoder = asn1_DEF_Int2.der_encoder; td->free_struct = asn1_DEF_Int2.free_struct; td->print_struct = asn1_DEF_Int2.print_struct; + td->ber_decoder = asn1_DEF_Int2.ber_decoder; + td->der_encoder = asn1_DEF_Int2.der_encoder; + td->xer_decoder = asn1_DEF_Int2.xer_decoder; + td->xer_encoder = asn1_DEF_Int2.xer_encoder; td->last_tag_form = asn1_DEF_Int2.last_tag_form; td->elements = asn1_DEF_Int2.elements; td->elements_count = asn1_DEF_Int2.elements_count; td->specifics = asn1_DEF_Int2.specifics; } +void +Int3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Int3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Int3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Int3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Int3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -294,7 +337,7 @@ Int3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Int3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -302,18 +345,12 @@ Int3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Int3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Int3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Int3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Int3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Int3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -324,11 +361,13 @@ static ber_tlv_tag_t asn1_DEF_Int3_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Int3 = { "Int3", + Int3_free, + Int3_print, Int3_constraint, Int3_decode_ber, Int3_encode_der, - Int3_print, - Int3_free, + 0, /* Not implemented yet */ + Int3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Int3_tags, sizeof(asn1_DEF_Int3_tags) @@ -354,11 +393,12 @@ typedef Int3_t Int4_t; /*** <<< FUNC-DECLS [Int4] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Int4; +asn_struct_free_f Int4_free; +asn_struct_print_f Int4_print; asn_constr_check_f Int4_constraint; ber_type_decoder_f Int4_decode_ber; der_type_encoder_f Int4_encode_der; -asn_struct_print_f Int4_print; -asn_struct_free_f Int4_free; +xer_type_encoder_f Int4_encode_xer; /*** <<< CODE [Int4] >>> ***/ @@ -400,16 +440,32 @@ Int4_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Int4_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Int3.ber_decoder; - td->der_encoder = asn1_DEF_Int3.der_encoder; td->free_struct = asn1_DEF_Int3.free_struct; td->print_struct = asn1_DEF_Int3.print_struct; + td->ber_decoder = asn1_DEF_Int3.ber_decoder; + td->der_encoder = asn1_DEF_Int3.der_encoder; + td->xer_decoder = asn1_DEF_Int3.xer_decoder; + td->xer_encoder = asn1_DEF_Int3.xer_encoder; td->last_tag_form = asn1_DEF_Int3.last_tag_form; td->elements = asn1_DEF_Int3.elements; td->elements_count = asn1_DEF_Int3.elements_count; td->specifics = asn1_DEF_Int3.specifics; } +void +Int4_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Int4_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Int4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Int4_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Int4_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -417,7 +473,7 @@ Int4_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Int4_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -425,18 +481,12 @@ Int4_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Int4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Int4_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Int4_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Int4_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Int4_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -447,11 +497,13 @@ static ber_tlv_tag_t asn1_DEF_Int4_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Int4 = { "Int4", + Int4_free, + Int4_print, Int4_constraint, Int4_decode_ber, Int4_encode_der, - Int4_print, - Int4_free, + 0, /* Not implemented yet */ + Int4_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Int4_tags, sizeof(asn1_DEF_Int4_tags) @@ -477,11 +529,12 @@ typedef Int4_t Int5_t; /*** <<< FUNC-DECLS [Int5] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Int5; +asn_struct_free_f Int5_free; +asn_struct_print_f Int5_print; asn_constr_check_f Int5_constraint; ber_type_decoder_f Int5_decode_ber; der_type_encoder_f Int5_encode_der; -asn_struct_print_f Int5_print; -asn_struct_free_f Int5_free; +xer_type_encoder_f Int5_encode_xer; /*** <<< CODE [Int5] >>> ***/ @@ -523,16 +576,32 @@ Int5_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Int5_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Int4.ber_decoder; - td->der_encoder = asn1_DEF_Int4.der_encoder; td->free_struct = asn1_DEF_Int4.free_struct; td->print_struct = asn1_DEF_Int4.print_struct; + td->ber_decoder = asn1_DEF_Int4.ber_decoder; + td->der_encoder = asn1_DEF_Int4.der_encoder; + td->xer_decoder = asn1_DEF_Int4.xer_decoder; + td->xer_encoder = asn1_DEF_Int4.xer_encoder; td->last_tag_form = asn1_DEF_Int4.last_tag_form; td->elements = asn1_DEF_Int4.elements; td->elements_count = asn1_DEF_Int4.elements_count; td->specifics = asn1_DEF_Int4.specifics; } +void +Int5_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Int5_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Int5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Int5_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Int5_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -540,7 +609,7 @@ Int5_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Int5_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -548,18 +617,12 @@ Int5_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Int5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Int5_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Int5_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Int5_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Int5_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -570,11 +633,13 @@ static ber_tlv_tag_t asn1_DEF_Int5_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Int5 = { "Int5", + Int5_free, + Int5_print, Int5_constraint, Int5_decode_ber, Int5_encode_der, - Int5_print, - Int5_free, + 0, /* Not implemented yet */ + Int5_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Int5_tags, sizeof(asn1_DEF_Int5_tags) @@ -600,11 +665,12 @@ typedef INTEGER_t ExtensibleExtensions_t; /*** <<< FUNC-DECLS [ExtensibleExtensions] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_ExtensibleExtensions; +asn_struct_free_f ExtensibleExtensions_free; +asn_struct_print_f ExtensibleExtensions_print; asn_constr_check_f ExtensibleExtensions_constraint; ber_type_decoder_f ExtensibleExtensions_decode_ber; der_type_encoder_f ExtensibleExtensions_encode_der; -asn_struct_print_f ExtensibleExtensions_print; -asn_struct_free_f ExtensibleExtensions_free; +xer_type_encoder_f ExtensibleExtensions_encode_xer; /*** <<< CODE [ExtensibleExtensions] >>> ***/ @@ -646,16 +712,32 @@ ExtensibleExtensions_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void ExtensibleExtensions_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_INTEGER.ber_decoder; - td->der_encoder = asn1_DEF_INTEGER.der_encoder; td->free_struct = asn1_DEF_INTEGER.free_struct; td->print_struct = asn1_DEF_INTEGER.print_struct; + td->ber_decoder = asn1_DEF_INTEGER.ber_decoder; + td->der_encoder = asn1_DEF_INTEGER.der_encoder; + td->xer_decoder = asn1_DEF_INTEGER.xer_decoder; + td->xer_encoder = asn1_DEF_INTEGER.xer_encoder; td->last_tag_form = asn1_DEF_INTEGER.last_tag_form; td->elements = asn1_DEF_INTEGER.elements; td->elements_count = asn1_DEF_INTEGER.elements_count; td->specifics = asn1_DEF_INTEGER.specifics; } +void +ExtensibleExtensions_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + ExtensibleExtensions_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +ExtensibleExtensions_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + ExtensibleExtensions_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t ExtensibleExtensions_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -663,7 +745,7 @@ ExtensibleExtensions_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t ExtensibleExtensions_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -671,18 +753,12 @@ ExtensibleExtensions_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -ExtensibleExtensions_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - ExtensibleExtensions_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -ExtensibleExtensions_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +ExtensibleExtensions_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { ExtensibleExtensions_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -693,11 +769,13 @@ static ber_tlv_tag_t asn1_DEF_ExtensibleExtensions_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_ExtensibleExtensions = { "ExtensibleExtensions", + ExtensibleExtensions_free, + ExtensibleExtensions_print, ExtensibleExtensions_constraint, ExtensibleExtensions_decode_ber, ExtensibleExtensions_encode_der, - ExtensibleExtensions_print, - ExtensibleExtensions_free, + 0, /* Not implemented yet */ + ExtensibleExtensions_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_ExtensibleExtensions_tags, sizeof(asn1_DEF_ExtensibleExtensions_tags) @@ -723,11 +801,12 @@ typedef IA5String_t Str1_t; /*** <<< FUNC-DECLS [Str1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Str1; +asn_struct_free_f Str1_free; +asn_struct_print_f Str1_print; asn_constr_check_f Str1_constraint; ber_type_decoder_f Str1_decode_ber; der_type_encoder_f Str1_encode_der; -asn_struct_print_f Str1_print; -asn_struct_free_f Str1_free; +xer_type_encoder_f Str1_encode_xer; /*** <<< CODE [Str1] >>> ***/ @@ -747,16 +826,32 @@ Str1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Str1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_IA5String.ber_decoder; - td->der_encoder = asn1_DEF_IA5String.der_encoder; td->free_struct = asn1_DEF_IA5String.free_struct; td->print_struct = asn1_DEF_IA5String.print_struct; + td->ber_decoder = asn1_DEF_IA5String.ber_decoder; + td->der_encoder = asn1_DEF_IA5String.der_encoder; + td->xer_decoder = asn1_DEF_IA5String.xer_decoder; + td->xer_encoder = asn1_DEF_IA5String.xer_encoder; td->last_tag_form = asn1_DEF_IA5String.last_tag_form; td->elements = asn1_DEF_IA5String.elements; td->elements_count = asn1_DEF_IA5String.elements_count; td->specifics = asn1_DEF_IA5String.specifics; } +void +Str1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Str1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Str1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Str1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Str1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -764,7 +859,7 @@ Str1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Str1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -772,18 +867,12 @@ Str1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Str1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { +asn_enc_rval_t +Str1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Str1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Str1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { - Str1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -794,11 +883,13 @@ static ber_tlv_tag_t asn1_DEF_Str1_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Str1 = { "Str1", + Str1_free, + Str1_print, Str1_constraint, Str1_decode_ber, Str1_encode_der, - Str1_print, - Str1_free, + 0, /* Not implemented yet */ + Str1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Str1_tags, sizeof(asn1_DEF_Str1_tags) @@ -824,11 +915,12 @@ typedef Str1_t Str2_t; /*** <<< FUNC-DECLS [Str2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Str2; +asn_struct_free_f Str2_free; +asn_struct_print_f Str2_print; asn_constr_check_f Str2_constraint; ber_type_decoder_f Str2_decode_ber; der_type_encoder_f Str2_encode_der; -asn_struct_print_f Str2_print; -asn_struct_free_f Str2_free; +xer_type_encoder_f Str2_encode_xer; /*** <<< CTABLES [Str2] >>> ***/ @@ -882,16 +974,32 @@ Str2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Str2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Str1.ber_decoder; - td->der_encoder = asn1_DEF_Str1.der_encoder; td->free_struct = asn1_DEF_Str1.free_struct; td->print_struct = asn1_DEF_Str1.print_struct; + td->ber_decoder = asn1_DEF_Str1.ber_decoder; + td->der_encoder = asn1_DEF_Str1.der_encoder; + td->xer_decoder = asn1_DEF_Str1.xer_decoder; + td->xer_encoder = asn1_DEF_Str1.xer_encoder; td->last_tag_form = asn1_DEF_Str1.last_tag_form; td->elements = asn1_DEF_Str1.elements; td->elements_count = asn1_DEF_Str1.elements_count; td->specifics = asn1_DEF_Str1.specifics; } +void +Str2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Str2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Str2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Str2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Str2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -899,7 +1007,7 @@ Str2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Str2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -907,18 +1015,12 @@ Str2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Str2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Str2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Str2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Str2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Str2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -929,11 +1031,13 @@ static ber_tlv_tag_t asn1_DEF_Str2_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Str2 = { "Str2", + Str2_free, + Str2_print, Str2_constraint, Str2_decode_ber, Str2_encode_der, - Str2_print, - Str2_free, + 0, /* Not implemented yet */ + Str2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Str2_tags, sizeof(asn1_DEF_Str2_tags) @@ -959,11 +1063,12 @@ typedef Str2_t Str3_t; /*** <<< FUNC-DECLS [Str3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Str3; +asn_struct_free_f Str3_free; +asn_struct_print_f Str3_print; asn_constr_check_f Str3_constraint; ber_type_decoder_f Str3_decode_ber; der_type_encoder_f Str3_encode_der; -asn_struct_print_f Str3_print; -asn_struct_free_f Str3_free; +xer_type_encoder_f Str3_encode_xer; /*** <<< CTABLES [Str3] >>> ***/ @@ -1028,16 +1133,32 @@ Str3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Str3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Str2.ber_decoder; - td->der_encoder = asn1_DEF_Str2.der_encoder; td->free_struct = asn1_DEF_Str2.free_struct; td->print_struct = asn1_DEF_Str2.print_struct; + td->ber_decoder = asn1_DEF_Str2.ber_decoder; + td->der_encoder = asn1_DEF_Str2.der_encoder; + td->xer_decoder = asn1_DEF_Str2.xer_decoder; + td->xer_encoder = asn1_DEF_Str2.xer_encoder; td->last_tag_form = asn1_DEF_Str2.last_tag_form; td->elements = asn1_DEF_Str2.elements; td->elements_count = asn1_DEF_Str2.elements_count; td->specifics = asn1_DEF_Str2.specifics; } +void +Str3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Str3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Str3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Str3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Str3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1045,7 +1166,7 @@ Str3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Str3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1053,18 +1174,12 @@ Str3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Str3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Str3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Str3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Str3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Str3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1075,11 +1190,13 @@ static ber_tlv_tag_t asn1_DEF_Str3_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Str3 = { "Str3", + Str3_free, + Str3_print, Str3_constraint, Str3_decode_ber, Str3_encode_der, - Str3_print, - Str3_free, + 0, /* Not implemented yet */ + Str3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Str3_tags, sizeof(asn1_DEF_Str3_tags) @@ -1105,11 +1222,12 @@ typedef IA5String_t Str4_t; /*** <<< FUNC-DECLS [Str4] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Str4; +asn_struct_free_f Str4_free; +asn_struct_print_f Str4_print; asn_constr_check_f Str4_constraint; ber_type_decoder_f Str4_decode_ber; der_type_encoder_f Str4_encode_der; -asn_struct_print_f Str4_print; -asn_struct_free_f Str4_free; +xer_type_encoder_f Str4_encode_xer; /*** <<< CTABLES [Str4] >>> ***/ @@ -1160,16 +1278,32 @@ Str4_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Str4_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_IA5String.ber_decoder; - td->der_encoder = asn1_DEF_IA5String.der_encoder; td->free_struct = asn1_DEF_IA5String.free_struct; td->print_struct = asn1_DEF_IA5String.print_struct; + td->ber_decoder = asn1_DEF_IA5String.ber_decoder; + td->der_encoder = asn1_DEF_IA5String.der_encoder; + td->xer_decoder = asn1_DEF_IA5String.xer_decoder; + td->xer_encoder = asn1_DEF_IA5String.xer_encoder; td->last_tag_form = asn1_DEF_IA5String.last_tag_form; td->elements = asn1_DEF_IA5String.elements; td->elements_count = asn1_DEF_IA5String.elements_count; td->specifics = asn1_DEF_IA5String.specifics; } +void +Str4_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Str4_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Str4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Str4_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Str4_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1177,7 +1311,7 @@ Str4_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Str4_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1185,18 +1319,12 @@ Str4_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Str4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Str4_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Str4_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Str4_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Str4_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1207,11 +1335,13 @@ static ber_tlv_tag_t asn1_DEF_Str4_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Str4 = { "Str4", + Str4_free, + Str4_print, Str4_constraint, Str4_decode_ber, Str4_encode_der, - Str4_print, - Str4_free, + 0, /* Not implemented yet */ + Str4_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Str4_tags, sizeof(asn1_DEF_Str4_tags) @@ -1237,11 +1367,12 @@ typedef IA5String_t PER_Visible_t; /*** <<< FUNC-DECLS [PER-Visible] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_PER_Visible; +asn_struct_free_f PER_Visible_free; +asn_struct_print_f PER_Visible_print; asn_constr_check_f PER_Visible_constraint; ber_type_decoder_f PER_Visible_decode_ber; der_type_encoder_f PER_Visible_encode_der; -asn_struct_print_f PER_Visible_print; -asn_struct_free_f PER_Visible_free; +xer_type_encoder_f PER_Visible_encode_xer; /*** <<< CTABLES [PER-Visible] >>> ***/ @@ -1292,16 +1423,32 @@ PER_Visible_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void PER_Visible_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_IA5String.ber_decoder; - td->der_encoder = asn1_DEF_IA5String.der_encoder; td->free_struct = asn1_DEF_IA5String.free_struct; td->print_struct = asn1_DEF_IA5String.print_struct; + td->ber_decoder = asn1_DEF_IA5String.ber_decoder; + td->der_encoder = asn1_DEF_IA5String.der_encoder; + td->xer_decoder = asn1_DEF_IA5String.xer_decoder; + td->xer_encoder = asn1_DEF_IA5String.xer_encoder; td->last_tag_form = asn1_DEF_IA5String.last_tag_form; td->elements = asn1_DEF_IA5String.elements; td->elements_count = asn1_DEF_IA5String.elements_count; td->specifics = asn1_DEF_IA5String.specifics; } +void +PER_Visible_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + PER_Visible_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +PER_Visible_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + PER_Visible_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t PER_Visible_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1309,7 +1456,7 @@ PER_Visible_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t PER_Visible_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1317,18 +1464,12 @@ PER_Visible_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -PER_Visible_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - PER_Visible_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -PER_Visible_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +PER_Visible_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { PER_Visible_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1339,11 +1480,13 @@ static ber_tlv_tag_t asn1_DEF_PER_Visible_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_PER_Visible = { "PER-Visible", + PER_Visible_free, + PER_Visible_print, PER_Visible_constraint, PER_Visible_decode_ber, PER_Visible_encode_der, - PER_Visible_print, - PER_Visible_free, + 0, /* Not implemented yet */ + PER_Visible_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_PER_Visible_tags, sizeof(asn1_DEF_PER_Visible_tags) @@ -1369,11 +1512,12 @@ typedef PER_Visible_t PER_Visible_2_t; /*** <<< FUNC-DECLS [PER-Visible-2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_PER_Visible_2; +asn_struct_free_f PER_Visible_2_free; +asn_struct_print_f PER_Visible_2_print; asn_constr_check_f PER_Visible_2_constraint; ber_type_decoder_f PER_Visible_2_decode_ber; der_type_encoder_f PER_Visible_2_encode_der; -asn_struct_print_f PER_Visible_2_print; -asn_struct_free_f PER_Visible_2_free; +xer_type_encoder_f PER_Visible_2_encode_xer; /*** <<< CTABLES [PER-Visible-2] >>> ***/ @@ -1424,16 +1568,32 @@ PER_Visible_2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void PER_Visible_2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +PER_Visible_2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + PER_Visible_2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +PER_Visible_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + PER_Visible_2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t PER_Visible_2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1441,7 +1601,7 @@ PER_Visible_2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t PER_Visible_2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1449,18 +1609,12 @@ PER_Visible_2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -PER_Visible_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - PER_Visible_2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -PER_Visible_2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +PER_Visible_2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { PER_Visible_2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1471,11 +1625,13 @@ static ber_tlv_tag_t asn1_DEF_PER_Visible_2_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_PER_Visible_2 = { "PER-Visible-2", + PER_Visible_2_free, + PER_Visible_2_print, PER_Visible_2_constraint, PER_Visible_2_decode_ber, PER_Visible_2_encode_der, - PER_Visible_2_print, - PER_Visible_2_free, + 0, /* Not implemented yet */ + PER_Visible_2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_PER_Visible_2_tags, sizeof(asn1_DEF_PER_Visible_2_tags) @@ -1501,11 +1657,12 @@ typedef PER_Visible_t Not_PER_Visible_1_t; /*** <<< FUNC-DECLS [Not-PER-Visible-1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_1; +asn_struct_free_f Not_PER_Visible_1_free; +asn_struct_print_f Not_PER_Visible_1_print; asn_constr_check_f Not_PER_Visible_1_constraint; ber_type_decoder_f Not_PER_Visible_1_decode_ber; der_type_encoder_f Not_PER_Visible_1_encode_der; -asn_struct_print_f Not_PER_Visible_1_print; -asn_struct_free_f Not_PER_Visible_1_free; +xer_type_encoder_f Not_PER_Visible_1_encode_xer; /*** <<< CTABLES [Not-PER-Visible-1] >>> ***/ @@ -1556,16 +1713,32 @@ Not_PER_Visible_1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Not_PER_Visible_1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +Not_PER_Visible_1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Not_PER_Visible_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Not_PER_Visible_1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Not_PER_Visible_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Not_PER_Visible_1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1573,7 +1746,7 @@ Not_PER_Visible_1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Not_PER_Visible_1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1581,18 +1754,12 @@ Not_PER_Visible_1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Not_PER_Visible_1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Not_PER_Visible_1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Not_PER_Visible_1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Not_PER_Visible_1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Not_PER_Visible_1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1603,11 +1770,13 @@ static ber_tlv_tag_t asn1_DEF_Not_PER_Visible_1_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_1 = { "Not-PER-Visible-1", + Not_PER_Visible_1_free, + Not_PER_Visible_1_print, Not_PER_Visible_1_constraint, Not_PER_Visible_1_decode_ber, Not_PER_Visible_1_encode_der, - Not_PER_Visible_1_print, - Not_PER_Visible_1_free, + 0, /* Not implemented yet */ + Not_PER_Visible_1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Not_PER_Visible_1_tags, sizeof(asn1_DEF_Not_PER_Visible_1_tags) @@ -1633,11 +1802,12 @@ typedef PER_Visible_t Not_PER_Visible_2_t; /*** <<< FUNC-DECLS [Not-PER-Visible-2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_2; +asn_struct_free_f Not_PER_Visible_2_free; +asn_struct_print_f Not_PER_Visible_2_print; asn_constr_check_f Not_PER_Visible_2_constraint; ber_type_decoder_f Not_PER_Visible_2_decode_ber; der_type_encoder_f Not_PER_Visible_2_encode_der; -asn_struct_print_f Not_PER_Visible_2_print; -asn_struct_free_f Not_PER_Visible_2_free; +xer_type_encoder_f Not_PER_Visible_2_encode_xer; /*** <<< CTABLES [Not-PER-Visible-2] >>> ***/ @@ -1688,16 +1858,32 @@ Not_PER_Visible_2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Not_PER_Visible_2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +Not_PER_Visible_2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Not_PER_Visible_2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Not_PER_Visible_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Not_PER_Visible_2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Not_PER_Visible_2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1705,7 +1891,7 @@ Not_PER_Visible_2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Not_PER_Visible_2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1713,18 +1899,12 @@ Not_PER_Visible_2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Not_PER_Visible_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Not_PER_Visible_2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Not_PER_Visible_2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Not_PER_Visible_2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Not_PER_Visible_2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1735,11 +1915,13 @@ static ber_tlv_tag_t asn1_DEF_Not_PER_Visible_2_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_2 = { "Not-PER-Visible-2", + Not_PER_Visible_2_free, + Not_PER_Visible_2_print, Not_PER_Visible_2_constraint, Not_PER_Visible_2_decode_ber, Not_PER_Visible_2_encode_der, - Not_PER_Visible_2_print, - Not_PER_Visible_2_free, + 0, /* Not implemented yet */ + Not_PER_Visible_2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Not_PER_Visible_2_tags, sizeof(asn1_DEF_Not_PER_Visible_2_tags) @@ -1765,11 +1947,12 @@ typedef PER_Visible_t Not_PER_Visible_3_t; /*** <<< FUNC-DECLS [Not-PER-Visible-3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_3; +asn_struct_free_f Not_PER_Visible_3_free; +asn_struct_print_f Not_PER_Visible_3_print; asn_constr_check_f Not_PER_Visible_3_constraint; ber_type_decoder_f Not_PER_Visible_3_decode_ber; der_type_encoder_f Not_PER_Visible_3_encode_der; -asn_struct_print_f Not_PER_Visible_3_print; -asn_struct_free_f Not_PER_Visible_3_free; +xer_type_encoder_f Not_PER_Visible_3_encode_xer; /*** <<< CTABLES [Not-PER-Visible-3] >>> ***/ @@ -1820,16 +2003,32 @@ Not_PER_Visible_3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Not_PER_Visible_3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +Not_PER_Visible_3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Not_PER_Visible_3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Not_PER_Visible_3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Not_PER_Visible_3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Not_PER_Visible_3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1837,7 +2036,7 @@ Not_PER_Visible_3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Not_PER_Visible_3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1845,18 +2044,12 @@ Not_PER_Visible_3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Not_PER_Visible_3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Not_PER_Visible_3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Not_PER_Visible_3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Not_PER_Visible_3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Not_PER_Visible_3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -1867,11 +2060,13 @@ static ber_tlv_tag_t asn1_DEF_Not_PER_Visible_3_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Not_PER_Visible_3 = { "Not-PER-Visible-3", + Not_PER_Visible_3_free, + Not_PER_Visible_3_print, Not_PER_Visible_3_constraint, Not_PER_Visible_3_decode_ber, Not_PER_Visible_3_encode_der, - Not_PER_Visible_3_print, - Not_PER_Visible_3_free, + 0, /* Not implemented yet */ + Not_PER_Visible_3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Not_PER_Visible_3_tags, sizeof(asn1_DEF_Not_PER_Visible_3_tags) @@ -1897,11 +2092,12 @@ typedef PER_Visible_t SIZE_but_not_FROM_t; /*** <<< FUNC-DECLS [SIZE-but-not-FROM] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_SIZE_but_not_FROM; +asn_struct_free_f SIZE_but_not_FROM_free; +asn_struct_print_f SIZE_but_not_FROM_print; asn_constr_check_f SIZE_but_not_FROM_constraint; ber_type_decoder_f SIZE_but_not_FROM_decode_ber; der_type_encoder_f SIZE_but_not_FROM_encode_der; -asn_struct_print_f SIZE_but_not_FROM_print; -asn_struct_free_f SIZE_but_not_FROM_free; +xer_type_encoder_f SIZE_but_not_FROM_encode_xer; /*** <<< CTABLES [SIZE-but-not-FROM] >>> ***/ @@ -1955,16 +2151,32 @@ SIZE_but_not_FROM_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void SIZE_but_not_FROM_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +SIZE_but_not_FROM_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + SIZE_but_not_FROM_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +SIZE_but_not_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + SIZE_but_not_FROM_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t SIZE_but_not_FROM_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -1972,7 +2184,7 @@ SIZE_but_not_FROM_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t SIZE_but_not_FROM_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -1980,18 +2192,12 @@ SIZE_but_not_FROM_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -SIZE_but_not_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - SIZE_but_not_FROM_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -SIZE_but_not_FROM_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +SIZE_but_not_FROM_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { SIZE_but_not_FROM_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2002,11 +2208,13 @@ static ber_tlv_tag_t asn1_DEF_SIZE_but_not_FROM_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_SIZE_but_not_FROM = { "SIZE-but-not-FROM", + SIZE_but_not_FROM_free, + SIZE_but_not_FROM_print, SIZE_but_not_FROM_constraint, SIZE_but_not_FROM_decode_ber, SIZE_but_not_FROM_encode_der, - SIZE_but_not_FROM_print, - SIZE_but_not_FROM_free, + 0, /* Not implemented yet */ + SIZE_but_not_FROM_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_SIZE_but_not_FROM_tags, sizeof(asn1_DEF_SIZE_but_not_FROM_tags) @@ -2032,11 +2240,12 @@ typedef PER_Visible_t SIZE_and_FROM_t; /*** <<< FUNC-DECLS [SIZE-and-FROM] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_SIZE_and_FROM; +asn_struct_free_f SIZE_and_FROM_free; +asn_struct_print_f SIZE_and_FROM_print; asn_constr_check_f SIZE_and_FROM_constraint; ber_type_decoder_f SIZE_and_FROM_decode_ber; der_type_encoder_f SIZE_and_FROM_encode_der; -asn_struct_print_f SIZE_and_FROM_print; -asn_struct_free_f SIZE_and_FROM_free; +xer_type_encoder_f SIZE_and_FROM_encode_xer; /*** <<< CTABLES [SIZE-and-FROM] >>> ***/ @@ -2090,16 +2299,32 @@ SIZE_and_FROM_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void SIZE_and_FROM_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +SIZE_and_FROM_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + SIZE_and_FROM_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +SIZE_and_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + SIZE_and_FROM_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t SIZE_and_FROM_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2107,7 +2332,7 @@ SIZE_and_FROM_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t SIZE_and_FROM_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2115,18 +2340,12 @@ SIZE_and_FROM_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -SIZE_and_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - SIZE_and_FROM_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -SIZE_and_FROM_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +SIZE_and_FROM_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { SIZE_and_FROM_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2137,11 +2356,13 @@ static ber_tlv_tag_t asn1_DEF_SIZE_and_FROM_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_SIZE_and_FROM = { "SIZE-and-FROM", + SIZE_and_FROM_free, + SIZE_and_FROM_print, SIZE_and_FROM_constraint, SIZE_and_FROM_decode_ber, SIZE_and_FROM_encode_der, - SIZE_and_FROM_print, - SIZE_and_FROM_free, + 0, /* Not implemented yet */ + SIZE_and_FROM_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_SIZE_and_FROM_tags, sizeof(asn1_DEF_SIZE_and_FROM_tags) @@ -2167,11 +2388,12 @@ typedef PER_Visible_t Neither_SIZE_nor_FROM_t; /*** <<< FUNC-DECLS [Neither-SIZE-nor-FROM] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Neither_SIZE_nor_FROM; +asn_struct_free_f Neither_SIZE_nor_FROM_free; +asn_struct_print_f Neither_SIZE_nor_FROM_print; asn_constr_check_f Neither_SIZE_nor_FROM_constraint; ber_type_decoder_f Neither_SIZE_nor_FROM_decode_ber; der_type_encoder_f Neither_SIZE_nor_FROM_encode_der; -asn_struct_print_f Neither_SIZE_nor_FROM_print; -asn_struct_free_f Neither_SIZE_nor_FROM_free; +xer_type_encoder_f Neither_SIZE_nor_FROM_encode_xer; /*** <<< CTABLES [Neither-SIZE-nor-FROM] >>> ***/ @@ -2222,16 +2444,32 @@ Neither_SIZE_nor_FROM_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; - td->der_encoder = asn1_DEF_PER_Visible.der_encoder; td->free_struct = asn1_DEF_PER_Visible.free_struct; td->print_struct = asn1_DEF_PER_Visible.print_struct; + td->ber_decoder = asn1_DEF_PER_Visible.ber_decoder; + td->der_encoder = asn1_DEF_PER_Visible.der_encoder; + td->xer_decoder = asn1_DEF_PER_Visible.xer_decoder; + td->xer_encoder = asn1_DEF_PER_Visible.xer_encoder; td->last_tag_form = asn1_DEF_PER_Visible.last_tag_form; td->elements = asn1_DEF_PER_Visible.elements; td->elements_count = asn1_DEF_PER_Visible.elements_count; td->specifics = asn1_DEF_PER_Visible.specifics; } +void +Neither_SIZE_nor_FROM_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Neither_SIZE_nor_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Neither_SIZE_nor_FROM_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2239,7 +2477,7 @@ Neither_SIZE_nor_FROM_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Neither_SIZE_nor_FROM_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2247,18 +2485,12 @@ Neither_SIZE_nor_FROM_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Neither_SIZE_nor_FROM_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Neither_SIZE_nor_FROM_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Neither_SIZE_nor_FROM_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Neither_SIZE_nor_FROM_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2269,11 +2501,13 @@ static ber_tlv_tag_t asn1_DEF_Neither_SIZE_nor_FROM_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Neither_SIZE_nor_FROM = { "Neither-SIZE-nor-FROM", + Neither_SIZE_nor_FROM_free, + Neither_SIZE_nor_FROM_print, Neither_SIZE_nor_FROM_constraint, Neither_SIZE_nor_FROM_decode_ber, Neither_SIZE_nor_FROM_encode_der, - Neither_SIZE_nor_FROM_print, - Neither_SIZE_nor_FROM_free, + 0, /* Not implemented yet */ + Neither_SIZE_nor_FROM_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Neither_SIZE_nor_FROM_tags, sizeof(asn1_DEF_Neither_SIZE_nor_FROM_tags) @@ -2299,11 +2533,12 @@ typedef Utf8_2_t Utf8_3_t; /*** <<< FUNC-DECLS [Utf8-3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Utf8_3; +asn_struct_free_f Utf8_3_free; +asn_struct_print_f Utf8_3_print; asn_constr_check_f Utf8_3_constraint; ber_type_decoder_f Utf8_3_decode_ber; der_type_encoder_f Utf8_3_encode_der; -asn_struct_print_f Utf8_3_print; -asn_struct_free_f Utf8_3_free; +xer_type_encoder_f Utf8_3_encode_xer; /*** <<< CTABLES [Utf8-3] >>> ***/ @@ -2371,16 +2606,32 @@ Utf8_3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Utf8_3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Utf8_2.ber_decoder; - td->der_encoder = asn1_DEF_Utf8_2.der_encoder; td->free_struct = asn1_DEF_Utf8_2.free_struct; td->print_struct = asn1_DEF_Utf8_2.print_struct; + td->ber_decoder = asn1_DEF_Utf8_2.ber_decoder; + td->der_encoder = asn1_DEF_Utf8_2.der_encoder; + td->xer_decoder = asn1_DEF_Utf8_2.xer_decoder; + td->xer_encoder = asn1_DEF_Utf8_2.xer_encoder; td->last_tag_form = asn1_DEF_Utf8_2.last_tag_form; td->elements = asn1_DEF_Utf8_2.elements; td->elements_count = asn1_DEF_Utf8_2.elements_count; td->specifics = asn1_DEF_Utf8_2.specifics; } +void +Utf8_3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Utf8_3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Utf8_3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Utf8_3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Utf8_3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2388,7 +2639,7 @@ Utf8_3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Utf8_3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2396,18 +2647,12 @@ Utf8_3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Utf8_3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Utf8_3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Utf8_3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Utf8_3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Utf8_3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2418,11 +2663,13 @@ static ber_tlv_tag_t asn1_DEF_Utf8_3_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Utf8_3 = { "Utf8-3", + Utf8_3_free, + Utf8_3_print, Utf8_3_constraint, Utf8_3_decode_ber, Utf8_3_encode_der, - Utf8_3_print, - Utf8_3_free, + 0, /* Not implemented yet */ + Utf8_3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Utf8_3_tags, sizeof(asn1_DEF_Utf8_3_tags) @@ -2448,11 +2695,12 @@ typedef Utf8_1_t Utf8_2_t; /*** <<< FUNC-DECLS [Utf8-2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Utf8_2; +asn_struct_free_f Utf8_2_free; +asn_struct_print_f Utf8_2_print; asn_constr_check_f Utf8_2_constraint; ber_type_decoder_f Utf8_2_decode_ber; der_type_encoder_f Utf8_2_encode_der; -asn_struct_print_f Utf8_2_print; -asn_struct_free_f Utf8_2_free; +xer_type_encoder_f Utf8_2_encode_xer; /*** <<< CODE [Utf8-2] >>> ***/ @@ -2490,16 +2738,32 @@ Utf8_2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Utf8_2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Utf8_1.ber_decoder; - td->der_encoder = asn1_DEF_Utf8_1.der_encoder; td->free_struct = asn1_DEF_Utf8_1.free_struct; td->print_struct = asn1_DEF_Utf8_1.print_struct; + td->ber_decoder = asn1_DEF_Utf8_1.ber_decoder; + td->der_encoder = asn1_DEF_Utf8_1.der_encoder; + td->xer_decoder = asn1_DEF_Utf8_1.xer_decoder; + td->xer_encoder = asn1_DEF_Utf8_1.xer_encoder; td->last_tag_form = asn1_DEF_Utf8_1.last_tag_form; td->elements = asn1_DEF_Utf8_1.elements; td->elements_count = asn1_DEF_Utf8_1.elements_count; td->specifics = asn1_DEF_Utf8_1.specifics; } +void +Utf8_2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Utf8_2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Utf8_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Utf8_2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Utf8_2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2507,7 +2771,7 @@ Utf8_2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Utf8_2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2515,18 +2779,12 @@ Utf8_2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Utf8_2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Utf8_2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Utf8_2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Utf8_2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Utf8_2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2537,11 +2795,13 @@ static ber_tlv_tag_t asn1_DEF_Utf8_2_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Utf8_2 = { "Utf8-2", + Utf8_2_free, + Utf8_2_print, Utf8_2_constraint, Utf8_2_decode_ber, Utf8_2_encode_der, - Utf8_2_print, - Utf8_2_free, + 0, /* Not implemented yet */ + Utf8_2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Utf8_2_tags, sizeof(asn1_DEF_Utf8_2_tags) @@ -2567,11 +2827,12 @@ typedef UTF8String_t Utf8_1_t; /*** <<< FUNC-DECLS [Utf8-1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Utf8_1; +asn_struct_free_f Utf8_1_free; +asn_struct_print_f Utf8_1_print; asn_constr_check_f Utf8_1_constraint; ber_type_decoder_f Utf8_1_decode_ber; der_type_encoder_f Utf8_1_encode_der; -asn_struct_print_f Utf8_1_print; -asn_struct_free_f Utf8_1_free; +xer_type_encoder_f Utf8_1_encode_xer; /*** <<< CODE [Utf8-1] >>> ***/ @@ -2591,16 +2852,32 @@ Utf8_1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Utf8_1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_UTF8String.ber_decoder; - td->der_encoder = asn1_DEF_UTF8String.der_encoder; td->free_struct = asn1_DEF_UTF8String.free_struct; td->print_struct = asn1_DEF_UTF8String.print_struct; + td->ber_decoder = asn1_DEF_UTF8String.ber_decoder; + td->der_encoder = asn1_DEF_UTF8String.der_encoder; + td->xer_decoder = asn1_DEF_UTF8String.xer_decoder; + td->xer_encoder = asn1_DEF_UTF8String.xer_encoder; td->last_tag_form = asn1_DEF_UTF8String.last_tag_form; td->elements = asn1_DEF_UTF8String.elements; td->elements_count = asn1_DEF_UTF8String.elements_count; td->specifics = asn1_DEF_UTF8String.specifics; } +void +Utf8_1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Utf8_1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Utf8_1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Utf8_1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Utf8_1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2608,7 +2885,7 @@ Utf8_1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Utf8_1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2616,18 +2893,12 @@ Utf8_1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Utf8_1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { +asn_enc_rval_t +Utf8_1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Utf8_1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Utf8_1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { - Utf8_1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2638,11 +2909,13 @@ static ber_tlv_tag_t asn1_DEF_Utf8_1_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Utf8_1 = { "Utf8-1", + Utf8_1_free, + Utf8_1_print, Utf8_1_constraint, Utf8_1_decode_ber, Utf8_1_encode_der, - Utf8_1_print, - Utf8_1_free, + 0, /* Not implemented yet */ + Utf8_1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Utf8_1_tags, sizeof(asn1_DEF_Utf8_1_tags) @@ -2668,11 +2941,12 @@ typedef Identifier_t VisibleIdentifier_t; /*** <<< FUNC-DECLS [VisibleIdentifier] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_VisibleIdentifier; +asn_struct_free_f VisibleIdentifier_free; +asn_struct_print_f VisibleIdentifier_print; asn_constr_check_f VisibleIdentifier_constraint; ber_type_decoder_f VisibleIdentifier_decode_ber; der_type_encoder_f VisibleIdentifier_encode_der; -asn_struct_print_f VisibleIdentifier_print; -asn_struct_free_f VisibleIdentifier_free; +xer_type_encoder_f VisibleIdentifier_encode_xer; /*** <<< CTABLES [VisibleIdentifier] >>> ***/ @@ -2738,16 +3012,32 @@ VisibleIdentifier_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void VisibleIdentifier_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Identifier.ber_decoder; - td->der_encoder = asn1_DEF_Identifier.der_encoder; td->free_struct = asn1_DEF_Identifier.free_struct; td->print_struct = asn1_DEF_Identifier.print_struct; + td->ber_decoder = asn1_DEF_Identifier.ber_decoder; + td->der_encoder = asn1_DEF_Identifier.der_encoder; + td->xer_decoder = asn1_DEF_Identifier.xer_decoder; + td->xer_encoder = asn1_DEF_Identifier.xer_encoder; td->last_tag_form = asn1_DEF_Identifier.last_tag_form; td->elements = asn1_DEF_Identifier.elements; td->elements_count = asn1_DEF_Identifier.elements_count; td->specifics = asn1_DEF_Identifier.specifics; } +void +VisibleIdentifier_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + VisibleIdentifier_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +VisibleIdentifier_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + VisibleIdentifier_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t VisibleIdentifier_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2755,7 +3045,7 @@ VisibleIdentifier_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t VisibleIdentifier_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2763,18 +3053,12 @@ VisibleIdentifier_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -VisibleIdentifier_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - VisibleIdentifier_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -VisibleIdentifier_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +VisibleIdentifier_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { VisibleIdentifier_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2785,11 +3069,13 @@ static ber_tlv_tag_t asn1_DEF_VisibleIdentifier_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_VisibleIdentifier = { "VisibleIdentifier", + VisibleIdentifier_free, + VisibleIdentifier_print, VisibleIdentifier_constraint, VisibleIdentifier_decode_ber, VisibleIdentifier_encode_der, - VisibleIdentifier_print, - VisibleIdentifier_free, + 0, /* Not implemented yet */ + VisibleIdentifier_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_VisibleIdentifier_tags, sizeof(asn1_DEF_VisibleIdentifier_tags) @@ -2815,11 +3101,12 @@ typedef VisibleString_t Identifier_t; /*** <<< FUNC-DECLS [Identifier] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_Identifier; +asn_struct_free_f Identifier_free; +asn_struct_print_f Identifier_print; asn_constr_check_f Identifier_constraint; ber_type_decoder_f Identifier_decode_ber; der_type_encoder_f Identifier_encode_der; -asn_struct_print_f Identifier_print; -asn_struct_free_f Identifier_free; +xer_type_encoder_f Identifier_encode_xer; /*** <<< CTABLES [Identifier] >>> ***/ @@ -2885,16 +3172,32 @@ Identifier_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void Identifier_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_VisibleString.ber_decoder; - td->der_encoder = asn1_DEF_VisibleString.der_encoder; td->free_struct = asn1_DEF_VisibleString.free_struct; td->print_struct = asn1_DEF_VisibleString.print_struct; + td->ber_decoder = asn1_DEF_VisibleString.ber_decoder; + td->der_encoder = asn1_DEF_VisibleString.der_encoder; + td->xer_decoder = asn1_DEF_VisibleString.xer_decoder; + td->xer_encoder = asn1_DEF_VisibleString.xer_encoder; td->last_tag_form = asn1_DEF_VisibleString.last_tag_form; td->elements = asn1_DEF_VisibleString.elements; td->elements_count = asn1_DEF_VisibleString.elements_count; td->specifics = asn1_DEF_VisibleString.specifics; } +void +Identifier_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + Identifier_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +Identifier_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + Identifier_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t Identifier_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -2902,7 +3205,7 @@ Identifier_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t Identifier_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -2910,18 +3213,12 @@ Identifier_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -Identifier_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - Identifier_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -Identifier_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +Identifier_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { Identifier_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -2932,11 +3229,13 @@ static ber_tlv_tag_t asn1_DEF_Identifier_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_Identifier = { "Identifier", + Identifier_free, + Identifier_print, Identifier_constraint, Identifier_decode_ber, Identifier_encode_der, - Identifier_print, - Identifier_free, + 0, /* Not implemented yet */ + Identifier_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Identifier_tags, sizeof(asn1_DEF_Identifier_tags) diff --git a/tests/60-any-OK.asn1.-P b/tests/60-any-OK.asn1.-P index 62fd9b38..2da68af1 100644 --- a/tests/60-any-OK.asn1.-P +++ b/tests/60-any-OK.asn1.-P @@ -54,11 +54,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_T1_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T1 = { "T1", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T1_tags, sizeof(asn1_DEF_T1_tags) @@ -129,11 +131,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_T2_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_T2 = { "T2", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T2_tags, sizeof(asn1_DEF_T2_tags) diff --git a/tests/65-multi-tag-OK.asn1.-P b/tests/65-multi-tag-OK.asn1.-P index 51d2b088..3156ba75 100644 --- a/tests/65-multi-tag-OK.asn1.-P +++ b/tests/65-multi-tag-OK.asn1.-P @@ -11,11 +11,12 @@ typedef T2_t T1_t; /*** <<< FUNC-DECLS [T1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T1; +asn_struct_free_f T1_free; +asn_struct_print_f T1_print; asn_constr_check_f T1_constraint; ber_type_decoder_f T1_decode_ber; der_type_encoder_f T1_encode_der; -asn_struct_print_f T1_print; -asn_struct_free_f T1_free; +xer_type_encoder_f T1_encode_xer; /*** <<< CODE [T1] >>> ***/ @@ -35,16 +36,32 @@ T1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T2.ber_decoder; - td->der_encoder = asn1_DEF_T2.der_encoder; td->free_struct = asn1_DEF_T2.free_struct; td->print_struct = asn1_DEF_T2.print_struct; + td->ber_decoder = asn1_DEF_T2.ber_decoder; + td->der_encoder = asn1_DEF_T2.der_encoder; + td->xer_decoder = asn1_DEF_T2.xer_decoder; + td->xer_encoder = asn1_DEF_T2.xer_encoder; td->last_tag_form = asn1_DEF_T2.last_tag_form; td->elements = asn1_DEF_T2.elements; td->elements_count = asn1_DEF_T2.elements_count; td->specifics = asn1_DEF_T2.specifics; } +void +T1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -52,7 +69,7 @@ T1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -60,18 +77,12 @@ T1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -93,11 +104,13 @@ static ber_tlv_tag_t asn1_DEF_T1_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T1 = { "T1", + T1_free, + T1_print, T1_constraint, T1_decode_ber, T1_encode_der, - T1_print, - T1_free, + 0, /* Not implemented yet */ + T1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T1_tags, sizeof(asn1_DEF_T1_tags) @@ -123,11 +136,12 @@ typedef T3_t T2_t; /*** <<< FUNC-DECLS [T2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T2; +asn_struct_free_f T2_free; +asn_struct_print_f T2_print; asn_constr_check_f T2_constraint; ber_type_decoder_f T2_decode_ber; der_type_encoder_f T2_encode_der; -asn_struct_print_f T2_print; -asn_struct_free_f T2_free; +xer_type_encoder_f T2_encode_xer; /*** <<< CODE [T2] >>> ***/ @@ -147,16 +161,32 @@ T2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T3.ber_decoder; - td->der_encoder = asn1_DEF_T3.der_encoder; td->free_struct = asn1_DEF_T3.free_struct; td->print_struct = asn1_DEF_T3.print_struct; + td->ber_decoder = asn1_DEF_T3.ber_decoder; + td->der_encoder = asn1_DEF_T3.der_encoder; + td->xer_decoder = asn1_DEF_T3.xer_decoder; + td->xer_encoder = asn1_DEF_T3.xer_encoder; td->last_tag_form = asn1_DEF_T3.last_tag_form; td->elements = asn1_DEF_T3.elements; td->elements_count = asn1_DEF_T3.elements_count; td->specifics = asn1_DEF_T3.specifics; } +void +T2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -164,7 +194,7 @@ T2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -172,18 +202,12 @@ T2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -203,11 +227,13 @@ static ber_tlv_tag_t asn1_DEF_T2_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T2 = { "T2", + T2_free, + T2_print, T2_constraint, T2_decode_ber, T2_encode_der, - T2_print, - T2_free, + 0, /* Not implemented yet */ + T2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T2_tags, sizeof(asn1_DEF_T2_tags) @@ -233,11 +259,12 @@ typedef T4_t T3_t; /*** <<< FUNC-DECLS [T3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T3; +asn_struct_free_f T3_free; +asn_struct_print_f T3_print; asn_constr_check_f T3_constraint; ber_type_decoder_f T3_decode_ber; der_type_encoder_f T3_encode_der; -asn_struct_print_f T3_print; -asn_struct_free_f T3_free; +xer_type_encoder_f T3_encode_xer; /*** <<< CODE [T3] >>> ***/ @@ -257,16 +284,32 @@ T3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T4.ber_decoder; - td->der_encoder = asn1_DEF_T4.der_encoder; td->free_struct = asn1_DEF_T4.free_struct; td->print_struct = asn1_DEF_T4.print_struct; + td->ber_decoder = asn1_DEF_T4.ber_decoder; + td->der_encoder = asn1_DEF_T4.der_encoder; + td->xer_decoder = asn1_DEF_T4.xer_decoder; + td->xer_encoder = asn1_DEF_T4.xer_encoder; td->last_tag_form = asn1_DEF_T4.last_tag_form; td->elements = asn1_DEF_T4.elements; td->elements_count = asn1_DEF_T4.elements_count; td->specifics = asn1_DEF_T4.specifics; } +void +T3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -274,7 +317,7 @@ T3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -282,18 +325,12 @@ T3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -311,11 +348,13 @@ static ber_tlv_tag_t asn1_DEF_T3_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T3 = { "T3", + T3_free, + T3_print, T3_constraint, T3_decode_ber, T3_encode_der, - T3_print, - T3_free, + 0, /* Not implemented yet */ + T3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T3_tags, sizeof(asn1_DEF_T3_tags) @@ -341,11 +380,12 @@ typedef T5_t T4_t; /*** <<< FUNC-DECLS [T4] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T4; +asn_struct_free_f T4_free; +asn_struct_print_f T4_print; asn_constr_check_f T4_constraint; ber_type_decoder_f T4_decode_ber; der_type_encoder_f T4_encode_der; -asn_struct_print_f T4_print; -asn_struct_free_f T4_free; +xer_type_encoder_f T4_encode_xer; /*** <<< CODE [T4] >>> ***/ @@ -365,16 +405,32 @@ T4_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T4_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T5.ber_decoder; - td->der_encoder = asn1_DEF_T5.der_encoder; td->free_struct = asn1_DEF_T5.free_struct; td->print_struct = asn1_DEF_T5.print_struct; + td->ber_decoder = asn1_DEF_T5.ber_decoder; + td->der_encoder = asn1_DEF_T5.der_encoder; + td->xer_decoder = asn1_DEF_T5.xer_decoder; + td->xer_encoder = asn1_DEF_T5.xer_encoder; td->last_tag_form = asn1_DEF_T5.last_tag_form; td->elements = asn1_DEF_T5.elements; td->elements_count = asn1_DEF_T5.elements_count; td->specifics = asn1_DEF_T5.specifics; } +void +T4_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T4_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T4_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T4_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -382,7 +438,7 @@ T4_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T4_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -390,18 +446,12 @@ T4_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T4_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T4_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T4_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T4_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -414,11 +464,13 @@ static ber_tlv_tag_t asn1_DEF_T4_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T4 = { "T4", + T4_free, + T4_print, T4_constraint, T4_decode_ber, T4_encode_der, - T4_print, - T4_free, + 0, /* Not implemented yet */ + T4_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T4_tags, sizeof(asn1_DEF_T4_tags) @@ -444,11 +496,12 @@ typedef T6_t T5_t; /*** <<< FUNC-DECLS [T5] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T5; +asn_struct_free_f T5_free; +asn_struct_print_f T5_print; asn_constr_check_f T5_constraint; ber_type_decoder_f T5_decode_ber; der_type_encoder_f T5_encode_der; -asn_struct_print_f T5_print; -asn_struct_free_f T5_free; +xer_type_encoder_f T5_encode_xer; /*** <<< CODE [T5] >>> ***/ @@ -468,16 +521,32 @@ T5_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T5_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T6.ber_decoder; - td->der_encoder = asn1_DEF_T6.der_encoder; td->free_struct = asn1_DEF_T6.free_struct; td->print_struct = asn1_DEF_T6.print_struct; + td->ber_decoder = asn1_DEF_T6.ber_decoder; + td->der_encoder = asn1_DEF_T6.der_encoder; + td->xer_decoder = asn1_DEF_T6.xer_decoder; + td->xer_encoder = asn1_DEF_T6.xer_encoder; td->last_tag_form = asn1_DEF_T6.last_tag_form; td->elements = asn1_DEF_T6.elements; td->elements_count = asn1_DEF_T6.elements_count; td->specifics = asn1_DEF_T6.specifics; } +void +T5_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T5_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T5_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T5_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -485,7 +554,7 @@ T5_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T5_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -493,18 +562,12 @@ T5_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T5_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T5_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T5_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T5_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -516,11 +579,13 @@ static ber_tlv_tag_t asn1_DEF_T5_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T5 = { "T5", + T5_free, + T5_print, T5_constraint, T5_decode_ber, T5_encode_der, - T5_print, - T5_free, + 0, /* Not implemented yet */ + T5_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T5_tags, sizeof(asn1_DEF_T5_tags) @@ -546,11 +611,12 @@ typedef REAL_t T6_t; /*** <<< FUNC-DECLS [T6] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T6; +asn_struct_free_f T6_free; +asn_struct_print_f T6_print; asn_constr_check_f T6_constraint; ber_type_decoder_f T6_decode_ber; der_type_encoder_f T6_encode_der; -asn_struct_print_f T6_print; -asn_struct_free_f T6_free; +xer_type_encoder_f T6_encode_xer; /*** <<< CODE [T6] >>> ***/ @@ -570,16 +636,32 @@ T6_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T6_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_REAL.ber_decoder; - td->der_encoder = asn1_DEF_REAL.der_encoder; td->free_struct = asn1_DEF_REAL.free_struct; td->print_struct = asn1_DEF_REAL.print_struct; + td->ber_decoder = asn1_DEF_REAL.ber_decoder; + td->der_encoder = asn1_DEF_REAL.der_encoder; + td->xer_decoder = asn1_DEF_REAL.xer_decoder; + td->xer_encoder = asn1_DEF_REAL.xer_encoder; td->last_tag_form = asn1_DEF_REAL.last_tag_form; td->elements = asn1_DEF_REAL.elements; td->elements_count = asn1_DEF_REAL.elements_count; td->specifics = asn1_DEF_REAL.specifics; } +void +T6_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T6_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T6_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T6_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T6_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -587,7 +669,7 @@ T6_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T6_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -595,18 +677,12 @@ T6_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T6_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T6_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T6_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T6_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T6_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -617,11 +693,13 @@ static ber_tlv_tag_t asn1_DEF_T6_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T6 = { "T6", + T6_free, + T6_print, T6_constraint, T6_decode_ber, T6_encode_der, - T6_print, - T6_free, + 0, /* Not implemented yet */ + T6_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T6_tags, sizeof(asn1_DEF_T6_tags) @@ -647,11 +725,12 @@ typedef Ts_t T_t; /*** <<< FUNC-DECLS [T] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T; +asn_struct_free_f T_free; +asn_struct_print_f T_print; asn_constr_check_f T_constraint; ber_type_decoder_f T_decode_ber; der_type_encoder_f T_encode_der; -asn_struct_print_f T_print; -asn_struct_free_f T_free; +xer_type_encoder_f T_encode_xer; /*** <<< CODE [T] >>> ***/ @@ -671,16 +750,32 @@ T_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Ts.ber_decoder; - td->der_encoder = asn1_DEF_Ts.der_encoder; td->free_struct = asn1_DEF_Ts.free_struct; td->print_struct = asn1_DEF_Ts.print_struct; + td->ber_decoder = asn1_DEF_Ts.ber_decoder; + td->der_encoder = asn1_DEF_Ts.der_encoder; + td->xer_decoder = asn1_DEF_Ts.xer_decoder; + td->xer_encoder = asn1_DEF_Ts.xer_encoder; td->last_tag_form = asn1_DEF_Ts.last_tag_form; td->elements = asn1_DEF_Ts.elements; td->elements_count = asn1_DEF_Ts.elements_count; td->specifics = asn1_DEF_Ts.specifics; } +void +T_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -688,7 +783,7 @@ T_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -696,18 +791,12 @@ T_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -720,11 +809,13 @@ static ber_tlv_tag_t asn1_DEF_T_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + T_free, + T_print, T_constraint, T_decode_ber, T_encode_der, - T_print, - T_free, + 0, /* Not implemented yet */ + T_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) @@ -804,11 +895,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_Ts_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Ts = { "Ts", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Ts_tags, sizeof(asn1_DEF_Ts_tags) diff --git a/tests/65-multi-tag-OK.asn1.-Pfnative-types b/tests/65-multi-tag-OK.asn1.-Pfnative-types index 88535bde..d26bfaf5 100644 --- a/tests/65-multi-tag-OK.asn1.-Pfnative-types +++ b/tests/65-multi-tag-OK.asn1.-Pfnative-types @@ -11,11 +11,12 @@ typedef T2_t T1_t; /*** <<< FUNC-DECLS [T1] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T1; +asn_struct_free_f T1_free; +asn_struct_print_f T1_print; asn_constr_check_f T1_constraint; ber_type_decoder_f T1_decode_ber; der_type_encoder_f T1_encode_der; -asn_struct_print_f T1_print; -asn_struct_free_f T1_free; +xer_type_encoder_f T1_encode_xer; /*** <<< CODE [T1] >>> ***/ @@ -35,16 +36,32 @@ T1_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T1_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T2.ber_decoder; - td->der_encoder = asn1_DEF_T2.der_encoder; td->free_struct = asn1_DEF_T2.free_struct; td->print_struct = asn1_DEF_T2.print_struct; + td->ber_decoder = asn1_DEF_T2.ber_decoder; + td->der_encoder = asn1_DEF_T2.der_encoder; + td->xer_decoder = asn1_DEF_T2.xer_decoder; + td->xer_encoder = asn1_DEF_T2.xer_encoder; td->last_tag_form = asn1_DEF_T2.last_tag_form; td->elements = asn1_DEF_T2.elements; td->elements_count = asn1_DEF_T2.elements_count; td->specifics = asn1_DEF_T2.specifics; } +void +T1_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T1_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T1_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T1_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -52,7 +69,7 @@ T1_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T1_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -60,18 +77,12 @@ T1_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T1_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T1_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T1_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T1_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T1_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -93,11 +104,13 @@ static ber_tlv_tag_t asn1_DEF_T1_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T1 = { "T1", + T1_free, + T1_print, T1_constraint, T1_decode_ber, T1_encode_der, - T1_print, - T1_free, + 0, /* Not implemented yet */ + T1_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T1_tags, sizeof(asn1_DEF_T1_tags) @@ -123,11 +136,12 @@ typedef T3_t T2_t; /*** <<< FUNC-DECLS [T2] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T2; +asn_struct_free_f T2_free; +asn_struct_print_f T2_print; asn_constr_check_f T2_constraint; ber_type_decoder_f T2_decode_ber; der_type_encoder_f T2_encode_der; -asn_struct_print_f T2_print; -asn_struct_free_f T2_free; +xer_type_encoder_f T2_encode_xer; /*** <<< CODE [T2] >>> ***/ @@ -147,16 +161,32 @@ T2_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T2_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T3.ber_decoder; - td->der_encoder = asn1_DEF_T3.der_encoder; td->free_struct = asn1_DEF_T3.free_struct; td->print_struct = asn1_DEF_T3.print_struct; + td->ber_decoder = asn1_DEF_T3.ber_decoder; + td->der_encoder = asn1_DEF_T3.der_encoder; + td->xer_decoder = asn1_DEF_T3.xer_decoder; + td->xer_encoder = asn1_DEF_T3.xer_encoder; td->last_tag_form = asn1_DEF_T3.last_tag_form; td->elements = asn1_DEF_T3.elements; td->elements_count = asn1_DEF_T3.elements_count; td->specifics = asn1_DEF_T3.specifics; } +void +T2_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T2_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T2_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T2_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -164,7 +194,7 @@ T2_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T2_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -172,18 +202,12 @@ T2_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T2_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T2_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T2_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T2_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T2_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -203,11 +227,13 @@ static ber_tlv_tag_t asn1_DEF_T2_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T2 = { "T2", + T2_free, + T2_print, T2_constraint, T2_decode_ber, T2_encode_der, - T2_print, - T2_free, + 0, /* Not implemented yet */ + T2_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T2_tags, sizeof(asn1_DEF_T2_tags) @@ -233,11 +259,12 @@ typedef T4_t T3_t; /*** <<< FUNC-DECLS [T3] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T3; +asn_struct_free_f T3_free; +asn_struct_print_f T3_print; asn_constr_check_f T3_constraint; ber_type_decoder_f T3_decode_ber; der_type_encoder_f T3_encode_der; -asn_struct_print_f T3_print; -asn_struct_free_f T3_free; +xer_type_encoder_f T3_encode_xer; /*** <<< CODE [T3] >>> ***/ @@ -257,16 +284,32 @@ T3_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T3_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T4.ber_decoder; - td->der_encoder = asn1_DEF_T4.der_encoder; td->free_struct = asn1_DEF_T4.free_struct; td->print_struct = asn1_DEF_T4.print_struct; + td->ber_decoder = asn1_DEF_T4.ber_decoder; + td->der_encoder = asn1_DEF_T4.der_encoder; + td->xer_decoder = asn1_DEF_T4.xer_decoder; + td->xer_encoder = asn1_DEF_T4.xer_encoder; td->last_tag_form = asn1_DEF_T4.last_tag_form; td->elements = asn1_DEF_T4.elements; td->elements_count = asn1_DEF_T4.elements_count; td->specifics = asn1_DEF_T4.specifics; } +void +T3_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T3_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T3_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T3_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -274,7 +317,7 @@ T3_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T3_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -282,18 +325,12 @@ T3_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T3_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T3_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T3_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T3_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T3_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -311,11 +348,13 @@ static ber_tlv_tag_t asn1_DEF_T3_all_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T3 = { "T3", + T3_free, + T3_print, T3_constraint, T3_decode_ber, T3_encode_der, - T3_print, - T3_free, + 0, /* Not implemented yet */ + T3_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T3_tags, sizeof(asn1_DEF_T3_tags) @@ -341,11 +380,12 @@ typedef T5_t T4_t; /*** <<< FUNC-DECLS [T4] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T4; +asn_struct_free_f T4_free; +asn_struct_print_f T4_print; asn_constr_check_f T4_constraint; ber_type_decoder_f T4_decode_ber; der_type_encoder_f T4_encode_der; -asn_struct_print_f T4_print; -asn_struct_free_f T4_free; +xer_type_encoder_f T4_encode_xer; /*** <<< CODE [T4] >>> ***/ @@ -365,16 +405,32 @@ T4_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T4_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T5.ber_decoder; - td->der_encoder = asn1_DEF_T5.der_encoder; td->free_struct = asn1_DEF_T5.free_struct; td->print_struct = asn1_DEF_T5.print_struct; + td->ber_decoder = asn1_DEF_T5.ber_decoder; + td->der_encoder = asn1_DEF_T5.der_encoder; + td->xer_decoder = asn1_DEF_T5.xer_decoder; + td->xer_encoder = asn1_DEF_T5.xer_encoder; td->last_tag_form = asn1_DEF_T5.last_tag_form; td->elements = asn1_DEF_T5.elements; td->elements_count = asn1_DEF_T5.elements_count; td->specifics = asn1_DEF_T5.specifics; } +void +T4_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T4_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T4_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T4_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -382,7 +438,7 @@ T4_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T4_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -390,18 +446,12 @@ T4_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T4_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T4_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T4_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T4_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T4_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -414,11 +464,13 @@ static ber_tlv_tag_t asn1_DEF_T4_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T4 = { "T4", + T4_free, + T4_print, T4_constraint, T4_decode_ber, T4_encode_der, - T4_print, - T4_free, + 0, /* Not implemented yet */ + T4_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T4_tags, sizeof(asn1_DEF_T4_tags) @@ -444,11 +496,12 @@ typedef T6_t T5_t; /*** <<< FUNC-DECLS [T5] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T5; +asn_struct_free_f T5_free; +asn_struct_print_f T5_print; asn_constr_check_f T5_constraint; ber_type_decoder_f T5_decode_ber; der_type_encoder_f T5_encode_der; -asn_struct_print_f T5_print; -asn_struct_free_f T5_free; +xer_type_encoder_f T5_encode_xer; /*** <<< CODE [T5] >>> ***/ @@ -468,16 +521,32 @@ T5_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T5_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_T6.ber_decoder; - td->der_encoder = asn1_DEF_T6.der_encoder; td->free_struct = asn1_DEF_T6.free_struct; td->print_struct = asn1_DEF_T6.print_struct; + td->ber_decoder = asn1_DEF_T6.ber_decoder; + td->der_encoder = asn1_DEF_T6.der_encoder; + td->xer_decoder = asn1_DEF_T6.xer_decoder; + td->xer_encoder = asn1_DEF_T6.xer_encoder; td->last_tag_form = asn1_DEF_T6.last_tag_form; td->elements = asn1_DEF_T6.elements; td->elements_count = asn1_DEF_T6.elements_count; td->specifics = asn1_DEF_T6.specifics; } +void +T5_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T5_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T5_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T5_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -485,7 +554,7 @@ T5_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T5_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -493,18 +562,12 @@ T5_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T5_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T5_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T5_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T5_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T5_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -516,11 +579,13 @@ static ber_tlv_tag_t asn1_DEF_T5_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T5 = { "T5", + T5_free, + T5_print, T5_constraint, T5_decode_ber, T5_encode_der, - T5_print, - T5_free, + 0, /* Not implemented yet */ + T5_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T5_tags, sizeof(asn1_DEF_T5_tags) @@ -546,11 +611,12 @@ typedef double T6_t; /*** <<< FUNC-DECLS [T6] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T6; +asn_struct_free_f T6_free; +asn_struct_print_f T6_print; asn_constr_check_f T6_constraint; ber_type_decoder_f T6_decode_ber; der_type_encoder_f T6_encode_der; -asn_struct_print_f T6_print; -asn_struct_free_f T6_free; +xer_type_encoder_f T6_encode_xer; /*** <<< CODE [T6] >>> ***/ @@ -570,16 +636,32 @@ T6_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T6_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_NativeReal.ber_decoder; - td->der_encoder = asn1_DEF_NativeReal.der_encoder; td->free_struct = asn1_DEF_NativeReal.free_struct; td->print_struct = asn1_DEF_NativeReal.print_struct; + td->ber_decoder = asn1_DEF_NativeReal.ber_decoder; + td->der_encoder = asn1_DEF_NativeReal.der_encoder; + td->xer_decoder = asn1_DEF_NativeReal.xer_decoder; + td->xer_encoder = asn1_DEF_NativeReal.xer_encoder; td->last_tag_form = asn1_DEF_NativeReal.last_tag_form; td->elements = asn1_DEF_NativeReal.elements; td->elements_count = asn1_DEF_NativeReal.elements_count; td->specifics = asn1_DEF_NativeReal.specifics; } +void +T6_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T6_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T6_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T6_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T6_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -587,7 +669,7 @@ T6_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T6_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -595,18 +677,12 @@ T6_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T6_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T6_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T6_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T6_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T6_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -617,11 +693,13 @@ static ber_tlv_tag_t asn1_DEF_T6_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T6 = { "T6", + T6_free, + T6_print, T6_constraint, T6_decode_ber, T6_encode_der, - T6_print, - T6_free, + 0, /* Not implemented yet */ + T6_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T6_tags, sizeof(asn1_DEF_T6_tags) @@ -647,11 +725,12 @@ typedef Ts_t T_t; /*** <<< FUNC-DECLS [T] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_T; +asn_struct_free_f T_free; +asn_struct_print_f T_print; asn_constr_check_f T_constraint; ber_type_decoder_f T_decode_ber; der_type_encoder_f T_encode_der; -asn_struct_print_f T_print; -asn_struct_free_f T_free; +xer_type_encoder_f T_encode_xer; /*** <<< CODE [T] >>> ***/ @@ -671,16 +750,32 @@ T_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void T_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_Ts.ber_decoder; - td->der_encoder = asn1_DEF_Ts.der_encoder; td->free_struct = asn1_DEF_Ts.free_struct; td->print_struct = asn1_DEF_Ts.print_struct; + td->ber_decoder = asn1_DEF_Ts.ber_decoder; + td->der_encoder = asn1_DEF_Ts.der_encoder; + td->xer_decoder = asn1_DEF_Ts.xer_decoder; + td->xer_encoder = asn1_DEF_Ts.xer_encoder; td->last_tag_form = asn1_DEF_Ts.last_tag_form; td->elements = asn1_DEF_Ts.elements; td->elements_count = asn1_DEF_Ts.elements_count; td->specifics = asn1_DEF_Ts.specifics; } +void +T_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + T_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + T_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t T_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -688,7 +783,7 @@ T_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t T_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -696,18 +791,12 @@ T_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -T_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - T_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -T_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +T_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { T_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -720,11 +809,13 @@ static ber_tlv_tag_t asn1_DEF_T_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + T_free, + T_print, T_constraint, T_decode_ber, T_encode_der, - T_print, - T_free, + 0, /* Not implemented yet */ + T_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) @@ -804,11 +895,13 @@ static asn1_SEQUENCE_specifics_t asn1_DEF_Ts_specs = { }; asn1_TYPE_descriptor_t asn1_DEF_Ts = { "Ts", + SEQUENCE_free, + SEQUENCE_print, SEQUENCE_constraint, SEQUENCE_decode_ber, SEQUENCE_encode_der, - SEQUENCE_print, - SEQUENCE_free, + 0, /* Not implemented yet */ + SEQUENCE_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_Ts_tags, sizeof(asn1_DEF_Ts_tags) diff --git a/tests/66-ref-simple-OK.asn1 b/tests/66-ref-simple-OK.asn1 index 7b19c705..38254a9f 100644 --- a/tests/66-ref-simple-OK.asn1 +++ b/tests/66-ref-simple-OK.asn1 @@ -5,13 +5,13 @@ -- .spelio.software.asn1c.test (9363.1.5.1) -- .66 -ModuleTestReferenceToSimpleType +ModuleTestReferenceToNamedSimpleType { iso org(3) dod(6) internet(1) private(4) enterprise(1) spelio(9363) software(1) asn1c(5) test(1) 66 } DEFINITIONS IMPLICIT TAGS ::= BEGIN - T ::= SET OF SimpleType + T ::= SET OF named SimpleType SimpleType ::= ENUMERATED { one, two, three } diff --git a/tests/66-ref-simple-OK.asn1.-P b/tests/66-ref-simple-OK.asn1.-P index 8a3466de..0ae62e3c 100644 --- a/tests/66-ref-simple-OK.asn1.-P +++ b/tests/66-ref-simple-OK.asn1.-P @@ -36,14 +36,17 @@ static ber_tlv_tag_t asn1_DEF_T_tags[] = { static asn1_SET_OF_specifics_t asn1_DEF_T_specs = { sizeof(struct T), offsetof(struct T, _ber_dec_ctx), + 1, /* XER encoding is XMLValueList */ }; asn1_TYPE_descriptor_t asn1_DEF_T = { "T", + SET_OF_free, + SET_OF_print, SET_OF_constraint, SET_OF_decode_ber, SET_OF_encode_der, - SET_OF_print, - SET_OF_free, + 0, /* Not implemented yet */ + SET_OF_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_T_tags, sizeof(asn1_DEF_T_tags) @@ -78,11 +81,12 @@ typedef ENUMERATED_t SimpleType_t; /*** <<< FUNC-DECLS [SimpleType] >>> ***/ extern asn1_TYPE_descriptor_t asn1_DEF_SimpleType; +asn_struct_free_f SimpleType_free; +asn_struct_print_f SimpleType_print; asn_constr_check_f SimpleType_constraint; ber_type_decoder_f SimpleType_decode_ber; der_type_encoder_f SimpleType_encode_der; -asn_struct_print_f SimpleType_print; -asn_struct_free_f SimpleType_free; +xer_type_encoder_f SimpleType_encode_xer; /*** <<< CODE [SimpleType] >>> ***/ @@ -102,16 +106,32 @@ SimpleType_constraint(asn1_TYPE_descriptor_t *td, const void *sptr, */ static void SimpleType_inherit_TYPE_descriptor(asn1_TYPE_descriptor_t *td) { - td->ber_decoder = asn1_DEF_ENUMERATED.ber_decoder; - td->der_encoder = asn1_DEF_ENUMERATED.der_encoder; td->free_struct = asn1_DEF_ENUMERATED.free_struct; td->print_struct = asn1_DEF_ENUMERATED.print_struct; + td->ber_decoder = asn1_DEF_ENUMERATED.ber_decoder; + td->der_encoder = asn1_DEF_ENUMERATED.der_encoder; + td->xer_decoder = asn1_DEF_ENUMERATED.xer_decoder; + td->xer_encoder = asn1_DEF_ENUMERATED.xer_encoder; td->last_tag_form = asn1_DEF_ENUMERATED.last_tag_form; td->elements = asn1_DEF_ENUMERATED.elements; td->elements_count = asn1_DEF_ENUMERATED.elements_count; td->specifics = asn1_DEF_ENUMERATED.specifics; } +void +SimpleType_free(asn1_TYPE_descriptor_t *td, + void *struct_ptr, int contents_only) { + SimpleType_inherit_TYPE_descriptor(td); + td->free_struct(td, struct_ptr, contents_only); +} + +int +SimpleType_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, + int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { + SimpleType_inherit_TYPE_descriptor(td); + return td->print_struct(td, struct_ptr, ilevel, cb, app_key); +} + ber_dec_rval_t SimpleType_decode_ber(asn1_TYPE_descriptor_t *td, void **structure, void *bufptr, size_t size, int tag_mode) { @@ -119,7 +139,7 @@ SimpleType_decode_ber(asn1_TYPE_descriptor_t *td, return td->ber_decoder(td, structure, bufptr, size, tag_mode); } -der_enc_rval_t +asn_enc_rval_t SimpleType_encode_der(asn1_TYPE_descriptor_t *td, void *structure, int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) { @@ -127,18 +147,12 @@ SimpleType_encode_der(asn1_TYPE_descriptor_t *td, return td->der_encoder(td, structure, tag_mode, tag, cb, app_key); } -int -SimpleType_print(asn1_TYPE_descriptor_t *td, const void *struct_ptr, - int ilevel, asn_app_consume_bytes_f *cb, void *app_key) { - SimpleType_inherit_TYPE_descriptor(td); - return td->print_struct(td, struct_ptr, ilevel, cb, app_key); -} - -void -SimpleType_free(asn1_TYPE_descriptor_t *td, - void *struct_ptr, int contents_only) { +asn_enc_rval_t +SimpleType_encode_xer(asn1_TYPE_descriptor_t *td, void *structure, + int ilevel, enum xer_encoder_flags_e flags, + asn_app_consume_bytes_f *cb, void *app_key) { SimpleType_inherit_TYPE_descriptor(td); - td->free_struct(td, struct_ptr, contents_only); + return td->xer_encoder(td, structure, ilevel, flags, cb, app_key); } @@ -149,11 +163,13 @@ static ber_tlv_tag_t asn1_DEF_SimpleType_tags[] = { }; asn1_TYPE_descriptor_t asn1_DEF_SimpleType = { "SimpleType", + SimpleType_free, + SimpleType_print, SimpleType_constraint, SimpleType_decode_ber, SimpleType_encode_der, - SimpleType_print, - SimpleType_free, + 0, /* Not implemented yet */ + SimpleType_encode_xer, 0, /* Use generic outmost tag fetcher */ asn1_DEF_SimpleType_tags, sizeof(asn1_DEF_SimpleType_tags) |