]> git.stg.codes - stg.git/blob - libs/smux/NULL.c
Use std::lock_guard instead of STG_LOCKER.
[stg.git] / libs / smux / NULL.c
1 /*-
2  * Copyright (c) 2003, 2005 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 <asn_codecs_prim.h>
7 #include <NULL.h>
8
9 /*
10  * NULL basic type description.
11  */
12 static const ber_tlv_tag_t asn_DEF_NULL_tags[] = {
13         (ASN_TAG_CLASS_UNIVERSAL | (5 << 2))
14 };
15 asn_TYPE_operation_t asn_OP_NULL = {
16         NULL_free,
17         NULL_print,
18         NULL_compare,
19         NULL_decode_ber,
20         NULL_encode_der,        /* Special handling of DER encoding */
21         NULL_decode_xer,
22         NULL_encode_xer,
23 #ifdef  ASN_DISABLE_OER_SUPPORT
24         0,
25         0,
26 #else
27         NULL_decode_oer,
28         NULL_encode_oer,
29 #endif  /* ASN_DISABLE_OER_SUPPORT */
30 #ifdef  ASN_DISABLE_PER_SUPPORT
31         0,
32         0,
33 #else
34         NULL_decode_uper,       /* Unaligned PER decoder */
35         NULL_encode_uper,       /* Unaligned PER encoder */
36 #endif  /* ASN_DISABLE_PER_SUPPORT */
37         NULL_random_fill,
38         0       /* Use generic outmost tag fetcher */
39 };
40 asn_TYPE_descriptor_t asn_DEF_NULL = {
41         "NULL",
42         "NULL",
43         &asn_OP_NULL,
44         asn_DEF_NULL_tags,
45         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
46         asn_DEF_NULL_tags,      /* Same as above */
47         sizeof(asn_DEF_NULL_tags) / sizeof(asn_DEF_NULL_tags[0]),
48         { 0, 0, asn_generic_no_constraint },
49         0, 0,   /* No members */
50         0       /* No specifics */
51 };
52
53 void
54 NULL_free(const asn_TYPE_descriptor_t *td, void *ptr,
55           enum asn_struct_free_method method) {
56     if(td && ptr) {
57         switch(method) {
58         case ASFM_FREE_EVERYTHING:
59             FREEMEM(ptr);
60             break;
61         case ASFM_FREE_UNDERLYING:
62             break;
63         case ASFM_FREE_UNDERLYING_AND_RESET:
64             memset(ptr, 0, sizeof(NULL_t));
65             break;
66         }
67     }
68 }
69
70 /*
71  * Decode NULL type.
72  */
73 asn_dec_rval_t
74 NULL_decode_ber(const asn_codec_ctx_t *opt_codec_ctx,
75                 const asn_TYPE_descriptor_t *td, void **bool_value,
76                 const void *buf_ptr, size_t size, int tag_mode) {
77     NULL_t *st = (NULL_t *)*bool_value;
78     asn_dec_rval_t rval;
79     ber_tlv_len_t length;
80
81     if(st == NULL) {
82         st = (NULL_t *)(*bool_value = CALLOC(1, sizeof(*st)));
83         if(st == NULL) {
84             rval.code = RC_FAIL;
85             rval.consumed = 0;
86             return rval;
87         }
88     }
89
90     ASN_DEBUG("Decoding %s as NULL (tm=%d)", td->name, tag_mode);
91
92     /*
93      * Check tags.
94      */
95     rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size, tag_mode, 0,
96                           &length, 0);
97     if(rval.code != RC_OK) {
98         return rval;
99     }
100
101     // X.690-201508, #8.8.2, length shall be zero.
102     if(length != 0) {
103         ASN_DEBUG("Decoding %s as NULL failed: too much data", td->name);
104         rval.code = RC_FAIL;
105         rval.consumed = 0;
106         return rval;
107     }
108
109     return rval;
110 }
111
112 asn_enc_rval_t
113 NULL_encode_der(const asn_TYPE_descriptor_t *td, const void *ptr, int tag_mode,
114                 ber_tlv_tag_t tag, asn_app_consume_bytes_f *cb, void *app_key) {
115     asn_enc_rval_t erval;
116
117         erval.encoded = der_write_tags(td, 0, tag_mode, 0, tag, cb, app_key);
118         if(erval.encoded == -1) {
119                 erval.failed_type = td;
120                 erval.structure_ptr = ptr;
121         }
122
123         ASN__ENCODED_OK(erval);
124 }
125
126 asn_enc_rval_t
127 NULL_encode_xer(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
128                 enum xer_encoder_flags_e flags, asn_app_consume_bytes_f *cb,
129                 void *app_key) {
130     asn_enc_rval_t er;
131
132         (void)td;
133         (void)sptr;
134         (void)ilevel;
135         (void)flags;
136         (void)cb;
137         (void)app_key;
138
139         /* XMLNullValue is empty */
140         er.encoded = 0;
141         ASN__ENCODED_OK(er);
142 }
143
144
145 static enum xer_pbd_rval
146 NULL__xer_body_decode(const asn_TYPE_descriptor_t *td, void *sptr,
147                       const void *chunk_buf, size_t chunk_size) {
148     (void)td;
149         (void)sptr;
150         (void)chunk_buf;    /* Going to be empty according to the rules below. */
151
152         /*
153          * There must be no content in self-terminating <NULL/> tag.
154          */
155         if(chunk_size)
156                 return XPBD_BROKEN_ENCODING;
157         else
158                 return XPBD_BODY_CONSUMED;
159 }
160
161 asn_dec_rval_t
162 NULL_decode_xer(const asn_codec_ctx_t *opt_codec_ctx,
163                 const asn_TYPE_descriptor_t *td, void **sptr,
164                 const char *opt_mname, const void *buf_ptr, size_t size) {
165     return xer_decode_primitive(opt_codec_ctx, td,
166                 sptr, sizeof(NULL_t), opt_mname, buf_ptr, size,
167                 NULL__xer_body_decode);
168 }
169
170 int
171 NULL_compare(const asn_TYPE_descriptor_t *td, const void *a, const void *b) {
172     (void)td;
173     (void)a;
174     (void)b;
175     return 0;
176 }
177
178 int
179 NULL_print(const asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
180            asn_app_consume_bytes_f *cb, void *app_key) {
181     (void)td;   /* Unused argument */
182         (void)ilevel;   /* Unused argument */
183
184         if(sptr) {
185                 return (cb("<present>", 9, app_key) < 0) ? -1 : 0;
186         } else {
187                 return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
188         }
189 }
190
191 #ifndef ASN_DISABLE_OER_SUPPORT
192
193 asn_dec_rval_t
194 NULL_decode_oer(const asn_codec_ctx_t *opt_codec_ctx,
195                 const asn_TYPE_descriptor_t *td,
196                 const asn_oer_constraints_t *constraints, void **sptr,
197                 const void *ptr, size_t size) {
198     asn_dec_rval_t rv = {RC_OK, 0};
199     (void)opt_codec_ctx;
200     (void)td;
201     (void)constraints;
202     (void)ptr;
203     (void)size;
204
205     if(!*sptr) {
206         *sptr = MALLOC(sizeof(NULL_t));
207         if(*sptr) {
208             *(NULL_t *)*sptr = 0;
209         } else {
210             ASN__DECODE_FAILED;
211         }
212     }
213
214     return rv;
215 }
216
217 asn_enc_rval_t
218 NULL_encode_oer(const asn_TYPE_descriptor_t *td,
219                 const asn_oer_constraints_t *constraints, const void *sptr,
220                 asn_app_consume_bytes_f *cb, void *app_key) {
221     asn_enc_rval_t er;
222
223     (void)td;
224     (void)sptr;
225     (void)constraints;
226     (void)cb;
227     (void)app_key;
228
229     er.encoded = 0; /* Encoding in 0 bytes. */
230
231     ASN__ENCODED_OK(er);
232 }
233
234 #endif /* ASN_DISABLE_OER_SUPPORT */
235
236 #ifndef ASN_DISABLE_PER_SUPPORT
237
238 asn_dec_rval_t
239 NULL_decode_uper(const asn_codec_ctx_t *opt_codec_ctx,
240                  const asn_TYPE_descriptor_t *td,
241                  const asn_per_constraints_t *constraints, void **sptr,
242                  asn_per_data_t *pd) {
243     asn_dec_rval_t rv;
244
245         (void)opt_codec_ctx;
246         (void)td;
247         (void)constraints;
248         (void)pd;
249
250         if(!*sptr) {
251                 *sptr = MALLOC(sizeof(NULL_t));
252                 if(*sptr) {
253                         *(NULL_t *)*sptr = 0;
254                 } else {
255                         ASN__DECODE_FAILED;
256                 }
257         }
258
259         /*
260          * NULL type does not have content octets.
261          */
262
263         rv.code = RC_OK;
264         rv.consumed = 0;
265         return rv;
266 }
267
268 asn_enc_rval_t
269 NULL_encode_uper(const asn_TYPE_descriptor_t *td,
270                  const asn_per_constraints_t *constraints, const void *sptr,
271                  asn_per_outp_t *po) {
272     asn_enc_rval_t er;
273
274         (void)td;
275         (void)constraints;
276         (void)sptr;
277         (void)po;
278
279         er.encoded = 0;
280         ASN__ENCODED_OK(er);
281 }
282
283 #endif  /* ASN_DISABLE_PER_SUPPORT */
284
285 asn_random_fill_result_t
286 NULL_random_fill(const asn_TYPE_descriptor_t *td, void **sptr,
287                     const asn_encoding_constraints_t *constr,
288                     size_t max_length) {
289     asn_random_fill_result_t result_ok = {ARFILL_OK, 1};
290     asn_random_fill_result_t result_failed = {ARFILL_FAILED, 0};
291     asn_random_fill_result_t result_skipped = {ARFILL_SKIPPED, 0};
292     NULL_t *st = *sptr;
293
294     (void)td;
295     (void)constr;
296
297     if(max_length == 0) return result_skipped;
298
299     if(st == NULL) {
300         st = (NULL_t *)(*sptr = CALLOC(1, sizeof(*st)));
301         if(st == NULL) {
302             return result_failed;
303         }
304     }
305
306     return result_ok;
307 }
308