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
5 #include <asn_internal.h>
\r
6 #include <asn_codecs_prim.h>
\r
10 * BOOLEAN basic type description.
\r
12 static const ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
\r
13 (ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
\r
15 asn_TYPE_operation_t asn_OP_BOOLEAN = {
\r
23 #ifdef ASN_DISABLE_OER_SUPPORT
\r
29 #endif /* ASN_DISABLE_OER_SUPPORT */
\r
30 #ifdef ASN_DISABLE_PER_SUPPORT
\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
44 asn_TYPE_descriptor_t asn_DEF_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
58 * Decode BOOLEAN type.
\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
70 st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
\r
72 rval.code = RC_FAIL;
\r
78 ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
\r
79 td->name, tag_mode);
\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
89 ASN_DEBUG("Boolean length is %d bytes", (int)length);
\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
100 * Compute boolean value.
\r
102 for(*st = 0, lidx = 0;
\r
103 (lidx < length) && *st == 0; lidx++) {
\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
109 *st |= ((const uint8_t *)buf_ptr)[lidx];
\r
113 rval.consumed += length;
\r
115 ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
\r
116 (long)rval.consumed, (long)length,
\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
126 asn_enc_rval_t erval = {0,0,0};
\r
127 const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
\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
137 uint8_t bool_value;
\r
139 bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
\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
149 erval.encoded += 1;
\r
151 ASN__ENCODED_OK(erval);
\r
156 * Decode the chunk of XML text encoding INTEGER.
\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
166 if(chunk_size && p[0] == 0x3c /* '<' */) {
\r
167 switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
\r
172 case XCT_UNKNOWN_BO:
\r
173 if(xer_check_tag(chunk_buf, chunk_size, "true")
\r
175 return XPBD_BROKEN_ENCODING;
\r
177 *st = 1; /* Or 0xff as in DER?.. */
\r
180 return XPBD_BROKEN_ENCODING;
\r
182 return XPBD_BODY_CONSUMED;
\r
184 return XPBD_BROKEN_ENCODING;
\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
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
208 if(!st) ASN__ENCODE_FAILED;
\r
211 ASN__CALLBACK("<true/>", 7);
\r
213 ASN__CALLBACK("<false/>", 8);
\r
216 ASN__ENCODED_OK(er);
\r
218 ASN__ENCODE_FAILED;
\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
228 (void)td; /* Unused argument */
\r
229 (void)ilevel; /* Unused argument */
\r
244 return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
\r
248 BOOLEAN_free(const asn_TYPE_descriptor_t *td, void *ptr,
\r
249 enum asn_struct_free_method method) {
\r
252 case ASFM_FREE_EVERYTHING:
\r
255 case ASFM_FREE_UNDERLYING:
\r
257 case ASFM_FREE_UNDERLYING_AND_RESET:
\r
258 memset(ptr, 0, sizeof(BOOLEAN_t));
\r
264 #ifndef ASN_DISABLE_PER_SUPPORT
\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
272 BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
\r
274 (void)opt_codec_ctx;
\r
279 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
\r
280 if(!st) ASN__DECODE_FAILED;
\r
284 * Extract a single bit
\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
292 ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
\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
309 if(!st) ASN__ENCODE_FAILED;
\r
311 if(per_put_few_bits(po, *st ? 1 : 0, 1))
\r
312 ASN__ENCODE_FAILED;
\r
314 ASN__ENCODED_OK(er);
\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
321 BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
\r
323 (void)opt_codec_ctx;
\r
328 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
\r
329 if(!st) ASN__DECODE_FAILED;
\r
333 * Extract a single bit
\r
335 switch(per_get_few_bits(pd, 1)) {
\r
344 ASN__DECODE_STARVED;
\r
347 ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
\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
363 if(!st) ASN__ENCODE_FAILED;
\r
365 if(per_put_few_bits(po, *st ? 1 : 0, 1))
\r
366 ASN__ENCODE_FAILED;
\r
368 ASN__ENCODED_OK(er);
\r
371 #endif /* ASN_DISABLE_PER_SUPPORT */
\r
373 #ifndef ASN_DISABLE_OER_SUPPORT
\r
376 * Encode as Canonical OER.
\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
387 (void)constraints; /* Constraints are unused in OER */
\r
389 if(cb(&bool_value, 1, app_key) < 0) {
\r
390 ASN__ENCODE_FAILED;
\r
392 ASN__ENCODED_OK(er);
\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
404 (void)opt_codec_ctx;
\r
406 (void)constraints; /* Constraints are unused in OER */
\r
409 ASN__DECODE_STARVED;
\r
412 if(!(st = *sptr)) {
\r
413 st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));
\r
414 if(!st) ASN__DECODE_FAILED;
\r
417 *st = *(const uint8_t *)ptr;
\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
435 if(!*a == !*b) { /* TRUE can be encoded by any non-zero byte. */
\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
458 if(max_length == 0) return result_skipped;
\r
461 st = (BOOLEAN_t *)(*sptr = CALLOC(1, sizeof(*st)));
\r
463 return result_failed;
\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
477 /* Simulate booleans that are sloppily set and biased. */
\r
478 switch(asn_random_between(0, 7)) {
\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
488 *st = asn_random_between(INT_MIN, INT_MAX);
\r