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