asn1c_defs/all-defs/NULL.c

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