E2AP code changes
[o-du/l2.git] / src / codec_utils / E2AP / constr_SEQUENCE_oer.c
1 /*
2  * Copyright (c) 2017 Lev Walkin <vlm@lionet.info>.
3  * All rights reserved.
4  * Redistribution and modifications are permitted subject to BSD license.
5  */
6 #ifndef ASN_DISABLE_OER_SUPPORT
7
8 #include <asn_internal.h>
9 #include <constr_SEQUENCE.h>
10 #include <OPEN_TYPE.h>
11 #include <errno.h>
12
13 /*
14  * This macro "eats" the part of the buffer which is definitely "consumed",
15  * i.e. was correctly converted into local representation or rightfully skipped.
16  */
17 #undef  ADVANCE
18 #define ADVANCE(num_bytes)                   \
19     do {                                     \
20         size_t num = num_bytes;              \
21         ptr = ((const char *)ptr) + num;     \
22         size -= num;                         \
23         consumed_myself += num;              \
24     } while(0)
25
26 /*
27  * Switch to the next phase of parsing.
28  */
29 #undef  NEXT_PHASE
30 #undef PHASE_OUT
31 #define NEXT_PHASE(ctx) \
32     do {                \
33         ctx->phase++;   \
34         ctx->step = 0;  \
35     } while(0)
36
37 /*
38  * Check whether we are inside the extensions group.
39  */
40 #define IN_EXTENSION_GROUP(specs, memb_idx) \
41     ((specs)->first_extension >= 0          \
42      && (unsigned)(specs)->first_extension <= (memb_idx))
43
44 #define IN_ROOT_GROUP_PRED(edx)                            \
45     edx < (specs->first_extension < 0 ? td->elements_count \
46                                       : (size_t)specs->first_extension)
47
48 #define FOR_IN_ROOT_GROUP(edx) for(edx = 0; IN_ROOT_GROUP_PRED(edx); edx++)
49
50 /*
51  * Return a standardized complex structure.
52  */
53 #undef  RETURN
54 #define RETURN(_code)   do {                    \
55                 rval.code = _code;              \
56                 rval.consumed = consumed_myself;\
57                 return rval;                    \
58         } while(0)
59
60 /*
61  * Return pointer to a member.
62  */
63 static void **
64 element_ptrptr(void *struct_ptr, asn_TYPE_member_t *elm, void **tmp_save_ptr) {
65     if(elm->flags & ATF_POINTER) {
66         /* Member is a pointer to another structure */
67         return (void **)((char *)struct_ptr + elm->memb_offset);
68     } else {
69         assert(tmp_save_ptr);
70         *tmp_save_ptr = (void *)((char *)struct_ptr + elm->memb_offset);
71         return tmp_save_ptr;
72     }
73 }
74
75 static const void *
76 element_ptr(const void *struct_ptr, const asn_TYPE_member_t *elm) {
77     if(elm->flags & ATF_POINTER) {
78         /* Member is a pointer to another structure */
79         return *(const void *const *)((const char *)struct_ptr
80                                       + elm->memb_offset);
81     } else {
82         return (const void *)((const char *)struct_ptr + elm->memb_offset);
83     }
84 }
85
86 asn_dec_rval_t
87 SEQUENCE_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
88                     const asn_TYPE_descriptor_t *td,
89                     const asn_oer_constraints_t *constraints, void **struct_ptr,
90                     const void *ptr, size_t size) {
91     const asn_SEQUENCE_specifics_t *specs =
92         (const asn_SEQUENCE_specifics_t *)td->specifics;
93     asn_dec_rval_t rval = {RC_OK, 0};
94     void *st = *struct_ptr; /* Target structure */
95     asn_struct_ctx_t *ctx; /* Decoder context */
96     size_t consumed_myself = 0; /* Consumed bytes from ptr. */
97
98     (void)constraints;
99
100     if(ASN__STACK_OVERFLOW_CHECK(opt_codec_ctx))
101         ASN__DECODE_FAILED;
102
103     /*
104      * Create the target structure if it is not present already.
105      */
106     if(st == 0) {
107         st = *struct_ptr = CALLOC(1, specs->struct_size);
108         if(st == 0) {
109             RETURN(RC_FAIL);
110         }
111     }
112
113     /*
114      * Restore parsing context.
115      */
116     ctx = (asn_struct_ctx_t *)((char *)st + specs->ctx_offset);
117
118     /*
119      * Start to parse where left previously.
120      */
121     switch(ctx->phase) {
122     case 0: {
123         /*
124          * Fetch preamble.
125          */
126         asn_bit_data_t *preamble;
127         int has_extensions_bit = (specs->first_extension >= 0);
128         size_t preamble_bits = (has_extensions_bit + specs->roms_count);
129         size_t preamble_bytes = ((7 + preamble_bits) >> 3);
130
131         ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 0", td->name);
132
133         ASN_DEBUG(
134             "Expecting preamble bits %" ASN_PRI_SIZE " for %s (including %d extension bits)",
135             preamble_bits, td->name, has_extensions_bit);
136
137         if(preamble_bytes > size) {
138             ASN__DECODE_STARVED;
139         }
140
141         preamble = asn_bit_data_new_contiguous(ptr, preamble_bits);
142         if(!preamble) {
143             RETURN(RC_FAIL);
144         }
145         preamble->nboff = has_extensions_bit;
146         ctx->ptr = preamble;
147         ADVANCE(preamble_bytes);
148     }
149         NEXT_PHASE(ctx);
150         /* FALL THROUGH */
151     case 1: {
152         /* Decode components of the extension root */
153         asn_bit_data_t *preamble = ctx->ptr;
154         size_t edx;
155
156         ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 1 (Root)", td->name);
157
158         assert(preamble);
159
160         for(edx = (ctx->step >> 1); IN_ROOT_GROUP_PRED(edx);
161             edx++, ctx->step = (ctx->step & ~1) + 2) {
162             asn_TYPE_member_t *elm = &td->elements[edx];
163
164             ASN_DEBUG("Decoding %s->%s", td->name, elm->name);
165
166             assert(!IN_EXTENSION_GROUP(specs, edx));
167
168             if(ctx->step & 1) {
169                 goto microphase2_decode_continues;
170             }
171
172
173             if(elm->optional) {
174                 int32_t present = asn_get_few_bits(preamble, 1);
175                 if(present < 0) {
176                     ASN_DEBUG("Presence map ended prematurely: %d", present);
177                     RETURN(RC_FAIL);
178                 } else if(present == 0) {
179                     if(elm->default_value_set) {
180                         /* Fill-in DEFAULT */
181                         void *tmp;
182                         if(elm->default_value_set(
183                                element_ptrptr(st, elm, &tmp))) {
184                             RETURN(RC_FAIL);
185                         }
186                     }
187                     /* The member is not present. */
188                     continue;
189                 }
190                 /* Present OPTIONAL or DEFAULT component. */
191             }
192
193             /*
194              * MICROPHASE 2: Invoke the member-specific decoder.
195              */
196             ctx->step |= 1; /* Confirm entering next microphase */
197         microphase2_decode_continues:
198             if(elm->flags & ATF_OPEN_TYPE) {
199                 rval = OPEN_TYPE_oer_get(opt_codec_ctx, td, st, elm, ptr, size);
200             } else {
201                 void *save_memb_ptr; /* Temporary reference. */
202                 void **memb_ptr2;  /* Pointer to a pointer to a memmber */
203
204                 memb_ptr2 = element_ptrptr(st, elm, &save_memb_ptr);
205
206                 rval = elm->type->op->oer_decoder(
207                     opt_codec_ctx, elm->type,
208                     elm->encoding_constraints.oer_constraints, memb_ptr2, ptr,
209                     size);
210             }
211             switch(rval.code) {
212             case RC_OK:
213                 ADVANCE(rval.consumed);
214                 break;
215             case RC_WMORE:
216                 ASN_DEBUG("More bytes needed at element %s \"%s\"", td->name,
217                           elm->name);
218                 ADVANCE(rval.consumed);
219                 RETURN(RC_WMORE);
220             case RC_FAIL:
221                 ASN_DEBUG("Decoding failed at element %s \"%s\"", td->name,
222                           elm->name);
223                 RETURN(RC_FAIL);
224             }
225         } /* for(all root members) */
226
227     }
228         NEXT_PHASE(ctx);
229         /* FALL THROUGH */
230     case 2:
231         assert(ctx->ptr);
232         {
233         /* Cleanup preamble. */
234         asn_bit_data_t *preamble = ctx->ptr;
235         asn_bit_data_t *extadds;
236         int has_extensions_bit = (specs->first_extension >= 0);
237         int extensions_present =
238             has_extensions_bit
239             && (preamble->buffer == NULL
240                 || (((const uint8_t *)preamble->buffer)[0] & 0x80));
241         uint8_t unused_bits;
242         size_t len = 0;
243         ssize_t len_len;
244
245         ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 2", td->name);
246
247         preamble->buffer = 0; /* Will do extensions_present==1 next time. */
248
249         if(!extensions_present) {
250             ctx->phase = 10;
251             RETURN(RC_OK);
252         }
253
254         /*
255          * X.696 (08/2015) #16.1 (c), #16.4
256          * Read in the extension addition presence bitmap.
257          */
258
259         len_len = oer_fetch_length(ptr, size, &len);
260         if(len_len > 0) {
261             ADVANCE(len_len);
262         } else if(len_len < 0) {
263             RETURN(RC_FAIL);
264         } else {
265             RETURN(RC_WMORE);
266         }
267
268         if(len == 0) {
269             /* 16.4.1-2 */
270             RETURN(RC_FAIL);
271         } else if(len > size) {
272             RETURN(RC_WMORE);
273         }
274
275         /* Account for unused bits */
276         unused_bits = 0x7 & *(const uint8_t *)ptr;
277         ADVANCE(1);
278         len--;
279         if(unused_bits && len == 0) {
280             RETURN(RC_FAIL);
281         }
282
283         /* Get the extensions map */
284         extadds = asn_bit_data_new_contiguous(ptr, len * 8 - unused_bits);
285         if(!extadds) {
286             RETURN(RC_FAIL);
287         }
288         FREEMEM(preamble);
289         ctx->ptr = extadds;
290         ADVANCE(len);
291     }
292         NEXT_PHASE(ctx);
293         ctx->step =
294             (specs->first_extension < 0 ? td->elements_count
295                                         : (size_t)specs->first_extension);
296         /* Fall through */
297     case 3:
298         ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 3 (Extensions)", td->name);
299         for(; ctx->step < (signed)td->elements_count; ctx->step++) {
300             asn_bit_data_t *extadds = ctx->ptr;
301             size_t edx = ctx->step;
302             asn_TYPE_member_t *elm = &td->elements[edx];
303             void *tmp_memb_ptr;
304             void **memb_ptr2 = element_ptrptr(st, elm, &tmp_memb_ptr);
305
306             switch(asn_get_few_bits(extadds, 1)) {
307             case -1:
308                 /*
309                  * Not every one of our extensions is known to the remote side.
310                  * Continue filling in their defaults though.
311                  */
312                 /* Fall through */
313             case 0:
314                 /* Fill-in DEFAULT */
315                 if(elm->default_value_set
316                    && elm->default_value_set(memb_ptr2)) {
317                     RETURN(RC_FAIL);
318                 }
319                 continue;
320             case 1: {
321                 /* Read OER open type */
322                 ssize_t ot_size =
323                     oer_open_type_get(opt_codec_ctx, elm->type,
324                                       elm->encoding_constraints.oer_constraints,
325                                       memb_ptr2, ptr, size);
326                 assert(ot_size <= (ssize_t)size);
327                 if(ot_size > 0) {
328                     ADVANCE(ot_size);
329                 } else if(ot_size < 0) {
330                     RETURN(RC_FAIL);
331                 } else {
332                     /* Roll back open type parsing */
333                     asn_get_undo(extadds, 1);
334                     RETURN(RC_WMORE);
335                 }
336                 break;
337             }
338             default:
339                 RETURN(RC_FAIL);
340             }
341         }
342
343         NEXT_PHASE(ctx);
344         /* Fall through */
345     case 4:
346         ASN_DEBUG("OER SEQUENCE %s Decoding PHASE 4", td->name);
347         /* Read in the rest of Open Types while ignoring them */
348         for(;;) {
349             asn_bit_data_t *extadds = ctx->ptr;
350             switch(asn_get_few_bits(extadds, 1)) {
351             case 0:
352                 continue;
353             case 1: {
354                 ssize_t skipped = oer_open_type_skip(ptr, size);
355                 if(skipped > 0) {
356                     ADVANCE(skipped);
357                 } else if(skipped < 0) {
358                     RETURN(RC_FAIL);
359                 } else {
360                     asn_get_undo(extadds, 1);
361                     RETURN(RC_WMORE);
362                 }
363                 continue;
364             }
365             case -1:
366                 /* No more Open Type encoded components */
367                 break;
368             default:
369                 RETURN(RC_FAIL);
370             }
371             break;
372         }
373     }
374
375     RETURN(RC_OK);
376 }
377
378 /*
379  * Encode as Canonical OER.
380  */
381 asn_enc_rval_t
382 SEQUENCE_encode_oer(const asn_TYPE_descriptor_t *td,
383                     const asn_oer_constraints_t *constraints, const void *sptr,
384                     asn_app_consume_bytes_f *cb, void *app_key) {
385     const asn_SEQUENCE_specifics_t *specs = (const asn_SEQUENCE_specifics_t *)td->specifics;
386     size_t computed_size = 0;
387     int has_extensions_bit = (specs->first_extension >= 0);
388     size_t preamble_bits = (has_extensions_bit + specs->roms_count);
389     uint32_t has_extensions = 0;
390     size_t edx;
391     int ret;
392
393     (void)constraints;
394
395     if(preamble_bits) {
396         asn_bit_outp_t preamble;
397
398         memset(&preamble, 0, sizeof(preamble));
399         preamble.output = cb;
400         preamble.op_key = app_key;
401
402         if(has_extensions_bit) {
403             for(edx = specs->first_extension; edx < td->elements_count; edx++) {
404                 asn_TYPE_member_t *elm = &td->elements[edx];
405                 const void *memb_ptr = element_ptr(sptr, elm);
406                 if(memb_ptr) {
407                     if(elm->default_value_cmp
408                        && elm->default_value_cmp(memb_ptr) == 0) {
409                         /* Do not encode default values in extensions */
410                     } else {
411                         has_extensions = 1;
412                         break;
413                     }
414                 }
415             }
416             ret = asn_put_few_bits(&preamble, has_extensions, 1);
417             assert(ret == 0);
418             if(ret < 0) {
419                 ASN__ENCODE_FAILED;
420             }
421         }
422
423         /*
424          * Encode optional components bitmap.
425          */
426         if(specs->roms_count) {
427             FOR_IN_ROOT_GROUP(edx) {
428                 asn_TYPE_member_t *elm = &td->elements[edx];
429
430                 if(IN_EXTENSION_GROUP(specs, edx)) break;
431
432                 if(elm->optional) {
433                     const void *memb_ptr = element_ptr(sptr, elm);
434                     uint32_t has_component = memb_ptr != NULL;
435                     if(has_component && elm->default_value_cmp
436                        && elm->default_value_cmp(memb_ptr) == 0) {
437                         has_component = 0;
438                     }
439                     ret = asn_put_few_bits(&preamble, has_component, 1);
440                     if(ret < 0) {
441                         ASN__ENCODE_FAILED;
442                     }
443                 }
444             }
445         }
446
447         asn_put_aligned_flush(&preamble);
448         computed_size += preamble.flushed_bytes;
449     }   /* if(preamble_bits) */
450
451     /*
452      * Put root components and extensions root.
453      */
454     for(edx = 0; edx < td->elements_count; edx++) {
455         asn_TYPE_member_t *elm = &td->elements[edx];
456         asn_enc_rval_t er = {0,0,0};
457         const void *memb_ptr;
458
459         if(IN_EXTENSION_GROUP(specs, edx)) break;
460
461         memb_ptr = element_ptr(sptr, elm);
462         if(memb_ptr) {
463             if(elm->default_value_cmp
464                && elm->default_value_cmp(memb_ptr) == 0) {
465                 /* Skip default values in encoding */
466                 continue;
467             }
468         } else {
469             if(elm->optional) continue;
470             /* Mandatory element is missing */
471             ASN__ENCODE_FAILED;
472         }
473         if(!elm->type->op->oer_encoder) {
474             ASN_DEBUG("OER encoder is not defined for type %s", elm->type->name);
475             ASN__ENCODE_FAILED;
476         }
477         er = elm->type->op->oer_encoder(
478             elm->type, elm->encoding_constraints.oer_constraints, memb_ptr, cb,
479             app_key);
480         if(er.encoded == -1) {
481             ASN_DEBUG("... while encoding %s member \"%s\"\n", td->name,
482                       elm->name);
483             return er;
484         }
485         computed_size += er.encoded;
486     }
487
488     /*
489      * Before encode extensions, encode extensions additions presense bitmap
490      # X.696 (08/2015) #16.4.
491      */
492     if(has_extensions) {
493         asn_bit_outp_t extadds;
494
495         /* Special case allowing us to use exactly one byte for #8.6 */
496         size_t aoms_length_bits = specs->aoms_count;
497         size_t aoms_length_bytes = (7 + aoms_length_bits) >> 3;
498         uint8_t unused_bits = 0x07 & (8 - (aoms_length_bits & 0x07));
499
500         assert(1 + aoms_length_bytes <= 127);
501
502         memset(&extadds, 0, sizeof(extadds));
503         extadds.output = cb;
504         extadds.op_key = app_key;
505
506         /* #8.6 length determinant */
507         ret = asn_put_few_bits(&extadds, (1 + aoms_length_bytes), 8);
508         if(ret < 0) ASN__ENCODE_FAILED;
509
510         /* Number of unused bytes, #16.4.2 */
511         ret = asn_put_few_bits(&extadds, unused_bits, 8);
512         if(ret < 0) ASN__ENCODE_FAILED;
513
514         /* Encode presence bitmap #16.4.3 */
515         for(edx = specs->first_extension; edx < td->elements_count; edx++) {
516             asn_TYPE_member_t *elm = &td->elements[edx];
517             const void *memb_ptr = element_ptr(sptr, elm);
518             if(memb_ptr && elm->default_value_cmp
519                && elm->default_value_cmp(memb_ptr) == 0) {
520                 memb_ptr = 0;   /* Do not encode default value. */
521             }
522             ret |= asn_put_few_bits(&extadds, memb_ptr ? 1 : 0, 1);
523         }
524         if(ret < 0) ASN__ENCODE_FAILED;
525
526         asn_put_aligned_flush(&extadds);
527         computed_size += extadds.flushed_bytes;
528
529         /* Now, encode extensions */
530         for(edx = specs->first_extension; edx < td->elements_count; edx++) {
531             asn_TYPE_member_t *elm = &td->elements[edx];
532             const void *memb_ptr = element_ptr(sptr, elm);
533
534             if(memb_ptr) {
535                 if(elm->default_value_cmp
536                    && elm->default_value_cmp(memb_ptr) == 0) {
537                     /* Do not encode default value. */
538                 } else {
539                     ssize_t wrote = oer_open_type_put(
540                         elm->type, elm->encoding_constraints.oer_constraints,
541                         memb_ptr, cb, app_key);
542                     if(wrote == -1) {
543                         ASN__ENCODE_FAILED;
544                     }
545                     computed_size += wrote;
546                 }
547             } else if(!elm->optional) {
548                 ASN__ENCODE_FAILED;
549             }
550         }
551     }   /* if(has_extensions) */
552
553
554     {
555         asn_enc_rval_t er = {0, 0, 0};
556         er.encoded = computed_size;
557         ASN__ENCODED_OK(er);
558     }
559 }
560
561 #endif  /* ASN_DISABLE_OER_SUPPORT */