aper_support.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
3  * Redistribution and modifications are permitted subject to BSD license.
4  */
5 #include <etsi_its_vam_ts_coding/asn_system.h>
6 #include <etsi_its_vam_ts_coding/asn_internal.h>
7 #include <etsi_its_vam_ts_coding/aper_support.h>
8 
9 int32_t
10 aper_get_align(asn_per_data_t *pd) {
11 
12  if(pd->nboff & 0x7) {
13  ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)pd->nboff & 0x7));
14  return per_get_few_bits(pd, 8 - (pd->nboff & 0x7));
15  }
16  return 0;
17 }
18 
19 ssize_t
20 aper_get_length(asn_per_data_t *pd, ssize_t lb, ssize_t ub,
21  int ebits, int *repeat) {
22  int constrained = (lb >= 0) && (ub >= 0);
23  ssize_t value;
24 
25  *repeat = 0;
26 
27  if (constrained && ub < 65536) {
28  return aper_get_constrained_whole_number(pd, lb, ub);
29  }
30 
31  if (aper_get_align(pd) < 0)
32  return -1;
33 
34  if(ebits >= 0) return per_get_few_bits(pd, ebits);
35 
36  value = per_get_few_bits(pd, 8);
37  if(value < 0) return -1;
38  if((value & 128) == 0) /* #11.9.3.6 */
39  return (value & 0x7F);
40  if((value & 64) == 0) { /* #11.9.3.7 */
41  value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
42  if(value < 0) return -1;
43  return value;
44  }
45  value &= 63; /* this is "m" from X.691, #11.9.3.8 */
46  if(value < 1 || value > 4)
47  return -1;
48  *repeat = 1;
49  return (16384 * value);
50 }
51 
52 ssize_t
53 aper_get_nslength(asn_per_data_t *pd) {
54  ssize_t length;
55 
56  ASN_DEBUG("Getting normally small length");
57 
58  if(per_get_few_bits(pd, 1) == 0) {
59  length = per_get_few_bits(pd, 6) + 1;
60  if(length <= 0) return -1;
61  ASN_DEBUG("l=%zd", length);
62  return length;
63  } else {
64  int repeat;
65  length = aper_get_length(pd, -1, -1, -1, &repeat);
66  if(length >= 0 && !repeat) return length;
67  return -1; /* Error, or do not support >16K extensions */
68  }
69 }
70 
71 ssize_t
72 aper_get_nsnnwn(asn_per_data_t *pd) {
73  int b;
74  int length;
75 
76  ASN_DEBUG("getting nsnnwn");
77 
78  b = per_get_few_bits(pd, 1);
79  if (b == -1)
80  return -1;
81 
82  /* X.691 2002 10.6.1 */
83  if (b == 0)
84  return per_get_few_bits(pd, 6);
85 
86  if (aper_get_align(pd) < 0)
87  return -1;
88 
89  /* X.691 2002 10.6.2 */
90  /* X.691 2002 10.9.3.5 */
91  b = per_get_few_bits(pd, 1);
92  if (b == -1)
93  return -1;
94 
95  if (b == 1) {
96  /* other 10.9.3.x cases not handled, it's doubtful we reach them in practice */
97  ASN_DEBUG("todo: X.691 2002 10.9.3.x");
98  return -1;
99  }
100 
101  /* X.691 2002 10.9.3.6 */
102  length = per_get_few_bits(pd, 7);
103  if (length > 4) {
104  /* todo */
105  ASN_DEBUG("todo: X.691 2002 10.9.3.6 for length > 4");
106  return -1;
107  }
108  ASN_DEBUG("length %d\n", length);
109 
110  /* todo: 0xffffffff will be seen as -1 and will lead to decoding failure */
111  return per_get_few_bits(pd, length * 8);
112 }
113 
114 /* X.691 2002 10.5 - Decoding of a constrained whole number */
115 long
116 aper_get_constrained_whole_number(asn_per_data_t *pd, long lb, long ub) {
117  assert(ub >= lb);
118  long range = ub - lb + 1;
119  int range_len;
120  int value_len;
121  long value;
122 
123  ASN_DEBUG("aper get constrained_whole_number with lb %ld and ub %ld", lb, ub);
124 
125  /* X.691 2002 10.5.4 */
126  if (range == 1)
127  return lb;
128 
129  /* X.691 2002 10.5.7.1 - The bit-field case. */
130  if (range <= 255) {
131  int bitfield_size = 8;
132  for (bitfield_size = 8; bitfield_size >= 2; bitfield_size--)
133  if ((range - 1) & (1 << (bitfield_size-1)))
134  break;
135  value = per_get_few_bits(pd, bitfield_size);
136  if (value < 0 || value >= range)
137  return -1;
138  return value + lb;
139  }
140 
141  /* X.691 2002 10.5.7.2 - The one-octet case. */
142  if (range == 256) {
143  if (aper_get_align(pd) < 0)
144  return -1;
145  value = per_get_few_bits(pd, 8);
146  if (value < 0 || value >= range)
147  return -1;
148  return value + lb;
149  }
150 
151  /* X.691 2002 10.5.7.3 - The two-octet case. */
152  if (range <= 65536) {
153  if (aper_get_align(pd) < 0)
154  return -1;
155  value = per_get_few_bits(pd, 16);
156  if (value < 0 || value >= range)
157  return -1;
158  return value + lb;
159  }
160 
161  /* X.691 2002 10.5.7.4 - The indefinite length case. */
162  /* since we limit input to be 'long' we don't handle all numbers */
163  /* and so length determinant is retrieved as X.691 2002 10.9.3.3 */
164  /* number of bytes to store the range */
165  for (range_len = 3; ; range_len++) {
166  long bits = ((long)1) << (8 * range_len);
167  if (range - 1 < bits)
168  break;
169  }
170  value_len = aper_get_constrained_whole_number(pd, 1, range_len);
171  if (value_len == -1)
172  return -1;
173  if (value_len > 4) {
174  ASN_DEBUG("todo: aper_get_constrained_whole_number: value_len > 4");
175  return -1;
176  }
177  if (aper_get_align(pd) < 0)
178  return -1;
179  value = per_get_few_bits(pd, value_len * 8);
180  if (value < 0 || value >= range)
181  return -1;
182  return value + lb;
183 }
184 
185 int aper_put_align(asn_per_outp_t *po) {
186 
187  if(po->nboff & 0x7) {
188  ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)po->nboff & 0x7));
189  if(per_put_few_bits(po, 0x00, (8 - (po->nboff & 0x7))))
190  return -1;
191  }
192  return 0;
193 }
194 
195 ssize_t
196 aper_put_length(asn_per_outp_t *po, ssize_t lb, ssize_t ub, size_t n, int *need_eom) {
197  int constrained = (lb >= 0) && (ub >= 0);
198  int dummy = 0;
199  if(!need_eom) need_eom = &dummy;
200 
201  *need_eom = 0;
202 
203 
204  ASN_DEBUG("APER put length %zu with range (%zd..%zd)", n, lb, ub);
205 
206  /* X.691 2002 10.9.3.3 */
207  if (constrained && ub < 65536)
208  return aper_put_constrained_whole_number(po, lb, ub, n + lb) ? -1 : (ssize_t)n;
209 
210  if (aper_put_align(po) < 0)
211  return -1;
212 
213  if(n <= 127) { /* #11.9.3.6 */
214  return per_put_few_bits(po, n, 8)
215  ? -1 : (ssize_t)n;
216  }
217  else if(n < 16384) /* #11.9.3.7 */
218  return per_put_few_bits(po, n|0x8000, 16)
219  ? -1 : (ssize_t)n;
220 
221  *need_eom = 0 == (n & 16383);
222  n >>= 14;
223  if(n > 4) {
224  *need_eom = 0;
225  n = 4;
226  }
227 
228  return per_put_few_bits(po, 0xC0 | n, 8)
229  ? -1 : (ssize_t)(n << 14);
230 }
231 
232 
233 int
234 aper_put_nslength(asn_per_outp_t *po, size_t length) {
235 
236  if(length <= 64) {
237  /* #11.9.3.4 */
238  if(length == 0) return -1;
239  return per_put_few_bits(po, length-1, 7) ? -1 : 0;
240  } else {
241  if(aper_put_length(po, -1, -1, length, NULL) != (ssize_t)length) {
242  /* This might happen in case of >16K extensions */
243  return -1;
244  }
245  }
246 
247  return 0;
248 }
249 
250 int
251 aper_put_nsnnwn(asn_per_outp_t *po, int number) {
252  int len;
253 
254  ASN_DEBUG("aper put nsnnwn %d", number);
255 
256  if (number <= 63) {
257  if (per_put_few_bits(po, 0, 1))
258  return -1;
259  return per_put_few_bits(po, number, 6);
260  }
261 
262  if (per_put_few_bits(po, 1, 1))
263  return -1;
264 
265  if (number < 256) {
266  len = 1;
267  } else if (number < 65536) {
268  len = 2;
269  } else { /* number > 64K */
270  int i;
271  for (i = 3; ; i++) {
272  int bits = 1 << (8 * i);
273  if (number < bits)
274  break;
275  }
276  len = i;
277  }
278 
279  if (aper_put_align(po) < 0)
280  return -1;
281 
282  /* put the length which is a non-constrained whole number */
283  if (len <= 127) {
284  if(per_put_few_bits(po, 0, 1))
285  return -1;
286  if(per_put_few_bits(po, len, 7))
287  return -1;
288  } else {
289  /* todo but not big problem, it's very doubtful that the
290  * number of bytes to encode 'number' will be > 127
291  */
292  return -1;
293  }
294  if(aper_put_align(po) < 0) /* Aligning on octet */
295  return -1;
296  return per_put_few_bits(po, number, 8 * len);
297 }
298 
299 /* X.691 2002 10.5 - Encoding of a constrained whole number */
300 int
301 aper_put_constrained_whole_number(asn_per_outp_t *po, long lb, long ub, long number) {
302  assert(ub >= lb);
303  long range = ub - lb + 1;
304  long value = number - lb;
305  int range_len;
306  int value_len;
307 
308  ASN_DEBUG("aper put constrained_whole_number %ld with lb %ld and ub %ld", number, lb, ub);
309 
310  if (number < lb || number > ub)
311  return -1;
312 
313  /* X.691 2002 10.5.4 */
314  if (range == 1)
315  return 0;
316 
317  /* X.691 2002 10.5.7.1 - The bit-field case. */
318  if (range <= 255) {
319  int bitfield_size = 8;
320  for (bitfield_size = 8; bitfield_size >= 2; bitfield_size--)
321  if ((range - 1) & (1 << (bitfield_size-1)))
322  break;
323  return per_put_few_bits(po, value, bitfield_size);
324  }
325 
326  /* X.691 2002 10.5.7.2 - The one-octet case. */
327  if (range == 256) {
328  if (aper_put_align(po))
329  return -1;
330  return per_put_few_bits(po, value, 8);
331  }
332 
333  /* X.691 2002 10.5.7.3 - The two-octet case. */
334  if (range <= 65536) {
335  if (aper_put_align(po))
336  return -1;
337  return per_put_few_bits(po, value, 16);
338  }
339 
340  /* X.691 2002 10.5.7.4 - The indefinite length case. */
341  /* since we limit input to be 'long' we don't handle all numbers */
342  /* and so length determinant is stored as X.691 2002 10.9.3.3 */
343  /* number of bytes to store the range */
344  for (range_len = 3; ; range_len++) {
345  int bits = 1 << (8 * range_len);
346  if (range - 1 < bits)
347  break;
348  }
349  /* number of bytes to store the value */
350  for (value_len = 1; ; value_len++) {
351  long bits = ((long)1) << (8 * value_len);
352  if (value < bits)
353  break;
354  }
355  if (aper_put_constrained_whole_number(po, 1, range_len, value_len))
356  return -1;
357  if (aper_put_align(po))
358  return -1;
359  return per_put_few_bits(po, value, value_len * 8);
360 }
asn_bit_outp_s
Definition: asn_bit_data.h:56
aper_put_nslength
int aper_put_nslength(asn_per_outp_t *po, size_t length)
Definition: aper_support.c:234
aper_put_constrained_whole_number
int aper_put_constrained_whole_number(asn_per_outp_t *po, long lb, long ub, long number)
Definition: aper_support.c:301
aper_put_align
int aper_put_align(asn_per_outp_t *po)
Definition: aper_support.c:185
aper_put_length
ssize_t aper_put_length(asn_per_outp_t *po, ssize_t lb, ssize_t ub, size_t n, int *need_eom)
Definition: aper_support.c:196
aper_put_nsnnwn
int aper_put_nsnnwn(asn_per_outp_t *po, int number)
Definition: aper_support.c:251
aper_get_align
int32_t aper_get_align(asn_per_data_t *pd)
Definition: aper_support.c:10
asn_bit_data_s::nboff
size_t nboff
Definition: asn_bit_data.h:19
aper_support.h
per_get_few_bits
#define per_get_few_bits(data, bits)
Definition: per_support.h:39
asn_bit_data_s
Definition: asn_bit_data.h:17
aper_get_constrained_whole_number
long aper_get_constrained_whole_number(asn_per_data_t *pd, long lb, long ub)
Definition: aper_support.c:116
aper_get_nslength
ssize_t aper_get_nslength(asn_per_data_t *pd)
Definition: aper_support.c:53
aper_get_nsnnwn
ssize_t aper_get_nsnnwn(asn_per_data_t *pd)
Definition: aper_support.c:72
asn_system.h
asn_internal.h
asn_bit_outp_s::nboff
size_t nboff
Definition: asn_bit_data.h:58
per_put_few_bits
#define per_put_few_bits(out, bits, obits)
Definition: per_support.h:46
aper_get_length
ssize_t aper_get_length(asn_per_data_t *pd, ssize_t lb, ssize_t ub, int ebits, int *repeat)
Definition: aper_support.c:20

etsi_its_vam_ts_coding
Author(s): Jean-Pierre Busch , Guido Küppers , Lennart Reiher
autogenerated on Sun May 18 2025 02:30:55