stglibs/smux.lib/BOOLEAN.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 <BOOLEAN.h>
   8
   9 /*
  10  * BOOLEAN basic type description.
  11  */
  12 static ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
  13         (ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
  14 };
  15 asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
  16         "BOOLEAN",
  17         "BOOLEAN",
  18         BOOLEAN_free,
  19         BOOLEAN_print,
  20         asn_generic_no_constraint,
  21         BOOLEAN_decode_ber,
  22         BOOLEAN_encode_der,
  23         BOOLEAN_decode_xer,
  24         BOOLEAN_encode_xer,
  25         BOOLEAN_decode_uper,    /* Unaligned PER decoder */
  26         BOOLEAN_encode_uper,    /* Unaligned PER encoder */
  27         0, /* Use generic outmost tag fetcher */
  28         asn_DEF_BOOLEAN_tags,
  29         sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
  30         asn_DEF_BOOLEAN_tags,   /* Same as above */
  31         sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
  32         0,      /* No PER visible constraints */
  33         0, 0,   /* No members */
  34         0       /* No specifics */
  35 };
  36
  37 /*
  38  * Decode BOOLEAN type.
  39  */
  40 asn_dec_rval_t
  41 BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
  42                 asn_TYPE_descriptor_t *td,
  43                 void **bool_value, const void *buf_ptr, size_t size,
  44                 int tag_mode) {
  45         BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
  46         asn_dec_rval_t rval;
  47         ber_tlv_len_t length;
  48         ber_tlv_len_t lidx;
  49
  50         if(st == NULL) {
  51                 st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
  52                 if(st == NULL) {
  53                         rval.code = RC_FAIL;
  54                         rval.consumed = 0;
  55                         return rval;
  56                 }
  57         }
  58
  59         ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
  60                 td->name, tag_mode);
  61
  62         /*
  63          * Check tags.
  64          */
  65         rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
  66                 tag_mode, 0, &length, 0);
  67         if(rval.code != RC_OK)
  68                 return rval;
  69
  70         ASN_DEBUG("Boolean length is %d bytes", (int)length);
  71
  72         buf_ptr = ((const char *)buf_ptr) + rval.consumed;
  73         size -= rval.consumed;
  74         if(length > (ber_tlv_len_t)size) {
  75                 rval.code = RC_WMORE;
  76                 rval.consumed = 0;
  77                 return rval;
  78         }
  79
  80         /*
  81          * Compute boolean value.
  82          */
  83         for(*st = 0, lidx = 0;
  84                 (lidx < length) && *st == 0; lidx++) {
  85                 /*
  86                  * Very simple approach: read bytes until the end or
  87                  * value is already TRUE.
  88                  * BOOLEAN is not supposed to contain meaningful data anyway.
  89                  */
  90                 *st |= ((const uint8_t *)buf_ptr)[lidx];
  91         }
  92
  93         rval.code = RC_OK;
  94         rval.consumed += length;
  95
  96         ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
  97                 (long)rval.consumed, (long)length,
  98                 td->name, *st);
  99
 100         return rval;
 101 }
 102
 103 asn_enc_rval_t
 104 BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
 105         int tag_mode, ber_tlv_tag_t tag,
 106         asn_app_consume_bytes_f *cb, void *app_key) {
 107         asn_enc_rval_t erval;
 108         BOOLEAN_t *st = (BOOLEAN_t *)sptr;
 109
 110         erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
 111         if(erval.encoded == -1) {
 112                 erval.failed_type = td;
 113                 erval.structure_ptr = sptr;
 114                 return erval;
 115         }
 116
 117         if(cb) {
 118                 uint8_t bool_value;
 119
 120                 bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
 121
 122                 if(cb(&bool_value, 1, app_key) < 0) {
 123                         erval.encoded = -1;
 124                         erval.failed_type = td;
 125                         erval.structure_ptr = sptr;
 126                         return erval;
 127                 }
 128         }
 129
 130         erval.encoded += 1;
 131
 132         _ASN_ENCODED_OK(erval);
 133 }
 134
 135
 136 /*
 137  * Decode the chunk of XML text encoding INTEGER.
 138  */
 139 static enum xer_pbd_rval
 140 BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
 141         BOOLEAN_t *st = (BOOLEAN_t *)sptr;
 142         const char *p = (const char *)chunk_buf;
 143
 144         (void)td;
 145
 146         if(chunk_size && p[0] == 0x3c /* '<' */) {
 147                 switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
 148                 case XCT_BOTH:
 149                         /* "<false/>" */
 150                         *st = 0;
 151                         break;
 152                 case XCT_UNKNOWN_BO:
 153                         if(xer_check_tag(chunk_buf, chunk_size, "true")
 154                                         != XCT_BOTH)
 155                                 return XPBD_BROKEN_ENCODING;
 156                         /* "<true/>" */
 157                         *st = 1;        /* Or 0xff as in DER?.. */
 158                         break;
 159                 default:
 160                         return XPBD_BROKEN_ENCODING;
 161                 }
 162                 return XPBD_BODY_CONSUMED;
 163         } else {
 164                 if(xer_is_whitespace(chunk_buf, chunk_size))
 165                         return XPBD_NOT_BODY_IGNORE;
 166                 else
 167                         return XPBD_BROKEN_ENCODING;
 168         }
 169 }
 170
 171
 172 asn_dec_rval_t
 173 BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
 174         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
 175                 const void *buf_ptr, size_t size) {
 176
 177         return xer_decode_primitive(opt_codec_ctx, td,
 178                 sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
 179                 BOOLEAN__xer_body_decode);
 180 }
 181
 182 asn_enc_rval_t
 183 BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
 184         int ilevel, enum xer_encoder_flags_e flags,
 185                 asn_app_consume_bytes_f *cb, void *app_key) {
 186         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
 187         asn_enc_rval_t er;
 188
 189         (void)ilevel;
 190         (void)flags;
 191
 192         if(!st) _ASN_ENCODE_FAILED;
 193
 194         if(*st) {
 195                 _ASN_CALLBACK("<true/>", 7);
 196                 er.encoded = 7;
 197         } else {
 198                 _ASN_CALLBACK("<false/>", 8);
 199                 er.encoded = 8;
 200         }
 201
 202         _ASN_ENCODED_OK(er);
 203 cb_failed:
 204         _ASN_ENCODE_FAILED;
 205 }
 206
 207 int
 208 BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
 209         asn_app_consume_bytes_f *cb, void *app_key) {
 210         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
 211         const char *buf;
 212         size_t buflen;
 213
 214         (void)td;       /* Unused argument */
 215         (void)ilevel;   /* Unused argument */
 216
 217         if(st) {
 218                 if(*st) {
 219                         buf = "TRUE";
 220                         buflen = 4;
 221                 } else {
 222                         buf = "FALSE";
 223                         buflen = 5;
 224                 }
 225         } else {
 226                 buf = "<absent>";
 227                 buflen = 8;
 228         }
 229
 230         return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
 231 }
 232
 233 void
 234 BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
 235         if(td && ptr && !contents_only) {
 236                 FREEMEM(ptr);
 237         }
 238 }
 239
 240 asn_dec_rval_t
 241 BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
 242         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
 243         asn_dec_rval_t rv;
 244         BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
 245
 246         (void)opt_codec_ctx;
 247         (void)constraints;
 248
 249         if(!st) {
 250                 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
 251                 if(!st) _ASN_DECODE_FAILED;
 252         }
 253
 254         /*
 255          * Extract a single bit
 256          */
 257         switch(per_get_few_bits(pd, 1)) {
 258         case 1: *st = 1; break;
 259         case 0: *st = 0; break;
 260         case -1: default: _ASN_DECODE_FAILED;
 261         }
 262
 263         ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
 264
 265         rv.code = RC_OK;
 266         rv.consumed = 1;
 267         return rv;
 268 }
 269
 270
 271 asn_enc_rval_t
 272 BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
 273         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
 274         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
 275         asn_enc_rval_t er;
 276
 277         (void)constraints;
 278
 279         if(!st) _ASN_ENCODE_FAILED;
 280
 281         per_put_few_bits(po, *st ? 1 : 0, 1);
 282
 283         _ASN_ENCODED_OK(er);
 284 }