stglibs/smux.lib/NativeInteger.c

   1 /*-
   2  * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
   3  * All rights reserved.
   4  * Redistribution and modifications are permitted subject to BSD license.
   5  */
   6 /*
   7  * Read the NativeInteger.h for the explanation wrt. differences between
   8  * INTEGER and NativeInteger.
   9  * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
  10  * implementation deals with the standard (machine-specific) representation
  11  * of them instead of using the platform-independent buffer.
  12  */
  13 #include <asn_internal.h>
  14 #include <NativeInteger.h>
  15
  16 /*
  17  * NativeInteger basic type description.
  18  */
  19 static ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
  20         (ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
  21 };
  22 asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
  23         "INTEGER",                      /* The ASN.1 type is still INTEGER */
  24         "INTEGER",
  25         NativeInteger_free,
  26         NativeInteger_print,
  27         asn_generic_no_constraint,
  28         NativeInteger_decode_ber,
  29         NativeInteger_encode_der,
  30         NativeInteger_decode_xer,
  31         NativeInteger_encode_xer,
  32         NativeInteger_decode_uper,      /* Unaligned PER decoder */
  33         NativeInteger_encode_uper,      /* Unaligned PER encoder */
  34         0, /* Use generic outmost tag fetcher */
  35         asn_DEF_NativeInteger_tags,
  36         sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
  37         asn_DEF_NativeInteger_tags,     /* Same as above */
  38         sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
  39         0,      /* No PER visible constraints */
  40         0, 0,   /* No members */
  41         0       /* No specifics */
  42 };
  43
  44 /*
  45  * Decode INTEGER type.
  46  */
  47 asn_dec_rval_t
  48 NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
  49         asn_TYPE_descriptor_t *td,
  50         void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
  51         long *native = (long *)*nint_ptr;
  52         asn_dec_rval_t rval;
  53         ber_tlv_len_t length;
  54
  55         /*
  56          * If the structure is not there, allocate it.
  57          */
  58         if(native == NULL) {
  59                 native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
  60                 if(native == NULL) {
  61                         rval.code = RC_FAIL;
  62                         rval.consumed = 0;
  63                         return rval;
  64                 }
  65         }
  66
  67         ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
  68                 td->name, tag_mode);
  69
  70         /*
  71          * Check tags.
  72          */
  73         rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
  74                         tag_mode, 0, &length, 0);
  75         if(rval.code != RC_OK)
  76                 return rval;
  77
  78         ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
  79
  80         /*
  81          * Make sure we have this length.
  82          */
  83         buf_ptr = ((const char *)buf_ptr) + rval.consumed;
  84         size -= rval.consumed;
  85         if(length > (ber_tlv_len_t)size) {
  86                 rval.code = RC_WMORE;
  87                 rval.consumed = 0;
  88                 return rval;
  89         }
  90
  91         /*
  92          * ASN.1 encoded INTEGER: buf_ptr, length
  93          * Fill the native, at the same time checking for overflow.
  94          * If overflow occured, return with RC_FAIL.
  95          */
  96         {
  97                 INTEGER_t tmp;
  98                 union {
  99                         const void *constbuf;
 100                         void *nonconstbuf;
 101                 } unconst_buf;
 102                 long l;
 103
 104                 unconst_buf.constbuf = buf_ptr;
 105                 tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
 106                 tmp.size = length;
 107
 108                 if(asn_INTEGER2long(&tmp, &l)) {
 109                         rval.code = RC_FAIL;
 110                         rval.consumed = 0;
 111                         return rval;
 112                 }
 113
 114                 *native = l;
 115         }
 116
 117         rval.code = RC_OK;
 118         rval.consumed += length;
 119
 120         ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
 121                 (long)rval.consumed, (long)length, td->name, (long)*native);
 122
 123         return rval;
 124 }
 125
 126 /*
 127  * Encode the NativeInteger using the standard INTEGER type DER encoder.
 128  */
 129 asn_enc_rval_t
 130 NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
 131         int tag_mode, ber_tlv_tag_t tag,
 132         asn_app_consume_bytes_f *cb, void *app_key) {
 133         unsigned long native = *(unsigned long *)ptr;   /* Disable sign ext. */
 134         asn_enc_rval_t erval;
 135         INTEGER_t tmp;
 136
 137 #ifdef  WORDS_BIGENDIAN         /* Opportunistic optimization */
 138
 139         tmp.buf = (uint8_t *)&native;
 140         tmp.size = sizeof(native);
 141
 142 #else   /* Works even if WORDS_BIGENDIAN is not set where should've been */
 143         uint8_t buf[sizeof(native)];
 144         uint8_t *p;
 145
 146         /* Prepare a fake INTEGER */
 147         for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
 148                 *p = native;
 149
 150         tmp.buf = buf;
 151         tmp.size = sizeof(buf);
 152 #endif  /* WORDS_BIGENDIAN */
 153
 154         /* Encode fake INTEGER */
 155         erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
 156         if(erval.encoded == -1) {
 157                 assert(erval.structure_ptr == &tmp);
 158                 erval.structure_ptr = ptr;
 159         }
 160         return erval;
 161 }
 162
 163 /*
 164  * Decode the chunk of XML text encoding INTEGER.
 165  */
 166 asn_dec_rval_t
 167 NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 168         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
 169                 const void *buf_ptr, size_t size) {
 170         asn_dec_rval_t rval;
 171         INTEGER_t st;
 172         void *st_ptr = (void *)&st;
 173         long *native = (long *)*sptr;
 174
 175         if(!native) {
 176                 native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
 177                 if(!native) _ASN_DECODE_FAILED;
 178         }
 179
 180         memset(&st, 0, sizeof(st));
 181         rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr,
 182                 opt_mname, buf_ptr, size);
 183         if(rval.code == RC_OK) {
 184                 long l;
 185                 if(asn_INTEGER2long(&st, &l)) {
 186                         rval.code = RC_FAIL;
 187                         rval.consumed = 0;
 188                 } else {
 189                         *native = l;
 190                 }
 191         } else {
 192                 /*
 193                  * Cannot restart from the middle;
 194                  * there is no place to save state in the native type.
 195                  * Request a continuation from the very beginning.
 196                  */
 197                 rval.consumed = 0;
 198         }
 199         ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
 200         return rval;
 201 }
 202
 203
 204 asn_enc_rval_t
 205 NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 206         int ilevel, enum xer_encoder_flags_e flags,
 207                 asn_app_consume_bytes_f *cb, void *app_key) {
 208         char scratch[32];       /* Enough for 64-bit int */
 209         asn_enc_rval_t er;
 210         const long *native = (const long *)sptr;
 211
 212         (void)ilevel;
 213         (void)flags;
 214
 215         if(!native) _ASN_ENCODE_FAILED;
 216
 217         er.encoded = snprintf(scratch, sizeof(scratch), "%ld", *native);
 218         if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
 219                 || cb(scratch, er.encoded, app_key) < 0)
 220                 _ASN_ENCODE_FAILED;
 221
 222         _ASN_ENCODED_OK(er);
 223 }
 224
 225 asn_dec_rval_t
 226 NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
 227         asn_TYPE_descriptor_t *td,
 228         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 229
 230         asn_dec_rval_t rval;
 231         long *native = (long *)*sptr;
 232         INTEGER_t tmpint;
 233         void *tmpintptr = &tmpint;
 234
 235         (void)opt_codec_ctx;
 236         ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
 237
 238         if(!native) {
 239                 native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
 240                 if(!native) _ASN_DECODE_FAILED;
 241         }
 242
 243         memset(&tmpint, 0, sizeof tmpint);
 244         rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
 245                                    &tmpintptr, pd);
 246         if(rval.code == RC_OK) {
 247                 if(asn_INTEGER2long(&tmpint, native))
 248                         rval.code = RC_FAIL;
 249                 else
 250                         ASN_DEBUG("NativeInteger %s got value %ld",
 251                                 td->name, *native);
 252         }
 253         ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
 254
 255         return rval;
 256 }
 257
 258 asn_enc_rval_t
 259 NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
 260         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
 261         asn_enc_rval_t er;
 262         long native;
 263         INTEGER_t tmpint;
 264
 265         if(!sptr) _ASN_ENCODE_FAILED;
 266
 267         native = *(long *)sptr;
 268
 269         ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
 270
 271         memset(&tmpint, 0, sizeof(tmpint));
 272         if(asn_long2INTEGER(&tmpint, native))
 273                 _ASN_ENCODE_FAILED;
 274         er = INTEGER_encode_uper(td, constraints, &tmpint, po);
 275         ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
 276         return er;
 277 }
 278
 279 /*
 280  * INTEGER specific human-readable output.
 281  */
 282 int
 283 NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 284         asn_app_consume_bytes_f *cb, void *app_key) {
 285         const long *native = (const long *)sptr;
 286         char scratch[32];       /* Enough for 64-bit int */
 287         int ret;
 288
 289         (void)td;       /* Unused argument */
 290         (void)ilevel;   /* Unused argument */
 291
 292         if(native) {
 293                 ret = snprintf(scratch, sizeof(scratch), "%ld", *native);
 294                 assert(ret > 0 && (size_t)ret < sizeof(scratch));
 295                 return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
 296         } else {
 297                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 298         }
 299 }
 300
 301 void
 302 NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
 303
 304         if(!td || !ptr)
 305                 return;
 306
 307         ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
 308                 td->name, contents_only, ptr);
 309
 310         if(!contents_only) {
 311                 FREEMEM(ptr);
 312         }
 313 }
 314