/*-

 * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.

 * All rights reserved.

 * Redistribution and modifications are permitted subject to BSD license.

 */

/*

 * Read the NativeInteger.h for the explanation wrt. differences between

 * INTEGER and NativeInteger.

 * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this

 * implementation deals with the standard (machine-specific) representation

 * of them instead of using the platform-independent buffer.

 */

#include <asn_internal.h>

#include <NativeInteger.h>

/*

 * NativeInteger basic type description.

 */

static ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {

  (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))

};

asn_TYPE_descriptor_t asn_DEF_NativeInteger = {

  "INTEGER",      /* The ASN.1 type is still INTEGER */

  "INTEGER",

  NativeInteger_free,

  NULL,

  asn_generic_no_constraint,

  NativeInteger_decode_ber,

  NativeInteger_encode_der,

  NULL,

  NULL,

  NativeInteger_decode_uper,  /* Unaligned PER decoder */

  NativeInteger_encode_uper,  /* Unaligned PER encoder */

  0, /* Use generic outmost tag fetcher */

  asn_DEF_NativeInteger_tags,

  sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),

  asn_DEF_NativeInteger_tags, /* Same as above */

  sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),

  0,  /* No PER visible constraints */

  0, 0, /* No members */

  0 /* No specifics */

};

/*

 * Decode INTEGER type.

 */

asn_dec_rval_t

NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,

  asn_TYPE_descriptor_t *td,

  void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {

  long *native = (long *)*nint_ptr;

  asn_dec_rval_t rval;

  ber_tlv_len_t length;

  /*

   * If the structure is not there, allocate it.

   */

  if(native == NULL) {

    native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));

    if(native == NULL) {

      rval.code = RC_FAIL;

      rval.consumed = 0;

      return rval;

    }

  }

  ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",

    td->name, tag_mode);

  /*

   * Check tags.

   */

  rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,

      tag_mode, 0, &length, 0);

  if(rval.code != RC_OK)

    return rval;

  ASN_DEBUG("%s length is %d bytes", td->name, (int)length);

  /*

   * Make sure we have this length.

   */

  buf_ptr = ((const char *)buf_ptr) + rval.consumed;

  size -= rval.consumed;

  if(length > (ber_tlv_len_t)size) {

    rval.code = RC_WMORE;

    rval.consumed = 0;

    return rval;

  }

  /*

   * ASN.1 encoded INTEGER: buf_ptr, length

   * Fill the native, at the same time checking for overflow.

   * If overflow occured, return with RC_FAIL.

   */

  {

    INTEGER_t tmp;

    union {

      const void *constbuf;

      void *nonconstbuf;

    } unconst_buf;

    long l;

    unconst_buf.constbuf = buf_ptr;

    tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;

    tmp.size = length;

    if(asn_INTEGER2long(&tmp, &l)) {

      rval.code = RC_FAIL;

      rval.consumed = 0;

      return rval;

    }

    *native = l;

  }

  rval.code = RC_OK;

  rval.consumed += length;

  ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",

    (long)rval.consumed, (long)length, td->name, (long)*native);

  return rval;

}

/*

 * Encode the NativeInteger using the standard INTEGER type DER encoder.

 */

asn_enc_rval_t

NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,

  int tag_mode, ber_tlv_tag_t tag,

  asn_app_consume_bytes_f *cb, void *app_key) {

  unsigned long native = *(unsigned long *)ptr; /* Disable sign ext. */

  asn_enc_rval_t erval;

  INTEGER_t tmp;

#ifdef  WORDS_BIGENDIAN   /* Opportunistic optimization */

  tmp.buf = (uint8_t *)&native;

  tmp.size = sizeof(native);

#else /* Works even if WORDS_BIGENDIAN is not set where should've been */

  uint8_t buf[sizeof(native)];

  uint8_t *p;

  /* Prepare a fake INTEGER */

  for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)

    *p = native;

  tmp.buf = buf;

  tmp.size = sizeof(buf);

#endif  /* WORDS_BIGENDIAN */

  /* Encode fake INTEGER */

  erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);

  if(erval.encoded == -1) {

    assert(erval.structure_ptr == &tmp);

    erval.structure_ptr = ptr;

  }

  return erval;

}

asn_dec_rval_t

NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,

  asn_TYPE_descriptor_t *td,

  asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {

  asn_dec_rval_t rval;

  long *native = (long *)*sptr;

  INTEGER_t tmpint;

  void *tmpintptr = &tmpint;

  (void)opt_codec_ctx;

  ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);

  if(!native) {

    native = (long *)(*sptr = CALLOC(1, sizeof(*native)));

    if(!native) _ASN_DECODE_FAILED;

  }

  memset(&tmpint, 0, sizeof tmpint);

  rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,

           &tmpintptr, pd);

  if(rval.code == RC_OK) {

    if(asn_INTEGER2long(&tmpint, native))

      rval.code = RC_FAIL;

    else

      ASN_DEBUG("NativeInteger %s got value %ld",

        td->name, *native);

  }

  ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);

  return rval;

}

asn_enc_rval_t

NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,

  asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {

  asn_enc_rval_t er;

  long native;

  INTEGER_t tmpint;

  if(!sptr) _ASN_ENCODE_FAILED;

  native = *(long *)sptr;

  ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);

  memset(&tmpint, 0, sizeof(tmpint));

  if(asn_long2INTEGER(&tmpint, native))

    _ASN_ENCODE_FAILED;

  er = INTEGER_encode_uper(td, constraints, &tmpint, po);

  ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);

  return er;

}

void

NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {

  if(!td || !ptr)

    return;

  ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",

    td->name, contents_only, ptr);

  if(!contents_only) {

    FREEMEM(ptr);

  }

}