Bouncer/e2sm_kpm/lib/ENUMERATED.c

   1 /*-
   2  * Copyright (c) 2003, 2005, 2006 Lev Walkin <vlm@lionet.info>.
   3  * All rights reserved.
   4  * Redistribution and modifications are permitted subject to BSD license.
   5  */
   6 #include <asn_internal.h>
   7 #include <ENUMERATED.h>
   8 #include <NativeEnumerated.h>
   9 #include <asn_codecs_prim.h>    /* Encoder and decoder of a primitive type */
  10
  11 /*
  12  * ENUMERATED basic type description.
  13  */
  14 static const ber_tlv_tag_t asn_DEF_ENUMERATED_tags[] = {
  15         (ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
  16 };
  17 asn_TYPE_operation_t asn_OP_ENUMERATED = {
  18         ASN__PRIMITIVE_TYPE_free,
  19         INTEGER_print,                  /* Implemented in terms of INTEGER */
  20         INTEGER_compare,                /* Implemented in terms of INTEGER */
  21         ber_decode_primitive,
  22         INTEGER_encode_der,             /* Implemented in terms of INTEGER */
  23         INTEGER_decode_xer,             /* This is temporary! */
  24         INTEGER_encode_xer,
  25 #ifdef  ASN_DISABLE_OER_SUPPORT
  26         0,
  27         0,
  28 #else
  29         ENUMERATED_decode_oer,
  30         ENUMERATED_encode_oer,
  31 #endif  /* ASN_DISABLE_OER_SUPPORT */
  32 #ifdef  ASN_DISABLE_PER_SUPPORT
  33         0,
  34         0,
  35         0,
  36         0,
  37 #else
  38         ENUMERATED_decode_uper,         /* Unaligned PER decoder */
  39         ENUMERATED_encode_uper,         /* Unaligned PER encoder */
  40         ENUMERATED_decode_aper,         /* Aligned PER decoder */
  41         ENUMERATED_encode_aper,         /* Aligned PER encoder */
  42 #endif  /* ASN_DISABLE_PER_SUPPORT */
  43         ENUMERATED_random_fill,
  44         0       /* Use generic outmost tag fetcher */
  45 };
  46 asn_TYPE_descriptor_t asn_DEF_ENUMERATED = {
  47         "ENUMERATED",
  48         "ENUMERATED",
  49         &asn_OP_ENUMERATED,
  50         asn_DEF_ENUMERATED_tags,
  51         sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
  52         asn_DEF_ENUMERATED_tags,        /* Same as above */
  53         sizeof(asn_DEF_ENUMERATED_tags) / sizeof(asn_DEF_ENUMERATED_tags[0]),
  54         { 0, 0, asn_generic_no_constraint },
  55         0, 0,   /* No members */
  56         0       /* No specifics */
  57 };
  58
  59
  60 #ifndef  ASN_DISABLE_OER_SUPPORT
  61
  62 asn_dec_rval_t
  63 ENUMERATED_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
  64                       const asn_TYPE_descriptor_t *td,
  65                       const asn_oer_constraints_t *constraints, void **sptr,
  66                       const void *ptr, size_t size) {
  67     asn_dec_rval_t rval;
  68     ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
  69     long value;
  70     void *vptr = &value;
  71
  72     if(!st) {
  73         st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
  74                 if(!st) ASN__DECODE_FAILED;
  75         }
  76
  77     rval = NativeEnumerated_decode_oer(opt_codec_ctx, td, constraints,
  78                                        (void **)&vptr, ptr, size);
  79     if(rval.code == RC_OK) {
  80         if(asn_long2INTEGER(st, value)) {
  81             rval.code = RC_FAIL;
  82         }
  83     }
  84     return rval;
  85 }
  86
  87 asn_enc_rval_t
  88 ENUMERATED_encode_oer(const asn_TYPE_descriptor_t *td,
  89                       const asn_oer_constraints_t *constraints,
  90                       const void *sptr, asn_app_consume_bytes_f *cb,
  91                       void *app_key) {
  92     const ENUMERATED_t *st = sptr;
  93         long value;
  94
  95         if(asn_INTEGER2long(st, &value)) {
  96         ASN__ENCODE_FAILED;
  97     }
  98
  99     return NativeEnumerated_encode_oer(td, constraints, &value, cb, app_key);
 100 }
 101
 102 #endif  /* ASN_DISABLE_OER_SUPPORT */
 103
 104 #ifndef  ASN_DISABLE_PER_SUPPORT
 105
 106 asn_dec_rval_t
 107 ENUMERATED_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
 108                        const asn_TYPE_descriptor_t *td,
 109                        const asn_per_constraints_t *constraints, void **sptr,
 110                        asn_per_data_t *pd) {
 111     asn_dec_rval_t rval;
 112     ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
 113     long value;
 114     void *vptr = &value;
 115
 116     if(!st) {
 117         st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
 118         if(!st) ASN__DECODE_FAILED;
 119         }
 120
 121     rval = NativeEnumerated_decode_uper(opt_codec_ctx, td, constraints,
 122                                         (void **)&vptr, pd);
 123     if(rval.code == RC_OK) {
 124         if(asn_long2INTEGER(st, value)) {
 125             rval.code = RC_FAIL;
 126         }
 127     }
 128     return rval;
 129 }
 130
 131 asn_enc_rval_t
 132 ENUMERATED_encode_uper(const asn_TYPE_descriptor_t *td,
 133                        const asn_per_constraints_t *constraints,
 134                        const void *sptr, asn_per_outp_t *po) {
 135     const ENUMERATED_t *st = (const ENUMERATED_t *)sptr;
 136     long value;
 137
 138     if(asn_INTEGER2long(st, &value)) {
 139         ASN__ENCODE_FAILED;
 140     }
 141
 142     return NativeEnumerated_encode_uper(td, constraints, &value, po);
 143 }
 144
 145 asn_dec_rval_t
 146 ENUMERATED_decode_aper(const asn_codec_ctx_t *opt_codec_ctx,
 147                        const asn_TYPE_descriptor_t *td,
 148                        const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 149         asn_dec_rval_t rval;
 150         ENUMERATED_t *st = (ENUMERATED_t *)*sptr;
 151         long value;
 152         void *vptr = &value;
 153
 154         if(!st) {
 155                 st = (ENUMERATED_t *)(*sptr = CALLOC(1, sizeof(*st)));
 156                 if(!st) ASN__DECODE_FAILED;
 157         }
 158
 159         rval = NativeEnumerated_decode_aper(opt_codec_ctx, td, constraints,
 160                                             (void **)&vptr, pd);
 161         if(rval.code == RC_OK)
 162                 if(asn_long2INTEGER(st, value))
 163                         rval.code = RC_FAIL;
 164         return rval;
 165 }
 166
 167 asn_enc_rval_t
 168 ENUMERATED_encode_aper(const asn_TYPE_descriptor_t *td,
 169                        const asn_per_constraints_t *constraints,
 170                        const void *sptr, asn_per_outp_t *po) {
 171         const ENUMERATED_t *st = (const ENUMERATED_t *)sptr;
 172         long value;
 173
 174         if(asn_INTEGER2long(st, &value))
 175                 ASN__ENCODE_FAILED;
 176
 177         return NativeEnumerated_encode_aper(td, constraints, &value, po);
 178 }
 179 #endif  /* ASN_DISABLE_PER_SUPPORT */
 180