]> git.stg.codes - stg.git/blob - libs/smux/OPEN_TYPE.c
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / libs / smux / OPEN_TYPE.c
1 /*
2  * Copyright (c) 2017 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 <OPEN_TYPE.h>
7 #include <constr_CHOICE.h>
8 #include <per_opentype.h>
9 #include <errno.h>
10
11 asn_TYPE_operation_t asn_OP_OPEN_TYPE = {
12         OPEN_TYPE_free,
13         OPEN_TYPE_print,
14         OPEN_TYPE_compare,
15         OPEN_TYPE_decode_ber,
16         OPEN_TYPE_encode_der,
17         OPEN_TYPE_decode_xer,
18         OPEN_TYPE_encode_xer,
19         0, 0,   /* No OER support, use "-gen-OER" to enable */
20 #ifdef ASN_DISABLE_PER_SUPPORT
21         0, 0,
22 #else
23         OPEN_TYPE_decode_uper,
24         OPEN_TYPE_encode_uper,
25 #endif
26         0,  /* Random fill is not supported for open type */
27         0,      /* Use generic outmost tag fetcher */
28 };
29
30 #undef  ADVANCE
31 #define ADVANCE(num_bytes)               \
32     do {                                 \
33         size_t num = num_bytes;          \
34         ptr = ((const char *)ptr) + num; \
35         size -= num;                     \
36         consumed_myself += num;          \
37     } while(0)
38
39 asn_dec_rval_t
40 OPEN_TYPE_ber_get(const asn_codec_ctx_t *opt_codec_ctx,
41                   const asn_TYPE_descriptor_t *td, void *sptr,
42                   const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
43     size_t consumed_myself = 0;
44     asn_type_selector_result_t selected;
45     void *memb_ptr;   /* Pointer to the member */
46     void **memb_ptr2; /* Pointer to that pointer */
47     void *inner_value;
48     asn_dec_rval_t rv;
49
50     if(!(elm->flags & ATF_OPEN_TYPE)) {
51         ASN__DECODE_FAILED;
52     }
53
54     if(!elm->type_selector) {
55         ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
56                   td->name, elm->name, elm->type->name);
57         ASN__DECODE_FAILED;
58     }
59
60     selected = elm->type_selector(td, sptr);
61     if(!selected.presence_index) {
62         ASN__DECODE_FAILED;
63     }
64
65     /* Fetch the pointer to this member */
66     if(elm->flags & ATF_POINTER) {
67         memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
68     } else {
69         memb_ptr = (char *)sptr + elm->memb_offset;
70         memb_ptr2 = &memb_ptr;
71     }
72     if(*memb_ptr2 != NULL) {
73         /* Make sure we reset the structure first before encoding */
74         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0) != 0) {
75             ASN__DECODE_FAILED;
76         }
77     }
78
79     inner_value =
80         (char *)*memb_ptr2
81         + elm->type->elements[selected.presence_index - 1].memb_offset;
82
83     ASN_DEBUG("presence %d\n", selected.presence_index);
84
85     rv = selected.type_descriptor->op->ber_decoder(
86         opt_codec_ctx, selected.type_descriptor, &inner_value, ptr, size,
87         elm->tag_mode);
88     ADVANCE(rv.consumed);
89     rv.consumed = 0;
90     switch(rv.code) {
91     case RC_OK:
92         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
93                                        selected.presence_index)
94            == 0) {
95             rv.code = RC_OK;
96             rv.consumed = consumed_myself;
97             return rv;
98         } else {
99             /* Oh, now a full-blown failure failure */
100         }
101         /* Fall through */
102     case RC_FAIL:
103         rv.consumed = consumed_myself;
104         /* Fall through */
105     case RC_WMORE:
106         break;
107     }
108
109     if(*memb_ptr2) {
110         const asn_CHOICE_specifics_t *specs =
111             selected.type_descriptor->specifics;
112         if(elm->flags & ATF_POINTER) {
113             ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
114             *memb_ptr2 = NULL;
115         } else {
116             ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
117                                           inner_value);
118             memset(*memb_ptr2, 0, specs->struct_size);
119         }
120     }
121     return rv;
122 }
123
124 asn_dec_rval_t
125 OPEN_TYPE_xer_get(const asn_codec_ctx_t *opt_codec_ctx,
126                   const asn_TYPE_descriptor_t *td, void *sptr,
127                   const asn_TYPE_member_t *elm, const void *ptr, size_t size) {
128     size_t consumed_myself = 0;
129     asn_type_selector_result_t selected;
130     void *memb_ptr;   /* Pointer to the member */
131     void **memb_ptr2; /* Pointer to that pointer */
132     void *inner_value;
133     asn_dec_rval_t rv;
134
135     int xer_context = 0;
136     ssize_t ch_size;
137     pxer_chunk_type_e ch_type;
138
139     if(!(elm->flags & ATF_OPEN_TYPE)) {
140         ASN__DECODE_FAILED;
141     }
142
143     if(!elm->type_selector) {
144         ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
145                   td->name, elm->name, elm->type->name);
146         ASN__DECODE_FAILED;
147     }
148
149     selected = elm->type_selector(td, sptr);
150     if(!selected.presence_index) {
151         ASN__DECODE_FAILED;
152     }
153
154     /* Fetch the pointer to this member */
155     assert(elm->flags == ATF_OPEN_TYPE);
156     if(elm->flags & ATF_POINTER) {
157         memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
158     } else {
159         memb_ptr = (char *)sptr + elm->memb_offset;
160         memb_ptr2 = &memb_ptr;
161     }
162     if(*memb_ptr2 != NULL) {
163         /* Make sure we reset the structure first before encoding */
164         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
165            != 0) {
166             ASN__DECODE_FAILED;
167         }
168     }
169
170     /*
171      * Confirm wrapper.
172      */
173     for(;;) {
174         ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
175         if(ch_size < 0) {
176             ASN__DECODE_FAILED;
177         } else {
178             switch(ch_type) {
179             case PXER_WMORE:
180                 ASN__DECODE_STARVED;
181             case PXER_COMMENT:
182             case PXER_TEXT:
183                 ADVANCE(ch_size);
184                 continue;
185             case PXER_TAG:
186                 break;
187             }
188             break;
189         }
190     }
191
192     /*
193      * Wrapper value confirmed.
194      */
195     switch(xer_check_tag(ptr, ch_size, elm->name)) {
196     case XCT_OPENING:
197         ADVANCE(ch_size);
198         break;
199     case XCT_BROKEN:
200     default:
201         ASN__DECODE_FAILED;
202     }
203
204     inner_value =
205         (char *)*memb_ptr2
206         + elm->type->elements[selected.presence_index - 1].memb_offset;
207
208     rv = selected.type_descriptor->op->xer_decoder(
209         opt_codec_ctx, selected.type_descriptor, &inner_value, NULL, ptr, size);
210     ADVANCE(rv.consumed);
211     rv.consumed = 0;
212     switch(rv.code) {
213     case RC_OK:
214         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
215                                        selected.presence_index)
216            == 0) {
217             break;
218         } else {
219             rv.code = RC_FAIL;
220         }
221         /* Fall through */
222     case RC_FAIL:
223         /* Point to a best position where failure occurred */
224         rv.consumed = consumed_myself;
225         /* Fall through */
226     case RC_WMORE:
227         /* Wrt. rv.consumed==0:
228          * In case a genuine RC_WMORE, the whole Open Type decoding
229          * will have to be restarted.
230          */
231         if(*memb_ptr2) {
232             const asn_CHOICE_specifics_t *specs =
233                 selected.type_descriptor->specifics;
234             if(elm->flags & ATF_POINTER) {
235                 ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
236                 *memb_ptr2 = NULL;
237             } else {
238                 ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
239                                               inner_value);
240                 memset(*memb_ptr2, 0, specs->struct_size);
241             }
242         }
243         return rv;
244     }
245
246     /*
247      * Finalize wrapper.
248      */
249     for(;;) {
250         ch_size = xer_next_token(&xer_context, ptr, size, &ch_type);
251         if(ch_size < 0) {
252             ASN__DECODE_FAILED;
253         } else {
254             switch(ch_type) {
255             case PXER_WMORE:
256                 ASN__DECODE_STARVED;
257             case PXER_COMMENT:
258             case PXER_TEXT:
259                 ADVANCE(ch_size);
260                 continue;
261             case PXER_TAG:
262                 break;
263             }
264             break;
265         }
266     }
267
268     /*
269      * Wrapper value confirmed.
270      */
271     switch(xer_check_tag(ptr, ch_size, elm->name)) {
272     case XCT_CLOSING:
273         ADVANCE(ch_size);
274         break;
275     case XCT_BROKEN:
276     default:
277         ASN__DECODE_FAILED;
278     }
279
280     rv.consumed += consumed_myself;
281
282     return rv;
283 }
284
285
286 #ifndef  ASN_DISABLE_PER_SUPPORT
287
288 asn_dec_rval_t
289 OPEN_TYPE_uper_get(const asn_codec_ctx_t *opt_codec_ctx,
290                    const asn_TYPE_descriptor_t *td, void *sptr,
291                    const asn_TYPE_member_t *elm, asn_per_data_t *pd) {
292     asn_type_selector_result_t selected;
293     void *memb_ptr;   /* Pointer to the member */
294     void **memb_ptr2; /* Pointer to that pointer */
295     void *inner_value;
296     asn_dec_rval_t rv;
297
298     if(!(elm->flags & ATF_OPEN_TYPE)) {
299         ASN__DECODE_FAILED;
300     }
301
302     if(!elm->type_selector) {
303         ASN_DEBUG("Type selector is not defined for Open Type %s->%s->%s",
304                   td->name, elm->name, elm->type->name);
305         ASN__DECODE_FAILED;
306     }
307
308     selected = elm->type_selector(td, sptr);
309     if(!selected.presence_index) {
310         ASN__DECODE_FAILED;
311     }
312
313     /* Fetch the pointer to this member */
314     assert(elm->flags == ATF_OPEN_TYPE);
315     if(elm->flags & ATF_POINTER) {
316         memb_ptr2 = (void **)((char *)sptr + elm->memb_offset);
317     } else {
318         memb_ptr = (char *)sptr + elm->memb_offset;
319         memb_ptr2 = &memb_ptr;
320     }
321     if(*memb_ptr2 != NULL) {
322         /* Make sure we reset the structure first before encoding */
323         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2, 0)
324            != 0) {
325             ASN__DECODE_FAILED;
326         }
327     }
328
329     inner_value =
330         (char *)*memb_ptr2
331         + elm->type->elements[selected.presence_index - 1].memb_offset;
332
333     rv = uper_open_type_get(opt_codec_ctx, selected.type_descriptor, NULL,
334                             &inner_value, pd);
335     switch(rv.code) {
336     case RC_OK:
337         if(CHOICE_variant_set_presence(elm->type, *memb_ptr2,
338                                        selected.presence_index)
339            == 0) {
340             break;
341         } else {
342             rv.code = RC_FAIL;
343         }
344         /* Fall through */
345     case RC_WMORE:
346     case RC_FAIL:
347         if(*memb_ptr2) {
348             const asn_CHOICE_specifics_t *specs =
349                 selected.type_descriptor->specifics;
350             if(elm->flags & ATF_POINTER) {
351                 ASN_STRUCT_FREE(*selected.type_descriptor, inner_value);
352                 *memb_ptr2 = NULL;
353             } else {
354                 ASN_STRUCT_FREE_CONTENTS_ONLY(*selected.type_descriptor,
355                                               inner_value);
356                 memset(*memb_ptr2, 0, specs->struct_size);
357             }
358         }
359     }
360     return rv;
361 }
362
363 asn_enc_rval_t
364 OPEN_TYPE_encode_uper(const asn_TYPE_descriptor_t *td,
365                       const asn_per_constraints_t *constraints,
366                       const void *sptr, asn_per_outp_t *po) {
367     const void *memb_ptr;   /* Pointer to the member */
368     asn_TYPE_member_t *elm; /* CHOICE's element */
369     asn_enc_rval_t er;
370     unsigned present;
371
372     (void)constraints;
373
374     present = CHOICE_variant_get_presence(td, sptr);
375     if(present == 0 || present > td->elements_count) {
376         ASN__ENCODE_FAILED;
377     } else {
378         present--;
379     }
380
381     ASN_DEBUG("Encoding %s OPEN TYPE element %d", td->name, present);
382
383     elm = &td->elements[present];
384     if(elm->flags & ATF_POINTER) {
385         /* Member is a pointer to another structure */
386         memb_ptr =
387             *(const void *const *)((const char *)sptr + elm->memb_offset);
388         if(!memb_ptr) ASN__ENCODE_FAILED;
389     } else {
390         memb_ptr = (const char *)sptr + elm->memb_offset;
391     }
392
393     if(uper_open_type_put(elm->type, NULL, memb_ptr, po) < 0) {
394         ASN__ENCODE_FAILED;
395     }
396
397     er.encoded = 0;
398     ASN__ENCODED_OK(er);
399 }
400
401
402 #endif  /* ASN_DISABLE_PER_SUPPORT */