asn1/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 #include <BOOLEAN.h>    /* Implemented in terms of BOOLEAN type */
   9
  10 /*
  11  * NULL basic type description.
  12  */
  13 static ber_tlv_tag_t asn_DEF_NULL_tags[] = {
  14         (ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
  15 };
  16 asn_TYPE_descriptor_t asn_DEF_NULL = {
  17         "NULL",
  18         "NULL",
  19         BOOLEAN_free,
  20         NULL_print,
  21         asn_generic_no_constraint,
  22         BOOLEAN_decode_ber,     /* Implemented in terms of BOOLEAN */
  23         NULL_encode_der,        /* Special handling of DER encoding */
  24         NULL_decode_xer,
  25         NULL_encode_xer,
  26         NULL_decode_uper,       /* Unaligned PER decoder */
  27         NULL_encode_uper,       /* Unaligned PER encoder */
  28         0, /* Use generic outmost tag fetcher */
  29         asn_DEF_NULL_tags,
  30         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
  31         asn_DEF_NULL_tags,      /* Same as above */
  32         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
  33         0,      /* No PER visible constraints */
  34         0, 0,   /* No members */
  35         0       /* No specifics */
  36 };
  37
  38 asn_enc_rval_t
  39 NULL_encode_der(asn_TYPE_descriptor_t *td, void *ptr,
  40         int tag_mode, ber_tlv_tag_t tag,
  41         asn_app_consume_bytes_f *cb, void *app_key) {
  42         asn_enc_rval_t erval;
  43
  44         erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
  45         if(erval.encoded == -1) {
  46                 erval.failed_type = td;
  47                 erval.structure_ptr = ptr;
  48         }
  49
  50         _ASN_ENCODED_OK(erval);
  51 }
  52
  53 asn_enc_rval_t
  54 NULL_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
  55         int ilevel, enum xer_encoder_flags_e flags,
  56                 asn_app_consume_bytes_f *cb, void *app_key) {
  57         asn_enc_rval_t er;
  58
  59         (void)td;
  60         (void)sptr;
  61         (void)ilevel;
  62         (void)flags;
  63         (void)cb;
  64         (void)app_key;
  65
  66         /* XMLNullValue is empty */
  67         er.encoded = 0;
  68         _ASN_ENCODED_OK(er);
  69 }
  70
  71
  72 static enum xer_pbd_rval
  73 NULL__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
  74         (void)td;
  75         (void)sptr;
  76
  77         if(xer_is_whitespace(chunk_buf, chunk_size))
  78                 return XPBD_BODY_CONSUMED;
  79         else
  80                 return XPBD_BROKEN_ENCODING;
  81 }
  82
  83 asn_dec_rval_t
  84 NULL_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
  85         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
  86                 const void *buf_ptr, size_t size) {
  87
  88         return xer_decode_primitive(opt_codec_ctx, td,
  89                 sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
  90                 NULL__xer_body_decode);
  91 }
  92
  93 int
  94 NULL_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
  95         asn_app_consume_bytes_f *cb, void *app_key) {
  96
  97         (void)td;       /* Unused argument */
  98         (void)ilevel;   /* Unused argument */
  99
 100         if(sptr) {
 101                 return (cb("<present>", 9, app_key) < 0) ? -1 : 0;
 102         } else {
 103                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
 104         }
 105 }
 106
 107 asn_dec_rval_t
 108 NULL_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 109         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 110         asn_dec_rval_t rv;
 111
 112         (void)opt_codec_ctx;
 113         (void)td;
 114         (void)constraints;
 115         (void)pd;
 116
 117         if(!*sptr) {
 118                 *sptr = MALLOC(sizeof(NULL_t));
 119                 if(*sptr) {
 120                         *(NULL_t *)*sptr = 0;
 121                 } else {
 122                         _ASN_DECODE_FAILED;
 123                 }
 124         }
 125
 126         /*
 127          * NULL type does not have content octets.
 128          */
 129
 130         rv.code = RC_OK;
 131         rv.consumed = 0;
 132         return rv;
 133 }
 134
 135 asn_enc_rval_t
 136 NULL_encode_uper(asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
 137                 void *sptr, asn_per_outp_t *po) {
 138         asn_enc_rval_t er;
 139
 140         (void)td;
 141         (void)constraints;
 142         (void)sptr;
 143         (void)po;
 144
 145         er.encoded = 0;
 146         _ASN_ENCODED_OK(er);
 147 }