text: /*
   * Copyright (c) 2004-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
   * Redistribution and modifications are permitted subject to BSD license.
   */
  #include <asn_internal.h>
  #include <ANY.h>
  #include <errno.h>
  
  asn_OCTET_STRING_specifics_t asn_SPC_ANY_specs = {
  	sizeof(ANY_t),
  	offsetof(ANY_t, _asn_ctx),
  	ASN_OSUBV_ANY
  };
  asn_TYPE_operation_t asn_OP_ANY = {
  	OCTET_STRING_free,
  	OCTET_STRING_print,
  	OCTET_STRING_compare,
  	OCTET_STRING_decode_ber,
  	OCTET_STRING_encode_der,
  	OCTET_STRING_decode_xer_hex,
  	ANY_encode_xer,
  #ifdef	ASN_DISABLE_OER_SUPPORT
  	0,
  	0,
  #else
  	0,
  	0,
  #endif  /* ASN_DISABLE_OER_SUPPORT */
  #ifdef	ASN_DISABLE_PER_SUPPORT
  	0, 0, 0, 0,
  #else
  	ANY_decode_uper,
  	ANY_encode_uper,
  	ANY_decode_aper,
  	ANY_encode_aper,
  #endif  /* ASN_DISABLE_PER_SUPPORT */
  	0,	/* Random fill is not defined for ANY type */
  	0	/* Use generic outmost tag fetcher */
  };
  asn_TYPE_descriptor_t asn_DEF_ANY = {
  	"ANY",
  	"ANY",
  	&asn_OP_ANY,
  	0, 0, 0, 0,
  	{ 0, 0, asn_generic_no_constraint },	/* No constraints */
  	0, 0,	/* No members */
  	&asn_SPC_ANY_specs,
  };
  
  #undef RETURN
  #define RETURN(_code)                       \
      do {                                    \
          asn_dec_rval_t tmprval;             \
          tmprval.code = _code;               \
          tmprval.consumed = consumed_myself; \
          return tmprval;                     \
      } while(0)
  
  asn_enc_rval_t
  ANY_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
                 enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
                 void *app_key) {
      if(flags & XER_F_CANONICAL) {
  		/*
  		 * Canonical XER-encoding of ANY type is not supported.
  		 */
  		ASN__ENCODE_FAILED;
  	}
  
  	/* Dump as binary */
  	return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
  }
  
  struct _callback_arg {
  	uint8_t *buffer;
  	size_t offset;
  	size_t size;
  };
  
  static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
  
  int
  ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
  	struct _callback_arg arg;
  	asn_enc_rval_t erval = {0,0,0};
  
  	if(!st || !td) {
  		errno = EINVAL;
  		return -1;
  	}
  
  	if(!sptr) {
  		if(st->buf) FREEMEM(st->buf);
  		st->size = 0;
  		return 0;
  	}
  
  	arg.offset = arg.size = 0;
  	arg.buffer = 0;
  
  	erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
  	if(erval.encoded == -1) {
  		if(arg.buffer) FREEMEM(arg.buffer);
  		return -1;
  	}
  	assert((size_t)erval.encoded == arg.offset);
  
  	if(st->buf) FREEMEM(st->buf);
  	st->buf = arg.buffer;
  	st->size = arg.offset;
  
  	return 0;
  }
  
  int
  ANY_fromType_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
  	uint8_t *buffer = NULL;
  	ssize_t erval;
  
  	if(!st || !td) {
  		errno = EINVAL;
  		return -1;
  	}
  
  	if(!sptr) {
  		if(st->buf) FREEMEM(st->buf);
  		st->size = 0;
  		return 0;
  	}
  
  	erval = aper_encode_to_new_buffer(td, td->encoding_constraints.per_constraints, sptr, (void**)&buffer);
  
  	if(erval == -1) {
  		if(buffer) FREEMEM(buffer);
  		return -1;
  	}
  	assert((size_t)erval > 0);
  
  	if(st->buf) FREEMEM(st->buf);
  	st->buf = buffer;
  	st->size = erval;
  
  	return 0;
  }
  
  ANY_t *
  ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
  	ANY_t tmp;
  	ANY_t *st;
  
  	if(!td || !sptr) {
  		errno = EINVAL;
  		return 0;
  	}
  
  	memset(&tmp, 0, sizeof(tmp));
  
  	if(ANY_fromType(&tmp, td, sptr)) return 0;
  
  	st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
  	if(st) {
  		*st = tmp;
  		return st;
  	} else {
  		FREEMEM(tmp.buf);
  		return 0;
  	}
  }
  
  ANY_t *
  ANY_new_fromType_aper(asn_TYPE_descriptor_t *td, void *sptr) {
  	ANY_t tmp;
  	ANY_t *st;
  
  	if(!td || !sptr) {
  		errno = EINVAL;
  		return 0;
  	}
  
  	memset(&tmp, 0, sizeof(tmp));
  
  	if(ANY_fromType_aper(&tmp, td, sptr)) return 0;
  
  	st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
  	if(st) {
  		*st = tmp;
  		return st;
  	} else {
  		FREEMEM(tmp.buf);
  		return 0;
  	}
  }
  
  int
  ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
  	asn_dec_rval_t rval;
  	void *newst = 0;
  
  	if(!st || !td || !struct_ptr) {
  		errno = EINVAL;
  		return -1;
  	}
  
  	if(st->buf == 0) {
  		/* Nothing to convert, make it empty. */
  		*struct_ptr = (void *)0;
  		return 0;
  	}
  
  	rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
  	if(rval.code == RC_OK) {
  		*struct_ptr = newst;
  		return 0;
  	} else {
  		/* Remove possibly partially decoded data. */
  		ASN_STRUCT_FREE(*td, newst);
  		return -1;
  	}
  }
  
  int
  ANY_to_type_aper(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
  	asn_dec_rval_t rval;
  	void *newst = 0;
  
  	if(!st || !td || !struct_ptr) {
  		errno = EINVAL;
  		return -1;
  	}
  
  	if(st->buf == 0) {
  		/* Nothing to convert, make it empty. */
  		*struct_ptr = (void *)0;
  		return 0;
  	}
  
  	rval = aper_decode(0, td, (void **)&newst, st->buf, st->size, 0, 0);
  	if(rval.code == RC_OK) {
  		*struct_ptr = newst;
  		return 0;
  	} else {
  		/* Remove possibly partially decoded data. */
  		ASN_STRUCT_FREE(*td, newst);
  		return -1;
  	}
  }
  
  static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
  	struct _callback_arg *arg = (struct _callback_arg *)key;
  
  	if((arg->offset + size) >= arg->size) {
  		size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
  		void *p = REALLOC(arg->buffer, nsize);
  		if(!p) return -1;
  		arg->buffer = (uint8_t *)p;
  		arg->size = nsize;
  	}
  
  	memcpy(arg->buffer + arg->offset, buffer, size);
  	arg->offset += size;
  	assert(arg->offset < arg->size);
  
  	return 0;
  }
  
  #ifndef ASN_DISABLE_PER_SUPPORT
  
  asn_dec_rval_t
  ANY_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
                  const asn_TYPE_descriptor_t *td,
                  const asn_per_constraints_t *constraints, void **sptr,
                  asn_per_data_t *pd) {
      const asn_OCTET_STRING_specifics_t *specs =
          td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
                        : &asn_SPC_ANY_specs;
      size_t consumed_myself = 0;
      int repeat;
      ANY_t *st = (ANY_t *)*sptr;
  
      (void)opt_codec_ctx;
      (void)constraints;
  
      /*
       * Allocate the structure.
       */
      if(!st) {
          st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
          if(!st) RETURN(RC_FAIL);
      }
  
      ASN_DEBUG("UPER Decoding ANY type");
  
      st->size = 0;
      do {
          ssize_t raw_len;
          ssize_t len_bytes;
          ssize_t len_bits;
          void *p;
          int ret;
  
          /* Get the PER length */
          raw_len = uper_get_length(pd, -1, 0, &repeat);
          if(raw_len < 0) RETURN(RC_WMORE);
          if(raw_len == 0 && st->buf) break;
  
          ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
                    repeat ? "repeat" : "once", td->name);
          len_bytes = raw_len;
          len_bits = len_bytes * 8;
  
          p = REALLOC(st->buf, st->size + len_bytes + 1);
          if(!p) RETURN(RC_FAIL);
          st->buf = (uint8_t *)p;
  
          ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
          if(ret < 0) RETURN(RC_WMORE);
          consumed_myself += len_bits;
          st->size += len_bytes;
      } while(repeat);
      st->buf[st->size] = 0; /* nul-terminate */
  
      RETURN(RC_OK);
  }
  
  asn_enc_rval_t
  ANY_encode_uper(const asn_TYPE_descriptor_t *td,
                  const asn_per_constraints_t *constraints, const void *sptr,
                  asn_per_outp_t *po) {
      const ANY_t *st = (const ANY_t *)sptr;
      asn_enc_rval_t er = {0, 0, 0};
      const uint8_t *buf;
      size_t size;
      int ret;
  
      (void)constraints;
  
      if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
  
      buf = st->buf;
      size = st->size;
      do {
          int need_eom = 0;
          ssize_t may_save = uper_put_length(po, size, &need_eom);
          if(may_save < 0) ASN__ENCODE_FAILED;
  
          ret = per_put_many_bits(po, buf, may_save * 8);
          if(ret) ASN__ENCODE_FAILED;
  
          buf += may_save;
          size -= may_save;
          assert(!(may_save & 0x07) || !size);
          if(need_eom && uper_put_length(po, 0, 0))
              ASN__ENCODE_FAILED; /* End of Message length */
      } while(size);
  
      ASN__ENCODED_OK(er);
  }
  
  asn_dec_rval_t
  ANY_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
                  const asn_TYPE_descriptor_t *td,
                  const asn_per_constraints_t *constraints, void **sptr,
                  asn_per_data_t *pd) {
      const asn_OCTET_STRING_specifics_t *specs =
          td->specifics ? (const asn_OCTET_STRING_specifics_t *)td->specifics
                        : &asn_SPC_ANY_specs;
      size_t consumed_myself = 0;
      int repeat;
      ANY_t *st = (ANY_t *)*sptr;
  
      (void)opt_codec_ctx;
      (void)constraints;
  
      /*
       * Allocate the structure.
       */
      if(!st) {
          st = (ANY_t *)(*sptr = CALLOC(1, specs->struct_size));
          if(!st) RETURN(RC_FAIL);
      }
  
      ASN_DEBUG("APER Decoding ANY type");
  
      st->size = 0;
      do {
          ssize_t raw_len;
          ssize_t len_bytes;
          ssize_t len_bits;
          void *p;
          int ret;
  
          /* Get the PER length */
          raw_len = aper_get_length(pd, -1, 0, &repeat);
          if(raw_len < 0) RETURN(RC_WMORE);
          if(raw_len == 0 && st->buf) break;
  
          ASN_DEBUG("Got PER length len %" ASN_PRI_SIZE ", %s (%s)", raw_len,
                    repeat ? "repeat" : "once", td->name);
          len_bytes = raw_len;
          len_bits = len_bytes * 8;
  
          p = REALLOC(st->buf, st->size + len_bytes + 1);
          if(!p) RETURN(RC_FAIL);
          st->buf = (uint8_t *)p;
  
          ret = per_get_many_bits(pd, &st->buf[st->size], 0, len_bits);
          if(ret < 0) RETURN(RC_WMORE);
          consumed_myself += len_bits;
          st->size += len_bytes;
      } while(repeat);
      st->buf[st->size] = 0; /* nul-terminate */
  
      RETURN(RC_OK);
  }
  
  asn_enc_rval_t
  ANY_encode_aper(const asn_TYPE_descriptor_t *td,
                  const asn_per_constraints_t *constraints, const void *sptr,
                  asn_per_outp_t *po) {
      const ANY_t *st = (const ANY_t *)sptr;
      asn_enc_rval_t er = {0, 0, 0};
      const uint8_t *buf;
      size_t size;
      int ret;
  
      (void)constraints;
  
      if(!st || (!st->buf && st->size)) ASN__ENCODE_FAILED;
  
      buf = st->buf;
      size = st->size;
      do {
          int need_eom = 0;
          ssize_t may_save = uper_put_length(po, size, &need_eom);
          if(may_save < 0) ASN__ENCODE_FAILED;
  
          ret = per_put_many_bits(po, buf, may_save * 8);
          if(ret) ASN__ENCODE_FAILED;
  
          buf += may_save;
          size -= may_save;
          assert(!(may_save & 0x07) || !size);
          if(need_eom && uper_put_length(po, 0, 0))
              ASN__ENCODE_FAILED; /* End of Message length */
      } while(size);
  
      ASN__ENCODED_OK(er);
  }
  #endif /* ASN_DISABLE_PER_SUPPORT */
  
  