]> git.stg.codes - stg.git/blob - libs/smux/BOOLEAN.c
Fight Optional
[stg.git] / libs / smux / 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 const 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                 return XPBD_BROKEN_ENCODING;
165         }
166 }
167
168
169 asn_dec_rval_t
170 BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
171         asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
172                 const void *buf_ptr, size_t size) {
173
174         return xer_decode_primitive(opt_codec_ctx, td,
175                 sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
176                 BOOLEAN__xer_body_decode);
177 }
178
179 asn_enc_rval_t
180 BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
181         int ilevel, enum xer_encoder_flags_e flags,
182                 asn_app_consume_bytes_f *cb, void *app_key) {
183         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
184         asn_enc_rval_t er;
185
186         (void)ilevel;
187         (void)flags;
188
189         if(!st) ASN__ENCODE_FAILED;
190
191         if(*st) {
192                 ASN__CALLBACK("<true/>", 7);
193                 er.encoded = 7;
194         } else {
195                 ASN__CALLBACK("<false/>", 8);
196                 er.encoded = 8;
197         }
198
199         ASN__ENCODED_OK(er);
200 cb_failed:
201         ASN__ENCODE_FAILED;
202 }
203
204 int
205 BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
206         asn_app_consume_bytes_f *cb, void *app_key) {
207         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
208         const char *buf;
209         size_t buflen;
210
211         (void)td;       /* Unused argument */
212         (void)ilevel;   /* Unused argument */
213
214         if(st) {
215                 if(*st) {
216                         buf = "TRUE";
217                         buflen = 4;
218                 } else {
219                         buf = "FALSE";
220                         buflen = 5;
221                 }
222         } else {
223                 buf = "<absent>";
224                 buflen = 8;
225         }
226
227         return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
228 }
229
230 void
231 BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
232         if(td && ptr && !contents_only) {
233                 FREEMEM(ptr);
234         }
235 }
236
237 asn_dec_rval_t
238 BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
239         asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
240         asn_dec_rval_t rv;
241         BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
242
243         (void)opt_codec_ctx;
244         (void)constraints;
245
246         if(!st) {
247                 st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
248                 if(!st) ASN__DECODE_FAILED;
249         }
250
251         /*
252          * Extract a single bit
253          */
254         switch(per_get_few_bits(pd, 1)) {
255         case 1: *st = 1; break;
256         case 0: *st = 0; break;
257         case -1: default: ASN__DECODE_STARVED;
258         }
259
260         ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
261
262         rv.code = RC_OK;
263         rv.consumed = 1;
264         return rv;
265 }
266
267
268 asn_enc_rval_t
269 BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
270         asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
271         const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
272         asn_enc_rval_t er = { 0, 0, 0 };
273
274         (void)constraints;
275
276         if(!st) ASN__ENCODE_FAILED;
277
278         if(per_put_few_bits(po, *st ? 1 : 0, 1))
279                 ASN__ENCODE_FAILED;
280
281         ASN__ENCODED_OK(er);
282 }