--- /dev/null
+/*-\r
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.\r
+ * All rights reserved.\r
+ * Redistribution and modifications are permitted subject to BSD license.\r
+ */\r
+/*\r
+ * Read the NativeInteger.h for the explanation wrt. differences between\r
+ * INTEGER and NativeInteger.\r
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this\r
+ * implementation deals with the standard (machine-specific) representation\r
+ * of them instead of using the platform-independent buffer.\r
+ */\r
+#include <asn_internal.h>\r
+#include <NativeInteger.h>\r
+\r
+/*\r
+ * NativeInteger basic type description.\r
+ */\r
+static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {\r
+ (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))\r
+};\r
+asn_TYPE_operation_t asn_OP_NativeInteger = {\r
+ NativeInteger_free,\r
+ NativeInteger_print,\r
+ NativeInteger_compare,\r
+ NativeInteger_decode_ber,\r
+ NativeInteger_encode_der,\r
+ NativeInteger_decode_xer,\r
+ NativeInteger_encode_xer,\r
+#ifdef ASN_DISABLE_OER_SUPPORT\r
+ 0,\r
+ 0,\r
+#else\r
+ NativeInteger_decode_oer, /* OER decoder */\r
+ NativeInteger_encode_oer, /* Canonical OER encoder */\r
+#endif /* ASN_DISABLE_OER_SUPPORT */\r
+#ifdef ASN_DISABLE_PER_SUPPORT\r
+ 0,\r
+ 0,\r
+ 0,\r
+ 0,\r
+#else\r
+ NativeInteger_decode_uper, /* Unaligned PER decoder */\r
+ NativeInteger_encode_uper, /* Unaligned PER encoder */\r
+ NativeInteger_decode_aper, /* Aligned PER decoder */\r
+ NativeInteger_encode_aper, /* Aligned PER encoder */\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+ NativeInteger_random_fill,\r
+ 0 /* Use generic outmost tag fetcher */\r
+};\r
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {\r
+ "INTEGER", /* The ASN.1 type is still INTEGER */\r
+ "INTEGER",\r
+ &asn_OP_NativeInteger,\r
+ asn_DEF_NativeInteger_tags,\r
+ sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),\r
+ asn_DEF_NativeInteger_tags, /* Same as above */\r
+ sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),\r
+ { 0, 0, asn_generic_no_constraint },\r
+ 0, 0, /* No members */\r
+ 0 /* No specifics */\r
+};\r
+\r
+/*\r
+ * Decode INTEGER type.\r
+ */\r
+asn_dec_rval_t\r
+NativeInteger_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td, void **nint_ptr,\r
+ const void *buf_ptr, size_t size, int tag_mode) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ long *native = (long *)*nint_ptr;\r
+ asn_dec_rval_t rval;\r
+ ber_tlv_len_t length;\r
+\r
+ /*\r
+ * If the structure is not there, allocate it.\r
+ */\r
+ if(native == NULL) {\r
+ native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));\r
+ if(native == NULL) {\r
+ rval.code = RC_FAIL;\r
+ rval.consumed = 0;\r
+ return rval;\r
+ }\r
+ }\r
+\r
+ ASN_DEBUG("Decoding %s as INTEGER (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("%s length is %d bytes", td->name, (int)length);\r
+\r
+ /*\r
+ * Make sure we have this 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
+ * ASN.1 encoded INTEGER: buf_ptr, length\r
+ * Fill the native, at the same time checking for overflow.\r
+ * If overflow occured, return with RC_FAIL.\r
+ */\r
+ {\r
+ INTEGER_t tmp;\r
+ union {\r
+ const void *constbuf;\r
+ void *nonconstbuf;\r
+ } unconst_buf;\r
+ long l;\r
+\r
+ unconst_buf.constbuf = buf_ptr;\r
+ tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;\r
+ tmp.size = length;\r
+\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_INTEGER2ulong(&tmp, (unsigned long *)&l) /* sic */\r
+ : asn_INTEGER2long(&tmp, &l)) {\r
+ rval.code = RC_FAIL;\r
+ rval.consumed = 0;\r
+ return rval;\r
+ }\r
+\r
+ *native = l;\r
+ }\r
+\r
+ rval.code = RC_OK;\r
+ rval.consumed += length;\r
+\r
+ ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",\r
+ (long)rval.consumed, (long)length, td->name, (long)*native);\r
+\r
+ return rval;\r
+}\r
+\r
+/*\r
+ * Encode the NativeInteger using the standard INTEGER type DER encoder.\r
+ */\r
+asn_enc_rval_t\r
+NativeInteger_encode_der(const asn_TYPE_descriptor_t *sd, const void *ptr,\r
+ int tag_mode, ber_tlv_tag_t tag,\r
+ asn_app_consume_bytes_f *cb, void *app_key) {\r
+ unsigned long native = *(const unsigned long *)ptr; /* Disable sign ext. */\r
+ asn_enc_rval_t erval = {0,0,0};\r
+ INTEGER_t tmp;\r
+\r
+#ifdef WORDS_BIGENDIAN /* Opportunistic optimization */\r
+\r
+ tmp.buf = (uint8_t *)&native;\r
+ tmp.size = sizeof(native);\r
+\r
+#else /* Works even if WORDS_BIGENDIAN is not set where should've been */\r
+ uint8_t buf[sizeof(native)];\r
+ uint8_t *p;\r
+\r
+ /* Prepare a fake INTEGER */\r
+ for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)\r
+ *p = (uint8_t)native;\r
+\r
+ tmp.buf = buf;\r
+ tmp.size = sizeof(buf);\r
+#endif /* WORDS_BIGENDIAN */\r
+ \r
+ /* Encode fake INTEGER */\r
+ erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);\r
+ if(erval.structure_ptr == &tmp) {\r
+ erval.structure_ptr = ptr;\r
+ }\r
+ return erval;\r
+}\r
+\r
+/*\r
+ * Decode the chunk of XML text encoding INTEGER.\r
+ */\r
+asn_dec_rval_t\r
+NativeInteger_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,\r
+ size_t size) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ asn_dec_rval_t rval;\r
+ INTEGER_t st;\r
+ void *st_ptr = (void *)&st;\r
+ long *native = (long *)*sptr;\r
+\r
+ if(!native) {\r
+ native = (long *)(*sptr = CALLOC(1, sizeof(*native)));\r
+ if(!native) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ memset(&st, 0, sizeof(st));\r
+ rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, \r
+ opt_mname, buf_ptr, size);\r
+ if(rval.code == RC_OK) {\r
+ long l;\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_INTEGER2ulong(&st, (unsigned long *)&l) /* sic */\r
+ : asn_INTEGER2long(&st, &l)) {\r
+ rval.code = RC_FAIL;\r
+ rval.consumed = 0;\r
+ } else {\r
+ *native = l;\r
+ }\r
+ } else {\r
+ /*\r
+ * Cannot restart from the middle;\r
+ * there is no place to save state in the native type.\r
+ * Request a continuation from the very beginning.\r
+ */\r
+ rval.consumed = 0;\r
+ }\r
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);\r
+ return rval;\r
+}\r
+\r
+\r
+asn_enc_rval_t\r
+NativeInteger_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 asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ char scratch[32]; /* Enough for 64-bit int */\r
+ asn_enc_rval_t er = {0,0,0};\r
+ const long *native = (const long *)sptr;\r
+\r
+ (void)ilevel;\r
+ (void)flags;\r
+\r
+ if(!native) ASN__ENCODE_FAILED;\r
+\r
+ er.encoded = snprintf(scratch, sizeof(scratch),\r
+ (specs && specs->field_unsigned)\r
+ ? "%lu" : "%ld", *native);\r
+ if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)\r
+ || cb(scratch, er.encoded, app_key) < 0)\r
+ ASN__ENCODE_FAILED;\r
+\r
+ ASN__ENCODED_OK(er);\r
+}\r
+\r
+#ifndef ASN_DISABLE_PER_SUPPORT\r
+\r
+asn_dec_rval_t\r
+NativeInteger_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
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ asn_dec_rval_t rval;\r
+ long *native = (long *)*sptr;\r
+ INTEGER_t tmpint;\r
+ void *tmpintptr = &tmpint;\r
+\r
+ (void)opt_codec_ctx;\r
+ ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);\r
+\r
+ if(!native) {\r
+ native = (long *)(*sptr = CALLOC(1, sizeof(*native)));\r
+ if(!native) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ memset(&tmpint, 0, sizeof tmpint);\r
+ rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,\r
+ &tmpintptr, pd);\r
+ if(rval.code == RC_OK) {\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)\r
+ : asn_INTEGER2long(&tmpint, native))\r
+ rval.code = RC_FAIL;\r
+ else\r
+ ASN_DEBUG("NativeInteger %s got value %ld",\r
+ td->name, *native);\r
+ }\r
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);\r
+\r
+ return rval;\r
+}\r
+\r
+asn_enc_rval_t\r
+NativeInteger_encode_uper(const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints,\r
+ const void *sptr, asn_per_outp_t *po) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ asn_enc_rval_t er = {0,0,0};\r
+ long native;\r
+ INTEGER_t tmpint;\r
+\r
+ if(!sptr) ASN__ENCODE_FAILED;\r
+\r
+ native = *(const long *)sptr;\r
+\r
+ ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);\r
+\r
+ memset(&tmpint, 0, sizeof(tmpint));\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_ulong2INTEGER(&tmpint, native)\r
+ : asn_long2INTEGER(&tmpint, native))\r
+ ASN__ENCODE_FAILED;\r
+ er = INTEGER_encode_uper(td, constraints, &tmpint, po);\r
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);\r
+ return er;\r
+}\r
+\r
+asn_dec_rval_t\r
+NativeInteger_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,\r
+ const asn_TYPE_descriptor_t *td,\r
+ const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {\r
+\r
+ const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;\r
+ asn_dec_rval_t rval;\r
+ long *native = (long *)*sptr;\r
+ INTEGER_t tmpint;\r
+ void *tmpintptr = &tmpint;\r
+\r
+ (void)opt_codec_ctx;\r
+ ASN_DEBUG("Decoding NativeInteger %s (APER)", td->name);\r
+\r
+ if(!native) {\r
+ native = (long *)(*sptr = CALLOC(1, sizeof(*native)));\r
+ if(!native) ASN__DECODE_FAILED;\r
+ }\r
+\r
+ memset(&tmpint, 0, sizeof tmpint);\r
+ rval = INTEGER_decode_aper(opt_codec_ctx, td, constraints,\r
+ &tmpintptr, pd);\r
+ if(rval.code == RC_OK) {\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)\r
+ : asn_INTEGER2long(&tmpint, native))\r
+ rval.code = RC_FAIL;\r
+ else\r
+ ASN_DEBUG("NativeInteger %s got value %ld",\r
+ td->name, *native);\r
+ }\r
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);\r
+\r
+ return rval;\r
+}\r
+\r
+asn_enc_rval_t\r
+NativeInteger_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
+\r
+ const asn_INTEGER_specifics_t *specs = (const asn_INTEGER_specifics_t *)td->specifics;\r
+ asn_enc_rval_t er = {0,0,0};\r
+ long native;\r
+ INTEGER_t tmpint;\r
+\r
+ if(!sptr) ASN__ENCODE_FAILED;\r
+\r
+ native = *(const long *)sptr;\r
+\r
+ ASN_DEBUG("Encoding NativeInteger %s %ld (APER)", td->name, native);\r
+\r
+ memset(&tmpint, 0, sizeof(tmpint));\r
+ if((specs&&specs->field_unsigned)\r
+ ? asn_ulong2INTEGER(&tmpint, (unsigned long)native)\r
+ : asn_long2INTEGER(&tmpint, native))\r
+ ASN__ENCODE_FAILED;\r
+ er = INTEGER_encode_aper(td, constraints, &tmpint, po);\r
+ ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);\r
+ return er;\r
+}\r
+\r
+#endif /* ASN_DISABLE_PER_SUPPORT */\r
+\r
+/*\r
+ * INTEGER specific human-readable output.\r
+ */\r
+int\r
+NativeInteger_print(const asn_TYPE_descriptor_t *td, const void *sptr,\r
+ int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ const long *native = (const long *)sptr;\r
+ char scratch[32]; /* Enough for 64-bit int */\r
+ int ret;\r
+\r
+ (void)td; /* Unused argument */\r
+ (void)ilevel; /* Unused argument */\r
+\r
+ if(native) {\r
+ long value = *native;\r
+ ret = snprintf(scratch, sizeof(scratch),\r
+ (specs && specs->field_unsigned) ? "%lu" : "%ld", value);\r
+ assert(ret > 0 && (size_t)ret < sizeof(scratch));\r
+ if(cb(scratch, ret, app_key) < 0) return -1;\r
+ if(specs && (value >= 0 || !specs->field_unsigned)) {\r
+ const asn_INTEGER_enum_map_t *el =\r
+ INTEGER_map_value2enum(specs, value);\r
+ if(el) {\r
+ if(cb(" (", 2, app_key) < 0) return -1;\r
+ if(cb(el->enum_name, el->enum_len, app_key) < 0) return -1;\r
+ if(cb(")", 1, app_key) < 0) return -1;\r
+ }\r
+ }\r
+ return 0;\r
+ } else {\r
+ return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;\r
+ }\r
+}\r
+\r
+void\r
+NativeInteger_free(const asn_TYPE_descriptor_t *td, void *ptr,\r
+ enum asn_struct_free_method method) {\r
+ if(!td || !ptr)\r
+ return;\r
+\r
+ ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",\r
+ td->name, method, ptr);\r
+\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(long));\r
+ break;\r
+ }\r
+}\r
+\r
+int\r
+NativeInteger_compare(const asn_TYPE_descriptor_t *td, const void *aptr, const void *bptr) {\r
+ (void)td;\r
+\r
+ if(aptr && bptr) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\r
+ if(specs && specs->field_unsigned) {\r
+ const unsigned long *a = aptr;\r
+ const unsigned long *b = bptr;\r
+ if(*a < *b) {\r
+ return -1;\r
+ } else if(*a > *b) {\r
+ return 1;\r
+ } else {\r
+ return 0;\r
+ }\r
+ } else {\r
+ const long *a = aptr;\r
+ const long *b = bptr;\r
+ if(*a < *b) {\r
+ return -1;\r
+ } else if(*a > *b) {\r
+ return 1;\r
+ } else {\r
+ return 0;\r
+ }\r
+ }\r
+ } else if(!aptr) {\r
+ return -1;\r
+ } else {\r
+ return 1;\r
+ }\r
+}\r
+\r
+asn_random_fill_result_t\r
+NativeInteger_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
+ const asn_encoding_constraints_t *constraints,\r
+ size_t max_length) {\r
+ const asn_INTEGER_specifics_t *specs =\r
+ (const asn_INTEGER_specifics_t *)td->specifics;\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
+ long *st = *sptr;\r
+ const asn_INTEGER_enum_map_t *emap;\r
+ size_t emap_len;\r
+ intmax_t value;\r
+ int find_inside_map;\r
+\r
+ if(max_length == 0) return result_skipped;\r
+\r
+ if(st == NULL) {\r
+ st = (long *)CALLOC(1, sizeof(*st));\r
+ if(st == NULL) {\r
+ return result_failed;\r
+ }\r
+ }\r
+\r
+ if(specs) {\r
+ emap = specs->value2enum;\r
+ emap_len = specs->map_count;\r
+ if(specs->strict_enumeration) {\r
+ find_inside_map = emap_len > 0;\r
+ } else {\r
+ find_inside_map = emap_len ? asn_random_between(0, 1) : 0;\r
+ }\r
+ } else {\r
+ emap = 0;\r
+ emap_len = 0;\r
+ find_inside_map = 0;\r
+ }\r
+\r
+ if(find_inside_map) {\r
+ assert(emap_len > 0);\r
+ value = emap[asn_random_between(0, emap_len - 1)].nat_value;\r
+ } else {\r
+ const asn_per_constraints_t *ct;\r
+\r
+ static const long variants[] = {\r
+ -65536, -65535, -65534, -32769, -32768, -32767, -16385, -16384,\r
+ -16383, -257, -256, -255, -254, -129, -128, -127,\r
+ -126, -1, 0, 1, 126, 127, 128, 129,\r
+ 254, 255, 256, 257, 16383, 16384, 16385, 32767,\r
+ 32768, 32769, 65534, 65535, 65536, 65537};\r
+ if(specs && specs->field_unsigned) {\r
+ assert(variants[18] == 0);\r
+ value = variants[asn_random_between(\r
+ 18, sizeof(variants) / sizeof(variants[0]) - 1)];\r
+ } else {\r
+ value = variants[asn_random_between(\r
+ 0, sizeof(variants) / sizeof(variants[0]) - 1)];\r
+ }\r
+\r
+ if(!constraints) constraints = &td->encoding_constraints;\r
+ ct = constraints ? constraints->per_constraints : 0;\r
+ if(ct && (ct->value.flags & APC_CONSTRAINED)) {\r
+ if(value < ct->value.lower_bound || value > ct->value.upper_bound) {\r
+ value = asn_random_between(ct->value.lower_bound,\r
+ ct->value.upper_bound);\r
+ }\r
+ }\r
+ }\r
+\r
+ *sptr = st;\r
+ *st = value;\r
+ return result_ok;\r
+}\r
Code Review / ric-app / kpimon.git / blobdiff