]> git.stg.codes - stg.git/blob - libs/smux/BOOLEAN.c
bb4697c28ce12e647bec8dbeb0ff1a33bf565a7f
[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 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 }