--- /dev/null
+/*-\r
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.\r
+ * Redistribution and modifications are permitted subject to BSD license.\r
+ */\r
+#include <asn_internal.h>\r
+#include <asn_codecs_prim.h>\r
+#include <BOOLEAN.h>\r
+\r
+/*\r
+ * BOOLEAN basic type description.\r
+ */\r
+static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {\r
+ (ASN_TAG_CLASS_UNIVERSAL | (1 << 2))\r
+};\r
+asn_TYPE_operation_t asn_OP_BOOLEAN = {\r
+ BOOLEAN_free,\r
+ BOOLEAN_print,\r
+ BOOLEAN_compare,\r
+ BOOLEAN_decode_ber,\r
+ BOOLEAN_encode_der,\r
+ BOOLEAN_decode_xer,\r
+ BOOLEAN_encode_xer,\r
+#ifdef ASN_DISABLE_OER_SUPPORT\r
+ 0,\r
+ 0,\r
+#else\r
+ BOOLEAN_decode_oer,\r
+ BOOLEAN_encode_oer,\r
+#endif /* ASN_DISABLE_OER_SUPPORT */\r
+#ifdef ASN_DISABLE_PER_SUPPORT\r
+ 0,\r
+ 0,\r
+ 0,\r
+ 0,\r
+#else\r
+ BOOLEAN_decode_uper, /* Unaligned PER decoder */\r
+ BOOLEAN_encode_uper, /* Unaligned PER encoder */\r
+ BOOLEAN_decode_aper, /* Aligned PER decoder */\r
+ BOOLEAN_encode_aper, /* Aligned PER encoder */\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+ BOOLEAN_random_fill,\r
+ 0 /* Use generic outmost tag fetcher */\r
+};\r
+asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {\r
+ "BOOLEAN",\r
+ "BOOLEAN",\r
+ &asn_OP_BOOLEAN,\r
+ asn_DEF_BOOLEAN_tags,\r
+ sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),\r
+ asn_DEF_BOOLEAN_tags, /* Same as above */\r
+ sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),\r
+ { 0, 0, asn_generic_no_constraint },\r
+ 0, 0, /* No members */\r
+ 0 /* No specifics */\r
+};\r
+\r
+/*\r
+ * Decode BOOLEAN type.\r
+ */\r
+asn_dec_rval_t\r
+BOOLEAN_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **bool_value,\r
+ const void *buf_ptr, size_t size, int tag_mode) {\r
+ BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;\r
+ asn_dec_rval_t rval;\r
+ ber_tlv_len_t length;\r
+ ber_tlv_len_t lidx;\r
+\r
+ if(st == NULL) {\r
+ st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));\r
+ if(st == NULL) {\r
+ rval.code = RC_FAIL;\r
+ rval.consumed = 0;\r
+ return rval;\r
+ }\r
+ }\r
+\r
+ ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",\r
+ td->name, tag_mode);\r
+\r
+ /*\r
+ * Check tags.\r
+ */\r
+ rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,\r
+ tag_mode, 0, &length, 0);\r
+ if(rval.code != RC_OK)\r
+ return rval;\r
+\r
+ ASN_DEBUG("Boolean length is %d bytes", (int)length);\r
+\r
+ buf_ptr = ((const char *)buf_ptr) + rval.consumed;\r
+ size -= rval.consumed;\r
+ if(length > (ber_tlv_len_t)size) {\r
+ rval.code = RC_WMORE;\r
+ rval.consumed = 0;\r
+ return rval;\r
+ }\r
+\r
+ /*\r
+ * Compute boolean value.\r
+ */\r
+ for(*st = 0, lidx = 0;\r
+ (lidx < length) && *st == 0; lidx++) {\r
+ /*\r
+ * Very simple approach: read bytes until the end or\r
+ * value is already TRUE.\r
+ * BOOLEAN is not supposed to contain meaningful data anyway.\r
+ */\r
+ *st |= ((const uint8_t *)buf_ptr)[lidx];\r
+ }\r
+\r
+ rval.code = RC_OK;\r
+ rval.consumed += length;\r
+\r
+ ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",\r
+ (long)rval.consumed, (long)length,\r
+ td->name, *st);\r
+ \r
+ return rval;\r
+}\r
+\r
+asn_enc_rval_t\r
+BOOLEAN_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,\r
+ void *app_key) {\r
+ asn_enc_rval_t erval = {0,0,0};\r
+ const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
+\r
+ erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);\r
+ if(erval.encoded == -1) {\r
+ erval.failed_type = td;\r
+ erval.structure_ptr = sptr;\r
+ return erval;\r
+ }\r
+\r
+ if(cb) {\r
+ uint8_t bool_value;\r
+\r
+ bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */\r
+\r
+ if(cb(&bool_value, 1, app_key) < 0) {\r
+ erval.encoded = -1;\r
+ erval.failed_type = td;\r
+ erval.structure_ptr = sptr;\r
+ return erval;\r
+ }\r
+ }\r
+\r
+ erval.encoded += 1;\r
+\r
+ ASN__ENCODED_OK(erval);\r
+}\r
+\r
+\r
+/*\r
+ * Decode the chunk of XML text encoding INTEGER.\r
+ */\r
+static enum xer_pbd_rval\r
+BOOLEAN__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,\r
+ const void *chunk_buf, size_t chunk_size) {\r
+ BOOLEAN_t *st = (BOOLEAN_t *)sptr;\r
+ const char *p = (const char *)chunk_buf;\r
+\r
+ (void)td;\r
+\r
+ if(chunk_size && p[0] == 0x3c /* '<' */) {\r
+ switch(xer_check_tag(chunk_buf, chunk_size, "false")) {\r
+ case XCT_BOTH:\r
+ /* "<false/>" */\r
+ *st = 0;\r
+ break;\r
+ case XCT_UNKNOWN_BO:\r
+ if(xer_check_tag(chunk_buf, chunk_size, "true")\r
+ != XCT_BOTH)\r
+ return XPBD_BROKEN_ENCODING;\r
+ /* "<true/>" */\r
+ *st = 1; /* Or 0xff as in DER?.. */\r
+ break;\r
+ default:\r
+ return XPBD_BROKEN_ENCODING;\r
+ }\r
+ return XPBD_BODY_CONSUMED;\r
+ } else {\r
+ return XPBD_BROKEN_ENCODING;\r
+ }\r
+}\r
+\r
+\r
+asn_dec_rval_t\r
+BOOLEAN_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const char *opt_mname, const void *buf_ptr, size_t size) {\r
+ return xer_decode_primitive(opt_codec_ctx, td,\r
+ sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,\r
+ BOOLEAN__xer_body_decode);\r
+}\r
+\r
+asn_enc_rval_t\r
+BOOLEAN_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int ilevel, enum xer_encoder_flags_e flags,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
+ asn_enc_rval_t er = {0, 0, 0};\r
+\r
+ (void)ilevel;\r
+ (void)flags;\r
+\r
+ if(!st) ASN__ENCODE_FAILED;\r
+\r
+ if(*st) {\r
+ ASN__CALLBACK("<true/>", 7);\r
+ } else {\r
+ ASN__CALLBACK("<false/>", 8);\r
+ }\r
+\r
+ ASN__ENCODED_OK(er);\r
+cb_failed:\r
+ ASN__ENCODE_FAILED;\r
+}\r
+\r
+int\r
+BOOLEAN_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
+ const char *buf;\r
+ size_t buflen;\r
+\r
+ (void)td; /* Unused argument */\r
+ (void)ilevel; /* Unused argument */\r
+\r
+ if(st) {\r
+ if(*st) {\r
+ buf = "TRUE";\r
+ buflen = 4;\r
+ } else {\r
+ buf = "FALSE";\r
+ buflen = 5;\r
+ }\r
+ } else {\r
+ buf = "<absent>";\r
+ buflen = 8;\r
+ }\r
+\r
+ return (cb(buf, buflen, app_key) < 0) ? -1 : 0;\r
+}\r
+\r
+void\r
+BOOLEAN_free(const asn_TYPE_descriptor_t *td, void *ptr,\r
+ enum asn_struct_free_method method) {\r
+ if(td && ptr) {\r
+ switch(method) {\r
+ case ASFM_FREE_EVERYTHING:\r
+ FREEMEM(ptr);\r
+ break;\r
+ case ASFM_FREE_UNDERLYING:\r
+ break;\r
+ case ASFM_FREE_UNDERLYING_AND_RESET:\r
+ memset(ptr, 0, sizeof(BOOLEAN_t));\r
+ break;\r
+ }\r
+ }\r
+}\r
+\r
+#ifndef ASN_DISABLE_PER_SUPPORT\r
+\r
+asn_dec_rval_t\r
+BOOLEAN_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, void **sptr,\r
+ asn_per_data_t *pd) {\r
+ asn_dec_rval_t rv;\r
+ BOOLEAN_t *st = (BOOLEAN_t *)*sptr;\r
+\r
+ (void)opt_codec_ctx;\r
+ (void)td;\r
+ (void)constraints;\r
+\r
+ if(!st) {\r
+ st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));\r
+ if(!st) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ /*\r
+ * Extract a single bit\r
+ */\r
+ switch(per_get_few_bits(pd, 1)) {\r
+ case 1: *st = 1; break;\r
+ case 0: *st = 0; break;\r
+ case -1: default: ASN__DECODE_STARVED;\r
+ }\r
+\r
+ ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");\r
+\r
+ rv.code = RC_OK;\r
+ rv.consumed = 1;\r
+ return rv;\r
+}\r
+\r
+\r
+asn_enc_rval_t\r
+BOOLEAN_encode_uper(const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, const void *sptr,\r
+ asn_per_outp_t *po) {\r
+ const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
+ asn_enc_rval_t er = { 0, 0, 0 };\r
+\r
+ (void)constraints;\r
+\r
+ if(!st) ASN__ENCODE_FAILED;\r
+\r
+ if(per_put_few_bits(po, *st ? 1 : 0, 1))\r
+ ASN__ENCODE_FAILED;\r
+\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+asn_dec_rval_t\r
+BOOLEAN_decode_aper(const asn_codec_ctx_t *opt_codec_ctx, const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {\r
+ asn_dec_rval_t rv;\r
+ BOOLEAN_t *st = (BOOLEAN_t *)*sptr;\r
+\r
+ (void)opt_codec_ctx;\r
+ (void)constraints;\r
+ (void)td;\r
+\r
+ if(!st) {\r
+ st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));\r
+ if(!st) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ /*\r
+ * Extract a single bit\r
+ */\r
+ switch(per_get_few_bits(pd, 1)) {\r
+ case 1:\r
+ *st = 1;\r
+ break;\r
+ case 0:\r
+ *st = 0;\r
+ break;\r
+ case -1:\r
+ default:\r
+ ASN__DECODE_STARVED;\r
+ }\r
+\r
+ ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");\r
+\r
+ rv.code = RC_OK;\r
+ rv.consumed = 1;\r
+ return rv;\r
+}\r
+\r
+asn_enc_rval_t\r
+BOOLEAN_encode_aper(const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints,\r
+ const void *sptr, asn_per_outp_t *po) {\r
+ const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
+ asn_enc_rval_t er = { 0, 0, 0 };\r
+\r
+ (void)constraints;\r
+\r
+ if(!st) ASN__ENCODE_FAILED;\r
+\r
+ if(per_put_few_bits(po, *st ? 1 : 0, 1))\r
+ ASN__ENCODE_FAILED;\r
+\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+\r
+#ifndef ASN_DISABLE_OER_SUPPORT\r
+\r
+/*\r
+ * Encode as Canonical OER.\r
+ */\r
+asn_enc_rval_t\r
+BOOLEAN_encode_oer(const asn_TYPE_descriptor_t *td,\r
+ const asn_oer_constraints_t *constraints, const void *sptr,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ asn_enc_rval_t er = { 1, 0, 0 };\r
+ const BOOLEAN_t *st = sptr;\r
+ uint8_t bool_value = *st ? 0xff : 0; /* 0xff mandated by OER */\r
+\r
+ (void)td;\r
+ (void)constraints; /* Constraints are unused in OER */\r
+\r
+ if(cb(&bool_value, 1, app_key) < 0) {\r
+ ASN__ENCODE_FAILED;\r
+ } else {\r
+ ASN__ENCODED_OK(er);\r
+ }\r
+}\r
+\r
+asn_dec_rval_t\r
+BOOLEAN_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td,\r
+ const asn_oer_constraints_t *constraints, void **sptr,\r
+ const void *ptr, size_t size) {\r
+ asn_dec_rval_t ok = {RC_OK, 1};\r
+ BOOLEAN_t *st;\r
+\r
+ (void)opt_codec_ctx;\r
+ (void)td;\r
+ (void)constraints; /* Constraints are unused in OER */\r
+\r
+ if(size < 1) {\r
+ ASN__DECODE_STARVED;\r
+ }\r
+\r
+ if(!(st = *sptr)) {\r
+ st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));\r
+ if(!st) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ *st = *(const uint8_t *)ptr;\r
+\r
+ return ok;\r
+}\r
+\r
+\r
+\r
+#endif\r
+\r
+int\r
+BOOLEAN_compare(const asn_TYPE_descriptor_t *td, const void *aptr,\r
+ const void *bptr) {\r
+ const BOOLEAN_t *a = aptr;\r
+ const BOOLEAN_t *b = bptr;\r
+\r
+ (void)td;\r
+\r
+ if(a && b) {\r
+ if(!*a == !*b) { /* TRUE can be encoded by any non-zero byte. */\r
+ return 0;\r
+ } else if(!*a) {\r
+ return -1;\r
+ } else {\r
+ return 1;\r
+ }\r
+ } else if(!a) {\r
+ return -1;\r
+ } else {\r
+ return 1;\r
+ }\r
+}\r
+\r
+asn_random_fill_result_t\r
+BOOLEAN_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const asn_encoding_constraints_t *constraints,\r
+ size_t max_length) {\r
+ asn_random_fill_result_t result_ok = {ARFILL_OK, 1};\r
+ asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};\r
+ asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};\r
+ BOOLEAN_t *st = *sptr;\r
+\r
+ if(max_length == 0) return result_skipped;\r
+\r
+ if(st == NULL) {\r
+ st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));\r
+ if(st == NULL) {\r
+ return result_failed;\r
+ }\r
+ }\r
+\r
+ if(!constraints || !constraints->per_constraints)\r
+ constraints = &td->encoding_constraints;\r
+ if(constraints->per_constraints) {\r
+ const asn_per_constraint_t *pc = &constraints->per_constraints->value;\r
+ if(pc->flags & APC_CONSTRAINED) {\r
+ *st = asn_random_between(pc->lower_bound, pc->upper_bound);\r
+ return result_ok;\r
+ }\r
+ }\r
+\r
+ /* Simulate booleans that are sloppily set and biased. */\r
+ switch(asn_random_between(0, 7)) {\r
+ case 0:\r
+ case 1:\r
+ case 2:\r
+ *st = 0; break;\r
+ case 3: *st = -1; break;\r
+ case 4: *st = 1; break;\r
+ case 5: *st = INT_MIN; break;\r
+ case 6: *st = INT_MAX; break;\r
+ default:\r
+ *st = asn_random_between(INT_MIN, INT_MAX);\r
+ break;\r
+ }\r
+ return result_ok;\r
+}\r
Code Review / ric-app / kpimon.git / blobdiff