]> git.stg.codes - stg.git/blob - stglibs/smux.lib/ANY.c
Better handling of errors from server. Refactoring.
[stg.git] / stglibs / smux.lib / ANY.c
1 /*-
2  * Copyright (c) 2004 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 <ANY.h>
7 #include <errno.h>
8
9 static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
10         sizeof(ANY_t),
11         offsetof(ANY_t, _asn_ctx),
12         2       /* Special indicator that this is an ANY type */
13 };
14 asn_TYPE_descriptor_t asn_DEF_ANY = {
15         "ANY",
16         "ANY",
17         OCTET_STRING_free,
18         OCTET_STRING_print,
19         asn_generic_no_constraint,
20         OCTET_STRING_decode_ber,
21         OCTET_STRING_encode_der,
22         OCTET_STRING_decode_xer_hex,
23         ANY_encode_xer,
24         0, 0,
25         0, /* Use generic outmost tag fetcher */
26         0, 0, 0, 0,
27         0,      /* No PER visible constraints */
28         0, 0,   /* No members */
29         &asn_DEF_ANY_specs,
30 };
31
32
33 asn_enc_rval_t
34 ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
35         int ilevel, enum xer_encoder_flags_e flags,
36                 asn_app_consume_bytes_f *cb, void *app_key) {
37
38         if(flags & XER_F_CANONICAL) {
39                 /*
40                  * Canonical XER-encoding of ANY type is not supported.
41                  */
42                 _ASN_ENCODE_FAILED;
43         }
44
45         /* Dump as binary */
46         return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
47 }
48
49 struct _callback_arg {
50         uint8_t *buffer;
51         size_t offset;
52         size_t size;
53 };
54
55 static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
56
57 int
58 ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
59         struct _callback_arg arg;
60         asn_enc_rval_t erval;
61
62         if(!st || !td) {
63                 errno = EINVAL;
64                 return -1;
65         }
66
67         if(!sptr) {
68                 if(st->buf) FREEMEM(st->buf);
69                 st->size = 0;
70                 return 0;
71         }
72
73         arg.offset = arg.size = 0;
74         arg.buffer = 0;
75
76         erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
77         if(erval.encoded == -1) {
78                 if(arg.buffer) FREEMEM(arg.buffer);
79                 return -1;
80         }
81         assert((size_t)erval.encoded == arg.offset);
82
83         if(st->buf) FREEMEM(st->buf);
84         st->buf = arg.buffer;
85         st->size = arg.offset;
86
87         return 0;
88 }
89
90 ANY_t *
91 ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
92         ANY_t tmp;
93         ANY_t *st;
94
95         if(!td || !sptr) {
96                 errno = EINVAL;
97                 return 0;
98         }
99
100         memset(&tmp, 0, sizeof(tmp));
101
102         if(ANY_fromType(&tmp, td, sptr)) return 0;
103
104         st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
105         if(st) {
106                 *st = tmp;
107                 return st;
108         } else {
109                 FREEMEM(tmp.buf);
110                 return 0;
111         }
112 }
113
114 int
115 ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
116         asn_dec_rval_t rval;
117         void *newst = 0;
118
119         if(!st || !td || !struct_ptr) {
120                 errno = EINVAL;
121                 return -1;
122         }
123
124         if(st->buf == 0) {
125                 /* Nothing to convert, make it empty. */
126                 *struct_ptr = (void *)0;
127                 return 0;
128         }
129
130         rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
131         if(rval.code == RC_OK) {
132                 *struct_ptr = newst;
133                 return 0;
134         } else {
135                 /* Remove possibly partially decoded data. */
136                 ASN_STRUCT_FREE(*td, newst);
137                 return -1;
138         }
139 }
140
141 static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
142         struct _callback_arg *arg = (struct _callback_arg *)key;
143
144         if((arg->offset + size) >= arg->size) {
145                 size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
146                 void *p = REALLOC(arg->buffer, nsize);
147                 if(!p) return -1;
148                 arg->buffer = (uint8_t *)p;
149                 arg->size = nsize;
150         }
151
152         memcpy(arg->buffer + arg->offset, buffer, size);
153         arg->offset += size;
154         assert(arg->offset < arg->size);
155
156         return 0;
157 }
158