libs/smux/NULL.c

   1 /*-
   2  * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
   3  * Redistribution and modifications are permitted subject to BSD license.
   4  */
   5 #include <asn_internal.h>
   6 #include <asn_codecs_prim.h>
   7 #include <NULL.h>
   8
   9 /*
  10  * NULL basic type description.
  11  */
  12 static const ber_tlv_tag_t asn_DEF_NULL_tags[] = {
  13         (ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
  14 };
  15 asn_TYPE_operation_t asn_OP_NULL = {
  16         NULL_free,
  17         NULL_print,
  18         NULL_compare,
  19         NULL_decode_ber,
  20         NULL_encode_der,        /* Special handling of DER encoding */
  21         NULL_decode_xer,
  22         NULL_encode_xer,
  23 #ifdef  ASN_DISABLE_OER_SUPPORT
  24         0,
  25         0,
  26 #else
  27         NULL_decode_oer,
  28         NULL_encode_oer,
  29 #endif  /* ASN_DISABLE_OER_SUPPORT */
  30 #ifdef  ASN_DISABLE_PER_SUPPORT
  31         0,
  32         0,
  33 #else
  34         NULL_decode_uper,       /* Unaligned PER decoder */
  35         NULL_encode_uper,       /* Unaligned PER encoder */
  36 #endif  /* ASN_DISABLE_PER_SUPPORT */
  37         NULL_random_fill,
  38         0       /* Use generic outmost tag fetcher */
  39 };
  40 asn_TYPE_descriptor_t asn_DEF_NULL = {
  41         "NULL",
  42         "NULL",
  43         &asn_OP_NULL,
  44         asn_DEF_NULL_tags,
  45         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
  46         asn_DEF_NULL_tags,      /* Same as above */
  47         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
  48         { 0, 0, asn_generic_no_constraint },
  49         0, 0,   /* No members */
  50         0       /* No specifics */
  51 };
  52
  53 void
  54 NULL_free(const asn_TYPE_descriptor_t *td, void *ptr,
  55           enum asn_struct_free_method method) {
  56     if(td && ptr) {
  57         switch(method) {
  58         case ASFM_FREE_EVERYTHING:
  59             FREEMEM(ptr);
  60             break;
  61         case ASFM_FREE_UNDERLYING:
  62             break;
  63         case ASFM_FREE_UNDERLYING_AND_RESET:
  64             memset(ptr, 0, sizeof(NULL_t));
  65             break;
  66         }
  67     }
  68 }
  69
  70 /*
  71  * Decode NULL type.
  72  */
  73 asn_dec_rval_t
  74 NULL_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
  75                 const asn_TYPE_descriptor_t *td, void **bool_value,
  76                 const void *buf_ptr, size_t size, int tag_mode) {
  77     NULL_t *st = (NULL_t *)*bool_value;
  78     asn_dec_rval_t rval;
  79     ber_tlv_len_t length;
  80
  81     if(st == NULL) {
  82         st = (NULL_t *)(*bool_value = CALLOC(1, sizeof(*st)));
  83         if(st == NULL) {
  84             rval.code = RC_FAIL;
  85             rval.consumed = 0;
  86             return rval;
  87         }
  88     }
  89
  90     ASN_DEBUG("Decoding %s as NULL (tm=%d)", td->name, tag_mode);
  91
  92     /*
  93      * Check tags.
  94      */
  95     rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, tag_mode, 0,
  96                           &length, 0);
  97     if(rval.code != RC_OK) {
  98         return rval;
  99     }
 100
 101     // X.690-201508, #8.8.2, length shall be zero.
 102     if(length != 0) {
 103         ASN_DEBUG("Decoding %s as NULL failed: too much data", td->name);
 104         rval.code = RC_FAIL;
 105         rval.consumed = 0;
 106         return rval;
 107     }
 108
 109     return rval;
 110 }
 111
 112 asn_enc_rval_t
 113 NULL_encode_der(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode,
 114                 ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) {
 115     asn_enc_rval_t erval;
 116
 117         erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
 118         if(erval.encoded == -1) {
 119                 erval.failed_type = td;
 120                 erval.structure_ptr = ptr;
 121         }
 122
 123         ASN__ENCODED_OK(erval);
 124 }
 125
 126 asn_enc_rval_t
 127 NULL_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 128                 enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
 129                 void *app_key) {
 130     asn_enc_rval_t er;
 131
 132         (void)td;
 133         (void)sptr;
 134         (void)ilevel;
 135         (void)flags;
 136         (void)cb;
 137         (void)app_key;
 138
 139         /* XMLNullValue is empty */
 140         er.encoded = 0;
 141         ASN__ENCODED_OK(er);
 142 }
 143
 144
 145 static enum xer_pbd_rval
 146 NULL__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
 147                       const void *chunk_buf, size_t chunk_size) {
 148     (void)td;
 149         (void)sptr;
 150         (void)chunk_buf;    /* Going to be empty according to the rules below. */
 151
 152         /*
 153          * There must be no content in self-terminating <NULL/> tag.
 154          */
 155         if(chunk_size)
 156                 return XPBD_BROKEN_ENCODING;
 157         else
 158                 return XPBD_BODY_CONSUMED;
 159 }
 160
 161 asn_dec_rval_t
 162 NULL_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
 163                 const asn_TYPE_descriptor_t *td, void **sptr,
 164                 const char *opt_mname, const void *buf_ptr, size_t size) {
 165     return xer_decode_primitive(opt_codec_ctx, td,
 166                 sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
 167                 NULL__xer_body_decode);
 168 }
 169
 170 int
 171 NULL_compare(const asn_TYPE_descriptor_t *td, const void *a, const void *b) {
 172     (void)td;
 173     (void)a;
 174     (void)b;
 175     return 0;
 176 }
 177
 178 int
 179 NULL_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 180            asn_app_consume_bytes_f *cb, void *app_key) {
 181     (void)td;   /* Unused argument */
 182         (void)ilevel;   /* Unused argument */
 183
 184         if(sptr) {
 185                 return (cb("<present>", 9, app_key) < 0) ? -1 : 0;
 186         } else {
 187                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 188         }
 189 }
 190
 191 #ifndef ASN_DISABLE_OER_SUPPORT
 192
 193 asn_dec_rval_t
 194 NULL_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
 195                 const asn_TYPE_descriptor_t *td,
 196                 const asn_oer_constraints_t *constraints, void **sptr,
 197                 const void *ptr, size_t size) {
 198     asn_dec_rval_t rv = {RC_OK, 0};
 199     (void)opt_codec_ctx;
 200     (void)td;
 201     (void)constraints;
 202     (void)ptr;
 203     (void)size;
 204
 205     if(!*sptr) {
 206         *sptr = MALLOC(sizeof(NULL_t));
 207         if(*sptr) {
 208             *(NULL_t *)*sptr = 0;
 209         } else {
 210             ASN__DECODE_FAILED;
 211         }
 212     }
 213
 214     return rv;
 215 }
 216
 217 asn_enc_rval_t
 218 NULL_encode_oer(const asn_TYPE_descriptor_t *td,
 219                 const asn_oer_constraints_t *constraints, const void *sptr,
 220                 asn_app_consume_bytes_f *cb, void *app_key) {
 221     asn_enc_rval_t er;
 222
 223     (void)td;
 224     (void)sptr;
 225     (void)constraints;
 226     (void)cb;
 227     (void)app_key;
 228
 229     er.encoded = 0; /* Encoding in 0 bytes. */
 230
 231     ASN__ENCODED_OK(er);
 232 }
 233
 234 #endif /* ASN_DISABLE_OER_SUPPORT */
 235
 236 #ifndef ASN_DISABLE_PER_SUPPORT
 237
 238 asn_dec_rval_t
 239 NULL_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
 240                  const asn_TYPE_descriptor_t *td,
 241                  const asn_per_constraints_t *constraints, void **sptr,
 242                  asn_per_data_t *pd) {
 243     asn_dec_rval_t rv;
 244
 245         (void)opt_codec_ctx;
 246         (void)td;
 247         (void)constraints;
 248         (void)pd;
 249
 250         if(!*sptr) {
 251                 *sptr = MALLOC(sizeof(NULL_t));
 252                 if(*sptr) {
 253                         *(NULL_t *)*sptr = 0;
 254                 } else {
 255                         ASN__DECODE_FAILED;
 256                 }
 257         }
 258
 259         /*
 260          * NULL type does not have content octets.
 261          */
 262
 263         rv.code = RC_OK;
 264         rv.consumed = 0;
 265         return rv;
 266 }
 267
 268 asn_enc_rval_t
 269 NULL_encode_uper(const asn_TYPE_descriptor_t *td,
 270                  const asn_per_constraints_t *constraints, const void *sptr,
 271                  asn_per_outp_t *po) {
 272     asn_enc_rval_t er;
 273
 274         (void)td;
 275         (void)constraints;
 276         (void)sptr;
 277         (void)po;
 278
 279         er.encoded = 0;
 280         ASN__ENCODED_OK(er);
 281 }
 282
 283 #endif  /* ASN_DISABLE_PER_SUPPORT */
 284
 285 asn_random_fill_result_t
 286 NULL_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
 287                     const asn_encoding_constraints_t *constr,
 288                     size_t max_length) {
 289     asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
 290     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
 291     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
 292     NULL_t *st = *sptr;
 293
 294     (void)td;
 295     (void)constr;
 296
 297     if(max_length == 0) return result_skipped;
 298
 299     if(st == NULL) {
 300         st = (NULL_t *)(*sptr = CALLOC(1, sizeof(*st)));
 301         if(st == NULL) {
 302             return result_failed;
 303         }
 304     }
 305
 306     return result_ok;
 307 }
 308