]> git.stg.codes - stg.git/blob - libs/smux/per_opentype.c
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / libs / smux / per_opentype.c
1 /*
2  * Copyright (c) 2007 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 <per_support.h>
7 #include <constr_TYPE.h>
8 #include <per_opentype.h>
9
10 typedef struct uper_ugot_key {
11         asn_per_data_t oldpd;   /* Old per data source */
12         size_t unclaimed;
13         size_t ot_moved;        /* Number of bits moved by OT processing */
14         int repeat;
15 } uper_ugot_key;
16
17 static int uper_ugot_refill(asn_per_data_t *pd);
18 static int per_skip_bits(asn_per_data_t *pd, int skip_nbits);
19 static asn_dec_rval_t uper_sot_suck(const asn_codec_ctx_t *,
20                                     const asn_TYPE_descriptor_t *td,
21                                     const asn_per_constraints_t *constraints,
22                                     void **sptr, asn_per_data_t *pd);
23
24 /*
25  * Encode an "open type field".
26  * #10.1, #10.2
27  */
28 int
29 uper_open_type_put(const asn_TYPE_descriptor_t *td,
30                    const asn_per_constraints_t *constraints, const void *sptr,
31                    asn_per_outp_t *po) {
32     void *buf;
33     void *bptr;
34     ssize_t size;
35
36     ASN_DEBUG("Open type put %s ...", td->name);
37
38     size = uper_encode_to_new_buffer(td, constraints, sptr, &buf);
39     if(size <= 0) return -1;
40
41     ASN_DEBUG("Open type put %s of length %" ASN_PRI_SSIZE " + overhead (1byte?)", td->name,
42               size);
43
44     bptr = buf;
45     do {
46         int need_eom = 0;
47         ssize_t may_save = uper_put_length(po, size, &need_eom);
48         ASN_DEBUG("Prepending length %" ASN_PRI_SSIZE
49                   " to %s and allowing to save %" ASN_PRI_SSIZE,
50                   size, td->name, may_save);
51         if(may_save < 0) break;
52         if(per_put_many_bits(po, bptr, may_save * 8)) break;
53         bptr = (char *)bptr + may_save;
54         size -= may_save;
55         if(need_eom && uper_put_length(po, 0, 0)) {
56             FREEMEM(buf);
57             return -1;
58         }
59     } while(size);
60
61     FREEMEM(buf);
62     if(size) return -1;
63
64     return 0;
65 }
66
67 static asn_dec_rval_t
68 uper_open_type_get_simple(const asn_codec_ctx_t *ctx,
69                           const asn_TYPE_descriptor_t *td,
70                           const asn_per_constraints_t *constraints, void **sptr,
71                           asn_per_data_t *pd) {
72     asn_dec_rval_t rv;
73         ssize_t chunk_bytes;
74         int repeat;
75         uint8_t *buf = 0;
76         size_t bufLen = 0;
77         size_t bufSize = 0;
78         asn_per_data_t spd;
79         size_t padding;
80
81         ASN__STACK_OVERFLOW_CHECK(ctx);
82
83         ASN_DEBUG("Getting open type %s...", td->name);
84
85         do {
86                 chunk_bytes = uper_get_length(pd, -1, 0, &repeat);
87                 if(chunk_bytes < 0) {
88                         FREEMEM(buf);
89                         ASN__DECODE_STARVED;
90                 }
91                 if(bufLen + chunk_bytes > bufSize) {
92                         void *ptr;
93                         bufSize = chunk_bytes + (bufSize << 2);
94                         ptr = REALLOC(buf, bufSize);
95                         if(!ptr) {
96                                 FREEMEM(buf);
97                                 ASN__DECODE_FAILED;
98                         }
99                         buf = ptr;
100                 }
101                 if(per_get_many_bits(pd, buf + bufLen, 0, chunk_bytes << 3)) {
102                         FREEMEM(buf);
103                         ASN__DECODE_STARVED;
104                 }
105                 bufLen += chunk_bytes;
106         } while(repeat);
107
108         ASN_DEBUG("Getting open type %s encoded in %ld bytes", td->name,
109                 (long)bufLen);
110
111         memset(&spd, 0, sizeof(spd));
112         spd.buffer = buf;
113         spd.nbits = bufLen << 3;
114
115         ASN_DEBUG_INDENT_ADD(+4);
116         rv = td->op->uper_decoder(ctx, td, constraints, sptr, &spd);
117         ASN_DEBUG_INDENT_ADD(-4);
118
119         if(rv.code == RC_OK) {
120                 /* Check padding validity */
121                 padding = spd.nbits - spd.nboff;
122                 if ((padding < 8 ||
123                 /* X.691#10.1.3 */
124                 (spd.nboff == 0 && spd.nbits == 8 && spd.buffer == buf)) &&
125                     per_get_few_bits(&spd, padding) == 0) {
126                         /* Everything is cool */
127                         FREEMEM(buf);
128                         return rv;
129                 }
130                 FREEMEM(buf);
131                 if(padding >= 8) {
132                         ASN_DEBUG("Too large padding %d in open type", (int)padding);
133                         ASN__DECODE_FAILED;
134                 } else {
135                         ASN_DEBUG("Non-zero padding");
136                         ASN__DECODE_FAILED;
137                 }
138         } else {
139                 FREEMEM(buf);
140                 /* rv.code could be RC_WMORE, nonsense in this context */
141                 rv.code = RC_FAIL; /* Noone would give us more */
142         }
143
144         return rv;
145 }
146
147 static asn_dec_rval_t CC_NOTUSED
148 uper_open_type_get_complex(const asn_codec_ctx_t *ctx,
149                            const asn_TYPE_descriptor_t *td,
150                            asn_per_constraints_t *constraints, void **sptr,
151                            asn_per_data_t *pd) {
152     uper_ugot_key arg;
153         asn_dec_rval_t rv;
154         ssize_t padding;
155
156         ASN__STACK_OVERFLOW_CHECK(ctx);
157
158         ASN_DEBUG("Getting open type %s from %s", td->name,
159                 asn_bit_data_string(pd));
160         arg.oldpd = *pd;
161         arg.unclaimed = 0;
162         arg.ot_moved = 0;
163         arg.repeat = 1;
164         pd->refill = uper_ugot_refill;
165         pd->refill_key = &arg;
166         pd->nbits = pd->nboff;  /* 0 good bits at this point, will refill */
167         pd->moved = 0;  /* This now counts the open type size in bits */
168
169         ASN_DEBUG_INDENT_ADD(+4);
170         rv = td->op->uper_decoder(ctx, td, constraints, sptr, pd);
171         ASN_DEBUG_INDENT_ADD(-4);
172
173 #define UPDRESTOREPD    do {                                            \
174         /* buffer and nboff are valid, preserve them. */                \
175         pd->nbits = arg.oldpd.nbits - (pd->moved - arg.ot_moved);       \
176         pd->moved = arg.oldpd.moved + (pd->moved - arg.ot_moved);       \
177         pd->refill = arg.oldpd.refill;                                  \
178         pd->refill_key = arg.oldpd.refill_key;                          \
179   } while(0)
180
181         if(rv.code != RC_OK) {
182                 UPDRESTOREPD;
183                 return rv;
184         }
185
186         ASN_DEBUG("OpenType %s pd%s old%s unclaimed=%d, repeat=%d", td->name,
187                 asn_bit_data_string(pd),
188                 asn_bit_data_string(&arg.oldpd),
189                 (int)arg.unclaimed, (int)arg.repeat);
190
191         padding = pd->moved % 8;
192         if(padding) {
193                 int32_t pvalue;
194                 if(padding > 7) {
195                         ASN_DEBUG("Too large padding %d in open type",
196                                 (int)padding);
197                         rv.code = RC_FAIL;
198                         UPDRESTOREPD;
199                         return rv;
200                 }
201                 padding = 8 - padding;
202                 ASN_DEBUG("Getting padding of %d bits", (int)padding);
203                 pvalue = per_get_few_bits(pd, padding);
204                 switch(pvalue) {
205                 case -1:
206                         ASN_DEBUG("Padding skip failed");
207                         UPDRESTOREPD;
208                         ASN__DECODE_STARVED;
209                 case 0: break;
210                 default:
211                         ASN_DEBUG("Non-blank padding (%d bits 0x%02x)",
212                                 (int)padding, (int)pvalue);
213                         UPDRESTOREPD;
214                         ASN__DECODE_FAILED;
215                 }
216         }
217         if(pd->nboff != pd->nbits) {
218                 ASN_DEBUG("Open type %s overhead pd%s old%s", td->name,
219                         asn_bit_data_string(pd), asn_bit_data_string(&arg.oldpd));
220                 if(1) {
221                         UPDRESTOREPD;
222                         ASN__DECODE_FAILED;
223                 } else {
224                         arg.unclaimed += pd->nbits - pd->nboff;
225                 }
226         }
227
228         /* Adjust pd back so it points to original data */
229         UPDRESTOREPD;
230
231         /* Skip data not consumed by the decoder */
232         if(arg.unclaimed) {
233                 ASN_DEBUG("Getting unclaimed %d", (int)arg.unclaimed);
234                 switch(per_skip_bits(pd, arg.unclaimed)) {
235                 case -1:
236                         ASN_DEBUG("Claim of %d failed", (int)arg.unclaimed);
237                         ASN__DECODE_STARVED;
238                 case 0:
239                         ASN_DEBUG("Got claim of %d", (int)arg.unclaimed);
240                         break;
241                 default:
242                         /* Padding must be blank */
243                         ASN_DEBUG("Non-blank unconsumed padding");
244                         ASN__DECODE_FAILED;
245                 }
246                 arg.unclaimed = 0;
247         }
248
249         if(arg.repeat) {
250                 ASN_DEBUG("Not consumed the whole thing");
251                 rv.code = RC_FAIL;
252                 return rv;
253         }
254
255         return rv;
256 }
257
258
259 asn_dec_rval_t
260 uper_open_type_get(const asn_codec_ctx_t *ctx, const asn_TYPE_descriptor_t *td,
261                    const asn_per_constraints_t *constraints, void **sptr,
262                    asn_per_data_t *pd) {
263     return uper_open_type_get_simple(ctx, td, constraints, sptr, pd);
264 }
265
266 int
267 uper_open_type_skip(const asn_codec_ctx_t *ctx, asn_per_data_t *pd) {
268         asn_TYPE_descriptor_t s_td;
269     asn_TYPE_operation_t s_op;
270         asn_dec_rval_t rv;
271
272         s_td.name = "<unknown extension>";
273         s_td.op = &s_op;
274     s_op.uper_decoder = uper_sot_suck;
275
276         rv = uper_open_type_get(ctx, &s_td, 0, 0, pd);
277         if(rv.code != RC_OK)
278                 return -1;
279         else
280                 return 0;
281 }
282
283 /*
284  * Internal functions.
285  */
286
287 static asn_dec_rval_t
288 uper_sot_suck(const asn_codec_ctx_t *ctx, const asn_TYPE_descriptor_t *td,
289               const asn_per_constraints_t *constraints, void **sptr,
290               asn_per_data_t *pd) {
291     asn_dec_rval_t rv;
292
293         (void)ctx;
294         (void)td;
295         (void)constraints;
296         (void)sptr;
297
298         while(per_get_few_bits(pd, 24) >= 0);
299
300         rv.code = RC_OK;
301         rv.consumed = pd->moved;
302
303         return rv;
304 }
305
306 static int
307 uper_ugot_refill(asn_per_data_t *pd) {
308         uper_ugot_key *arg = pd->refill_key;
309         ssize_t next_chunk_bytes, next_chunk_bits;
310         ssize_t avail;
311
312         asn_per_data_t *oldpd = &arg->oldpd;
313
314         ASN_DEBUG("REFILLING pd->moved=%ld, oldpd->moved=%ld",
315                 (long)pd->moved, (long)oldpd->moved);
316
317         /* Advance our position to where pd is */
318         oldpd->buffer = pd->buffer;
319         oldpd->nboff  = pd->nboff;
320         oldpd->nbits -= pd->moved - arg->ot_moved;
321         oldpd->moved += pd->moved - arg->ot_moved;
322         arg->ot_moved = pd->moved;
323
324         if(arg->unclaimed) {
325                 /* Refill the container */
326                 if(per_get_few_bits(oldpd, 1))
327                         return -1;
328                 if(oldpd->nboff == 0) {
329                         assert(0);
330                         return -1;
331                 }
332                 pd->buffer = oldpd->buffer;
333                 pd->nboff = oldpd->nboff - 1;
334                 pd->nbits = oldpd->nbits;
335                 ASN_DEBUG("UNCLAIMED <- return from (pd->moved=%ld)",
336                         (long)pd->moved);
337                 return 0;
338         }
339
340         if(!arg->repeat) {
341                 ASN_DEBUG("Want more but refill doesn't have it");
342                 return -1;
343         }
344
345         next_chunk_bytes = uper_get_length(oldpd, -1, 0, &arg->repeat);
346         ASN_DEBUG("Open type LENGTH %ld bytes at off %ld, repeat %ld",
347                 (long)next_chunk_bytes, (long)oldpd->moved, (long)arg->repeat);
348         if(next_chunk_bytes < 0) return -1;
349         if(next_chunk_bytes == 0) {
350                 pd->refill = 0; /* No more refills, naturally */
351                 assert(!arg->repeat);   /* Implementation guarantee */
352         }
353         next_chunk_bits = next_chunk_bytes << 3;
354         avail = oldpd->nbits - oldpd->nboff;
355         if(avail >= next_chunk_bits) {
356                 pd->nbits = oldpd->nboff + next_chunk_bits;
357                 arg->unclaimed = 0;
358                 ASN_DEBUG("!+Parent frame %ld bits, alloting %ld [%ld..%ld] (%ld)",
359                         (long)next_chunk_bits, (long)oldpd->moved,
360                         (long)oldpd->nboff, (long)oldpd->nbits,
361                         (long)(oldpd->nbits - oldpd->nboff));
362         } else {
363                 pd->nbits = oldpd->nbits;
364                 arg->unclaimed = next_chunk_bits - avail;
365                 ASN_DEBUG("!-Parent frame %ld, require %ld, will claim %ld",
366                         (long)avail, (long)next_chunk_bits,
367                         (long)arg->unclaimed);
368         }
369         pd->buffer = oldpd->buffer;
370         pd->nboff = oldpd->nboff;
371         ASN_DEBUG("Refilled pd%s old%s",
372                 asn_bit_data_string(pd), asn_bit_data_string(oldpd));
373         return 0;
374 }
375
376 static int
377 per_skip_bits(asn_per_data_t *pd, int skip_nbits) {
378         int hasNonZeroBits = 0;
379         while(skip_nbits > 0) {
380                 int skip;
381
382                 /* per_get_few_bits() is more efficient when nbits <= 24 */
383                 if(skip_nbits < 24)
384                         skip = skip_nbits;
385                 else
386                         skip = 24;
387                 skip_nbits -= skip;
388
389                 switch(per_get_few_bits(pd, skip)) {
390                 case -1: return -1;     /* Starving */
391                 case 0: continue;       /* Skipped empty space */
392                 default: hasNonZeroBits = 1; continue;
393                 }
394         }
395         return hasNonZeroBits;
396 }