asn1c_defs/all-defs/BOOLEAN.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 <BOOLEAN.h>\r
   8 \r
   9 /*\r
  10  * BOOLEAN basic type description.\r
  11  */\r
  12 static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {\r
  13         (ASN_TAG_CLASS_UNIVERSAL | (1 << 2))\r
  14 };\r
  15 asn_TYPE_operation_t asn_OP_BOOLEAN = {\r
  16         BOOLEAN_free,\r
  17         BOOLEAN_print,\r
  18         BOOLEAN_compare,\r
  19         BOOLEAN_decode_ber,\r
  20         BOOLEAN_encode_der,\r
  21         BOOLEAN_decode_xer,\r
  22         BOOLEAN_encode_xer,\r
  23 #ifdef  ASN_DISABLE_OER_SUPPORT\r
  24         0,\r
  25         0,\r
  26 #else\r
  27         BOOLEAN_decode_oer,\r
  28         BOOLEAN_encode_oer,\r
  29 #endif  /* ASN_DISABLE_OER_SUPPORT */\r
  30 #ifdef  ASN_DISABLE_PER_SUPPORT\r
  31         0,\r
  32         0,\r
  33         0,\r
  34         0,\r
  35 #else\r
  36         BOOLEAN_decode_uper,    /* Unaligned PER decoder */\r
  37         BOOLEAN_encode_uper,    /* Unaligned PER encoder */\r
  38         BOOLEAN_decode_aper,    /* Aligned PER decoder */\r
  39         BOOLEAN_encode_aper,    /* Aligned PER encoder */\r
  40 #endif  /* ASN_DISABLE_PER_SUPPORT */\r
  41         BOOLEAN_random_fill,\r
  42         0       /* Use generic outmost tag fetcher */\r
  43 };\r
  44 asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {\r
  45         "BOOLEAN",\r
  46         "BOOLEAN",\r
  47         &asn_OP_BOOLEAN,\r
  48         asn_DEF_BOOLEAN_tags,\r
  49         sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),\r
  50         asn_DEF_BOOLEAN_tags,   /* Same as above */\r
  51         sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),\r
  52         { 0, 0, asn_generic_no_constraint },\r
  53         0, 0,   /* No members */\r
  54         0       /* No specifics */\r
  55 };\r
  56 \r
  57 /*\r
  58  * Decode BOOLEAN type.\r
  59  */\r
  60 asn_dec_rval_t\r
  61 BOOLEAN_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,\r
  62                    const asn_TYPE_descriptor_t *td, void **bool_value,\r
  63                    const void *buf_ptr, size_t size, int tag_mode) {\r
  64     BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;\r
  65         asn_dec_rval_t rval;\r
  66         ber_tlv_len_t length;\r
  67         ber_tlv_len_t lidx;\r
  68 \r
  69         if(st == NULL) {\r
  70                 st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));\r
  71                 if(st == NULL) {\r
  72                         rval.code = RC_FAIL;\r
  73                         rval.consumed = 0;\r
  74                         return rval;\r
  75                 }\r
  76         }\r
  77 \r
  78         ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",\r
  79                 td->name, tag_mode);\r
  80 \r
  81         /*\r
  82          * Check tags.\r
  83          */\r
  84         rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,\r
  85                 tag_mode, 0, &length, 0);\r
  86         if(rval.code != RC_OK)\r
  87                 return rval;\r
  88 \r
  89         ASN_DEBUG("Boolean length is %d bytes", (int)length);\r
  90 \r
  91         buf_ptr = ((const char *)buf_ptr) + rval.consumed;\r
  92         size -= rval.consumed;\r
  93         if(length > (ber_tlv_len_t)size) {\r
  94                 rval.code = RC_WMORE;\r
  95                 rval.consumed = 0;\r
  96                 return rval;\r
  97         }\r
  98 \r
  99         /*\r
 100          * Compute boolean value.\r
 101          */\r
 102         for(*st = 0, lidx = 0;\r
 103                 (lidx < length) && *st == 0; lidx++) {\r
 104                 /*\r
 105                  * Very simple approach: read bytes until the end or\r
 106                  * value is already TRUE.\r
 107                  * BOOLEAN is not supposed to contain meaningful data anyway.\r
 108                  */\r
 109                 *st |= ((const uint8_t *)buf_ptr)[lidx];\r
 110         }\r
 111 \r
 112         rval.code = RC_OK;\r
 113         rval.consumed += length;\r
 114 \r
 115         ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",\r
 116                 (long)rval.consumed, (long)length,\r
 117                 td->name, *st);\r
 118         \r
 119         return rval;\r
 120 }\r
 121 \r
 122 asn_enc_rval_t\r
 123 BOOLEAN_encode_der(const asn_TYPE_descriptor_t *td, const void *sptr,\r
 124                    int tag_mode, ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb,\r
 125                    void *app_key) {\r
 126         asn_enc_rval_t erval = {0,0,0};\r
 127         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
 128 \r
 129         erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);\r
 130         if(erval.encoded == -1) {\r
 131                 erval.failed_type = td;\r
 132                 erval.structure_ptr = sptr;\r
 133                 return erval;\r
 134         }\r
 135 \r
 136         if(cb) {\r
 137                 uint8_t bool_value;\r
 138 \r
 139                 bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */\r
 140 \r
 141                 if(cb(&bool_value, 1, app_key) < 0) {\r
 142                         erval.encoded = -1;\r
 143                         erval.failed_type = td;\r
 144                         erval.structure_ptr = sptr;\r
 145                         return erval;\r
 146                 }\r
 147         }\r
 148 \r
 149         erval.encoded += 1;\r
 150 \r
 151         ASN__ENCODED_OK(erval);\r
 152 }\r
 153 \r
 154 \r
 155 /*\r
 156  * Decode the chunk of XML text encoding INTEGER.\r
 157  */\r
 158 static enum xer_pbd_rval\r
 159 BOOLEAN__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,\r
 160                          const void *chunk_buf, size_t chunk_size) {\r
 161     BOOLEAN_t *st = (BOOLEAN_t *)sptr;\r
 162         const char *p = (const char *)chunk_buf;\r
 163 \r
 164         (void)td;\r
 165 \r
 166         if(chunk_size && p[0] == 0x3c /* '<' */) {\r
 167                 switch(xer_check_tag(chunk_buf, chunk_size, "false")) {\r
 168                 case XCT_BOTH:\r
 169                         /* "<false/>" */\r
 170                         *st = 0;\r
 171                         break;\r
 172                 case XCT_UNKNOWN_BO:\r
 173                         if(xer_check_tag(chunk_buf, chunk_size, "true")\r
 174                                         != XCT_BOTH)\r
 175                                 return XPBD_BROKEN_ENCODING;\r
 176                         /* "<true/>" */\r
 177                         *st = 1;        /* Or 0xff as in DER?.. */\r
 178                         break;\r
 179                 default:\r
 180                         return XPBD_BROKEN_ENCODING;\r
 181                 }\r
 182                 return XPBD_BODY_CONSUMED;\r
 183         } else {\r
 184                 return XPBD_BROKEN_ENCODING;\r
 185         }\r
 186 }\r
 187 \r
 188 \r
 189 asn_dec_rval_t\r
 190 BOOLEAN_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,\r
 191                    const asn_TYPE_descriptor_t *td, void **sptr,\r
 192                    const char *opt_mname, const void *buf_ptr, size_t size) {\r
 193     return xer_decode_primitive(opt_codec_ctx, td,\r
 194                 sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,\r
 195                 BOOLEAN__xer_body_decode);\r
 196 }\r
 197 \r
 198 asn_enc_rval_t\r
 199 BOOLEAN_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr,\r
 200         int ilevel, enum xer_encoder_flags_e flags,\r
 201                 asn_app_consume_bytes_f *cb, void *app_key) {\r
 202         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
 203         asn_enc_rval_t er = {0, 0, 0};\r
 204 \r
 205         (void)ilevel;\r
 206         (void)flags;\r
 207 \r
 208         if(!st) ASN__ENCODE_FAILED;\r
 209 \r
 210         if(*st) {\r
 211                 ASN__CALLBACK("<true/>", 7);\r
 212         } else {\r
 213                 ASN__CALLBACK("<false/>", 8);\r
 214         }\r
 215 \r
 216         ASN__ENCODED_OK(er);\r
 217 cb_failed:\r
 218         ASN__ENCODE_FAILED;\r
 219 }\r
 220 \r
 221 int\r
 222 BOOLEAN_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,\r
 223               asn_app_consume_bytes_f *cb, void *app_key) {\r
 224     const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
 225         const char *buf;\r
 226         size_t buflen;\r
 227 \r
 228         (void)td;       /* Unused argument */\r
 229         (void)ilevel;   /* Unused argument */\r
 230 \r
 231         if(st) {\r
 232                 if(*st) {\r
 233                         buf = "TRUE";\r
 234                         buflen = 4;\r
 235                 } else {\r
 236                         buf = "FALSE";\r
 237                         buflen = 5;\r
 238                 }\r
 239         } else {\r
 240                 buf = "<absent>";\r
 241                 buflen = 8;\r
 242         }\r
 243 \r
 244         return (cb(buf, buflen, app_key) < 0) ? -1 : 0;\r
 245 }\r
 246 \r
 247 void\r
 248 BOOLEAN_free(const asn_TYPE_descriptor_t *td, void *ptr,\r
 249              enum asn_struct_free_method method) {\r
 250     if(td && ptr) {\r
 251         switch(method) {\r
 252         case ASFM_FREE_EVERYTHING:\r
 253             FREEMEM(ptr);\r
 254             break;\r
 255         case ASFM_FREE_UNDERLYING:\r
 256             break;\r
 257         case ASFM_FREE_UNDERLYING_AND_RESET:\r
 258             memset(ptr, 0, sizeof(BOOLEAN_t));\r
 259             break;\r
 260         }\r
 261     }\r
 262 }\r
 263 \r
 264 #ifndef ASN_DISABLE_PER_SUPPORT\r
 265 \r
 266 asn_dec_rval_t\r
 267 BOOLEAN_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,\r
 268                     const asn_TYPE_descriptor_t *td,\r
 269                     const asn_per_constraints_t *constraints, void **sptr,\r
 270                     asn_per_data_t *pd) {\r
 271     asn_dec_rval_t rv;\r
 272         BOOLEAN_t *st = (BOOLEAN_t *)*sptr;\r
 273 \r
 274         (void)opt_codec_ctx;\r
 275     (void)td;\r
 276         (void)constraints;\r
 277 \r
 278         if(!st) {\r
 279                 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));\r
 280                 if(!st) ASN__DECODE_FAILED;\r
 281         }\r
 282 \r
 283         /*\r
 284          * Extract a single bit\r
 285          */\r
 286         switch(per_get_few_bits(pd, 1)) {\r
 287         case 1: *st = 1; break;\r
 288         case 0: *st = 0; break;\r
 289         case -1: default: ASN__DECODE_STARVED;\r
 290         }\r
 291 \r
 292         ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");\r
 293 \r
 294         rv.code = RC_OK;\r
 295         rv.consumed = 1;\r
 296         return rv;\r
 297 }\r
 298 \r
 299 \r
 300 asn_enc_rval_t\r
 301 BOOLEAN_encode_uper(const asn_TYPE_descriptor_t *td,\r
 302                     const asn_per_constraints_t *constraints, const void *sptr,\r
 303                     asn_per_outp_t *po) {\r
 304     const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
 305         asn_enc_rval_t er = { 0, 0, 0 };\r
 306 \r
 307         (void)constraints;\r
 308 \r
 309         if(!st) ASN__ENCODE_FAILED;\r
 310 \r
 311         if(per_put_few_bits(po, *st ? 1 : 0, 1))\r
 312                 ASN__ENCODE_FAILED;\r
 313 \r
 314         ASN__ENCODED_OK(er);\r
 315 }\r
 316 \r
 317 asn_dec_rval_t\r
 318 BOOLEAN_decode_aper(const asn_codec_ctx_t *opt_codec_ctx, const asn_TYPE_descriptor_t *td,\r
 319                     const asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {\r
 320         asn_dec_rval_t rv;\r
 321         BOOLEAN_t *st = (BOOLEAN_t *)*sptr;\r
 322 \r
 323         (void)opt_codec_ctx;\r
 324         (void)constraints;\r
 325         (void)td;\r
 326 \r
 327         if(!st) {\r
 328                 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));\r
 329                 if(!st) ASN__DECODE_FAILED;\r
 330         }\r
 331 \r
 332         /*\r
 333          * Extract a single bit\r
 334          */\r
 335         switch(per_get_few_bits(pd, 1)) {\r
 336         case 1:\r
 337                 *st = 1;\r
 338                 break;\r
 339         case 0:\r
 340                 *st = 0;\r
 341                 break;\r
 342         case -1:\r
 343         default:\r
 344                 ASN__DECODE_STARVED;\r
 345         }\r
 346 \r
 347         ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");\r
 348 \r
 349         rv.code = RC_OK;\r
 350         rv.consumed = 1;\r
 351         return rv;\r
 352 }\r
 353 \r
 354 asn_enc_rval_t\r
 355 BOOLEAN_encode_aper(const asn_TYPE_descriptor_t *td,\r
 356                     const asn_per_constraints_t *constraints,\r
 357                     const void *sptr, asn_per_outp_t *po) {\r
 358         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;\r
 359         asn_enc_rval_t er = { 0, 0, 0 };\r
 360 \r
 361         (void)constraints;\r
 362 \r
 363         if(!st) ASN__ENCODE_FAILED;\r
 364 \r
 365         if(per_put_few_bits(po, *st ? 1 : 0, 1))\r
 366                 ASN__ENCODE_FAILED;\r
 367 \r
 368         ASN__ENCODED_OK(er);\r
 369 }\r
 370 \r
 371 #endif /* ASN_DISABLE_PER_SUPPORT */\r
 372 \r
 373 #ifndef  ASN_DISABLE_OER_SUPPORT\r
 374 \r
 375 /*\r
 376  * Encode as Canonical OER.\r
 377  */\r
 378 asn_enc_rval_t\r
 379 BOOLEAN_encode_oer(const asn_TYPE_descriptor_t *td,\r
 380                    const asn_oer_constraints_t *constraints, const void *sptr,\r
 381                    asn_app_consume_bytes_f *cb, void *app_key) {\r
 382     asn_enc_rval_t er = { 1, 0, 0 };\r
 383     const BOOLEAN_t *st = sptr;\r
 384     uint8_t bool_value = *st ? 0xff : 0; /* 0xff mandated by OER */\r
 385 \r
 386     (void)td;\r
 387     (void)constraints;  /* Constraints are unused in OER */\r
 388 \r
 389     if(cb(&bool_value, 1, app_key) < 0) {\r
 390         ASN__ENCODE_FAILED;\r
 391     } else {\r
 392         ASN__ENCODED_OK(er);\r
 393     }\r
 394 }\r
 395 \r
 396 asn_dec_rval_t\r
 397 BOOLEAN_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,\r
 398                    const asn_TYPE_descriptor_t *td,\r
 399                    const asn_oer_constraints_t *constraints, void **sptr,\r
 400                    const void *ptr, size_t size) {\r
 401     asn_dec_rval_t ok = {RC_OK, 1};\r
 402     BOOLEAN_t *st;\r
 403 \r
 404     (void)opt_codec_ctx;\r
 405     (void)td;\r
 406     (void)constraints; /* Constraints are unused in OER */\r
 407 \r
 408     if(size < 1) {\r
 409         ASN__DECODE_STARVED;\r
 410     }\r
 411 \r
 412     if(!(st = *sptr)) {\r
 413         st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));\r
 414         if(!st) ASN__DECODE_FAILED;\r
 415     }\r
 416 \r
 417     *st = *(const uint8_t *)ptr;\r
 418 \r
 419     return ok;\r
 420 }\r
 421 \r
 422 \r
 423 \r
 424 #endif\r
 425 \r
 426 int\r
 427 BOOLEAN_compare(const asn_TYPE_descriptor_t *td, const void *aptr,\r
 428                 const void *bptr) {\r
 429     const BOOLEAN_t *a = aptr;\r
 430     const BOOLEAN_t *b = bptr;\r
 431 \r
 432     (void)td;\r
 433 \r
 434     if(a && b) {\r
 435         if(!*a == !*b) {    /* TRUE can be encoded by any non-zero byte. */\r
 436             return 0;\r
 437         } else if(!*a) {\r
 438             return -1;\r
 439         } else {\r
 440             return 1;\r
 441         }\r
 442     } else if(!a) {\r
 443         return -1;\r
 444     } else {\r
 445         return 1;\r
 446     }\r
 447 }\r
 448 \r
 449 asn_random_fill_result_t\r
 450 BOOLEAN_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,\r
 451                     const asn_encoding_constraints_t *constraints,\r
 452                     size_t max_length) {\r
 453     asn_random_fill_result_t result_ok = {ARFILL_OK, 1};\r
 454     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};\r
 455     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};\r
 456     BOOLEAN_t *st = *sptr;\r
 457 \r
 458     if(max_length == 0) return result_skipped;\r
 459 \r
 460     if(st == NULL) {\r
 461         st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));\r
 462         if(st == NULL) {\r
 463             return result_failed;\r
 464         }\r
 465     }\r
 466 \r
 467     if(!constraints || !constraints->per_constraints)\r
 468         constraints = &td->encoding_constraints;\r
 469     if(constraints->per_constraints) {\r
 470         const asn_per_constraint_t *pc = &constraints->per_constraints->value;\r
 471         if(pc->flags & APC_CONSTRAINED) {\r
 472             *st = asn_random_between(pc->lower_bound, pc->upper_bound);\r
 473             return result_ok;\r
 474         }\r
 475     }\r
 476 \r
 477     /* Simulate booleans that are sloppily set and biased. */\r
 478     switch(asn_random_between(0, 7)) {\r
 479     case 0:\r
 480     case 1:\r
 481     case 2:\r
 482         *st = 0; break;\r
 483     case 3: *st = -1; break;\r
 484     case 4: *st = 1; break;\r
 485     case 5: *st = INT_MIN; break;\r
 486     case 6: *st = INT_MAX; break;\r
 487     default:\r
 488         *st = asn_random_between(INT_MIN, INT_MAX);\r
 489         break;\r
 490     }\r
 491     return result_ok;\r
 492 }\r