]> git.stg.codes - stg.git/blob - libs/smux/asn_codecs_prim.c
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / libs / smux / asn_codecs_prim.c
1 /*-
2  * Copyright (c) 2003, 2004 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 <errno.h>
8
9 /*
10  * Decode an always-primitive type.
11  */
12 asn_dec_rval_t
13 ber_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
14                      const asn_TYPE_descriptor_t *td, void **sptr,
15                      const void *buf_ptr, size_t size, int tag_mode) {
16     ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)*sptr;
17         asn_dec_rval_t rval;
18         ber_tlv_len_t length = 0; /* =0 to avoid [incorrect] warning. */
19
20         /*
21          * If the structure is not there, allocate it.
22          */
23         if(st == NULL) {
24                 st = (ASN__PRIMITIVE_TYPE_t *)CALLOC(1, sizeof(*st));
25                 if(st == NULL) ASN__DECODE_FAILED;
26                 *sptr = (void *)st;
27         }
28
29         ASN_DEBUG("Decoding %s as plain primitive (tm=%d)",
30                 td->name, tag_mode);
31
32         /*
33          * Check tags and extract value length.
34          */
35         rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
36                         tag_mode, 0, &length, 0);
37         if(rval.code != RC_OK)
38                 return rval;
39
40         ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
41
42         /*
43          * Make sure we have this length.
44          */
45         buf_ptr = ((const char *)buf_ptr) + rval.consumed;
46         size -= rval.consumed;
47         if(length > (ber_tlv_len_t)size) {
48                 rval.code = RC_WMORE;
49                 rval.consumed = 0;
50                 return rval;
51         }
52
53         st->size = (int)length;
54         /* The following better be optimized away. */
55         if(sizeof(st->size) != sizeof(length)
56                         && (ber_tlv_len_t)st->size != length) {
57                 st->size = 0;
58                 ASN__DECODE_FAILED;
59         }
60
61         st->buf = (uint8_t *)MALLOC(length + 1);
62         if(!st->buf) {
63                 st->size = 0;
64                 ASN__DECODE_FAILED;
65         }
66
67         memcpy(st->buf, buf_ptr, length);
68         st->buf[length] = '\0';         /* Just in case */
69
70         rval.code = RC_OK;
71         rval.consumed += length;
72
73         ASN_DEBUG("Took %ld/%ld bytes to encode %s",
74                 (long)rval.consumed,
75                 (long)length, td->name);
76
77         return rval;
78 }
79
80 /*
81  * Encode an always-primitive type using DER.
82  */
83 asn_enc_rval_t
84 der_encode_primitive(const asn_TYPE_descriptor_t *td, const void *sptr,
85                      int tag_mode, ber_tlv_tag_t tag,
86                      asn_app_consume_bytes_f *cb, void *app_key) {
87     asn_enc_rval_t erval;
88         const ASN__PRIMITIVE_TYPE_t *st = (const ASN__PRIMITIVE_TYPE_t *)sptr;
89
90         ASN_DEBUG("%s %s as a primitive type (tm=%d)",
91                 cb?"Encoding":"Estimating", td->name, tag_mode);
92
93         erval.encoded = der_write_tags(td, st->size, tag_mode, 0, tag,
94                 cb, app_key);
95         ASN_DEBUG("%s wrote tags %d", td->name, (int)erval.encoded);
96         if(erval.encoded == -1) {
97                 erval.failed_type = td;
98                 erval.structure_ptr = sptr;
99                 return erval;
100         }
101
102         if(cb && st->buf) {
103                 if(cb(st->buf, st->size, app_key) < 0) {
104                         erval.encoded = -1;
105                         erval.failed_type = td;
106                         erval.structure_ptr = sptr;
107                         return erval;
108                 }
109         } else {
110                 assert(st->buf || st->size == 0);
111         }
112
113         erval.encoded += st->size;
114         ASN__ENCODED_OK(erval);
115 }
116
117 void
118 ASN__PRIMITIVE_TYPE_free(const asn_TYPE_descriptor_t *td, void *sptr,
119                          enum asn_struct_free_method method) {
120     ASN__PRIMITIVE_TYPE_t *st = (ASN__PRIMITIVE_TYPE_t *)sptr;
121
122         if(!td || !sptr)
123                 return;
124
125         ASN_DEBUG("Freeing %s as a primitive type", td->name);
126
127         if(st->buf)
128                 FREEMEM(st->buf);
129
130     switch(method) {
131     case ASFM_FREE_EVERYTHING:
132         FREEMEM(sptr);
133         break;
134     case ASFM_FREE_UNDERLYING:
135         break;
136     case ASFM_FREE_UNDERLYING_AND_RESET:
137         memset(sptr, 0, sizeof(ASN__PRIMITIVE_TYPE_t));
138         break;
139     }
140 }
141
142
143 /*
144  * Local internal type passed around as an argument.
145  */
146 struct xdp_arg_s {
147     const asn_TYPE_descriptor_t *type_descriptor;
148     void *struct_key;
149         xer_primitive_body_decoder_f *prim_body_decoder;
150         int decoded_something;
151         int want_more;
152 };
153
154 /*
155  * Since some kinds of primitive values can be encoded using value-specific
156  * tags (<MINUS-INFINITY>, <enum-element>, etc), the primitive decoder must
157  * be supplied with such tags to parse them as needed.
158  */
159 static int
160 xer_decode__unexpected_tag(void *key, const void *chunk_buf, size_t chunk_size) {
161         struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
162         enum xer_pbd_rval bret;
163
164         /*
165          * The chunk_buf is guaranteed to start at '<'.
166          */
167         assert(chunk_size && ((const char *)chunk_buf)[0] == 0x3c);
168
169         /*
170          * Decoding was performed once already. Prohibit doing it again.
171          */
172         if(arg->decoded_something)
173                 return -1;
174
175         bret = arg->prim_body_decoder(arg->type_descriptor,
176                 arg->struct_key, chunk_buf, chunk_size);
177         switch(bret) {
178         case XPBD_SYSTEM_FAILURE:
179         case XPBD_DECODER_LIMIT:
180         case XPBD_BROKEN_ENCODING:
181                 break;
182         case XPBD_BODY_CONSUMED:
183                 /* Tag decoded successfully */
184                 arg->decoded_something = 1;
185                 /* Fall through */
186         case XPBD_NOT_BODY_IGNORE:      /* Safe to proceed further */
187                 return 0;
188         }
189
190         return -1;
191 }
192
193 static ssize_t
194 xer_decode__primitive_body(void *key, const void *chunk_buf, size_t chunk_size, int have_more) {
195         struct xdp_arg_s *arg = (struct xdp_arg_s *)key;
196         enum xer_pbd_rval bret;
197         size_t lead_wsp_size;
198
199         if(arg->decoded_something) {
200                 if(xer_whitespace_span(chunk_buf, chunk_size) == chunk_size) {
201                         /*
202                          * Example:
203                          * "<INTEGER>123<!--/--> </INTEGER>"
204                          *                      ^- chunk_buf position.
205                          */
206                         return chunk_size;
207                 }
208                 /*
209                  * Decoding was done once already. Prohibit doing it again.
210                  */
211                 return -1;
212         }
213
214         if(!have_more) {
215                 /*
216                  * If we've received something like "1", we can't really
217                  * tell whether it is really `1` or `123`, until we know
218                  * that there is no more data coming.
219                  * The have_more argument will be set to 1 once something
220                  * like this is available to the caller of this callback:
221                  * "1<tag_start..."
222                  */
223                 arg->want_more = 1;
224                 return -1;
225         }
226
227         lead_wsp_size = xer_whitespace_span(chunk_buf, chunk_size);
228         chunk_buf = (const char *)chunk_buf + lead_wsp_size;
229         chunk_size -= lead_wsp_size;
230
231         bret = arg->prim_body_decoder(arg->type_descriptor,
232                 arg->struct_key, chunk_buf, chunk_size);
233         switch(bret) {
234         case XPBD_SYSTEM_FAILURE:
235         case XPBD_DECODER_LIMIT:
236         case XPBD_BROKEN_ENCODING:
237                 break;
238         case XPBD_BODY_CONSUMED:
239                 /* Tag decoded successfully */
240                 arg->decoded_something = 1;
241                 /* Fall through */
242         case XPBD_NOT_BODY_IGNORE:      /* Safe to proceed further */
243                 return lead_wsp_size + chunk_size;
244         }
245
246         return -1;
247 }
248
249
250 asn_dec_rval_t
251 xer_decode_primitive(const asn_codec_ctx_t *opt_codec_ctx,
252                      const asn_TYPE_descriptor_t *td, void **sptr,
253                      size_t struct_size, const char *opt_mname,
254                      const void *buf_ptr, size_t size,
255                      xer_primitive_body_decoder_f *prim_body_decoder) {
256     const char *xml_tag = opt_mname ? opt_mname : td->xml_tag;
257         asn_struct_ctx_t s_ctx;
258         struct xdp_arg_s s_arg;
259         asn_dec_rval_t rc;
260
261         /*
262          * Create the structure if does not exist.
263          */
264         if(!*sptr) {
265                 *sptr = CALLOC(1, struct_size);
266                 if(!*sptr) ASN__DECODE_FAILED;
267         }
268
269         memset(&s_ctx, 0, sizeof(s_ctx));
270         s_arg.type_descriptor = td;
271         s_arg.struct_key = *sptr;
272         s_arg.prim_body_decoder = prim_body_decoder;
273         s_arg.decoded_something = 0;
274         s_arg.want_more = 0;
275
276         rc = xer_decode_general(opt_codec_ctx, &s_ctx, &s_arg,
277                 xml_tag, buf_ptr, size,
278                 xer_decode__unexpected_tag, xer_decode__primitive_body);
279         switch(rc.code) {
280         case RC_OK:
281                 if(!s_arg.decoded_something) {
282                         char ch;
283                         ASN_DEBUG("Primitive body is not recognized, "
284                                 "supplying empty one");
285                         /*
286                          * Decoding opportunity has come and gone.
287                          * Where's the result?
288                          * Try to feed with empty body, see if it eats it.
289                          */
290                         if(prim_body_decoder(s_arg.type_descriptor,
291                                 s_arg.struct_key, &ch, 0)
292                                         != XPBD_BODY_CONSUMED) {
293                                 /*
294                                  * This decoder does not like empty stuff.
295                                  */
296                                 ASN__DECODE_FAILED;
297                         }
298                 }
299                 break;
300         case RC_WMORE:
301                 /*
302                  * Redo the whole thing later.
303                  * We don't have a context to save intermediate parsing state.
304                  */
305                 rc.consumed = 0;
306                 break;
307         case RC_FAIL:
308                 rc.consumed = 0;
309                 if(s_arg.want_more)
310                         rc.code = RC_WMORE;
311                 else
312                         ASN__DECODE_FAILED;
313                 break;
314         }
315         return rc;
316 }
317