Annotation of embedaddon/libpdel/structs/type/structs_type_data.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <sys/socket.h>
43: #include <netinet/in.h>
44: #include <arpa/inet.h>
45: #include <net/ethernet.h>
46:
47: #include <stdlib.h>
48: #include <stdio.h>
49: #include <stdarg.h>
50: #include <string.h>
51: #include <limits.h>
52: #include <assert.h>
53: #include <ctype.h>
54: #include <errno.h>
55: #include <time.h>
56:
57: #include "structs/structs.h"
58: #include "structs/type/array.h"
59: #include "structs/type/data.h"
60: #include "io/filter.h"
61: #include "io/base64.h"
62: #include "util/typed_mem.h"
63:
64: #define HEXVAL(c) (isdigit(c) ? (c) - '0' : tolower(c) - 'a' + 10)
65:
66: static const char hexchars[] = "0123456789abcdef";
67:
68: /*********************************************************************
69: BINARY DATA TYPE
70: *********************************************************************/
71:
72: int
73: structs_data_copy(const struct structs_type *type, const void *from, void *to)
74: {
75: const char *const mtype = type->args[1].v;
76: const struct structs_data *const fdata = from;
77: struct structs_data *const tdata = to;
78: u_char *copy;
79:
80: if (fdata->length == 0) {
81: memset(tdata, 0, sizeof(*tdata));
82: return (0);
83: }
84: if ((copy = MALLOC(mtype, fdata->length)) == NULL)
85: return (-1);
86: memcpy(copy, fdata->data, fdata->length);
87: tdata->data = copy;
88: tdata->length = fdata->length;
89: return (0);
90: }
91:
92: int
93: structs_data_equal(const struct structs_type *type,
94: const void *v1, const void *v2)
95: {
96: const struct structs_data *const d1 = v1;
97: const struct structs_data *const d2 = v2;
98:
99: return (d1->length == d2->length
100: && memcmp(d1->data, d2->data, d1->length) == 0);
101: }
102:
103: char *
104: structs_data_ascify(const struct structs_type *type,
105: const char *mtype, const void *data)
106: {
107: const char *const charmap = type->args[0].v;
108: const struct structs_data *const d = data;
109: struct filter *encoder;
110: char *edata;
111: int elen;
112: int i;
113:
114: /* Handle hex encoding */
115: if (charmap != NULL && *charmap == '\0') {
116: if ((edata = MALLOC(mtype, d->length * 2 + 1)) == NULL)
117: return (NULL);
118: for (i = 0; i < d->length; i++) {
119: edata[i * 2] = hexchars[(d->data[i] >> 4) & 0x0f];
120: edata[i * 2 + 1] = hexchars[d->data[i] & 0x0f];
121: }
122: edata[i * 2] = '\0';
123: return (edata);
124: }
125:
126: /* Get encoding filter */
127: if ((encoder = b64_encoder_create(charmap)) == NULL)
128: return (NULL);
129:
130: /* Encode data */
131: elen = filter_process(encoder, d->data,
132: d->length, 1, (u_char **)&edata, mtype);
133: filter_destroy(&encoder);
134: if (elen == -1)
135: return (NULL);
136:
137: /* Return encoded data as a string */
138: edata[elen] = '\0';
139: return (edata);
140: }
141:
142: int
143: structs_data_binify(const struct structs_type *type,
144: const char *ascii, void *data, char *ebuf, size_t emax)
145: {
146: const char *const charmap = type->args[0].v;
147: const char *const mtype = type->args[1].v;
148: struct structs_data *const d = data;
149: struct filter *decoder;
150: u_char *bdata;
151: int blen;
152: int i;
153:
154: /* Handle hex encoding */
155: if (charmap != NULL && *charmap == '\0') {
156: if ((bdata = MALLOC(mtype, (strlen(ascii) + 1) / 2)) == NULL)
157: return (-1);
158: for (blen = 0; *ascii != '\0'; blen++) {
159: while (isspace(*ascii))
160: ascii++;
161: if (*ascii == '\0')
162: break;
163: bdata[blen] = 0;
164: for (i = 4; i >= 0; i -= 4) {
165: if (!isxdigit(*ascii)) {
166: strlcpy(ebuf, *ascii == '\0' ?
167: "odd length hex sequence" :
168: "non-hex character seen", emax);
169: FREE(mtype, bdata);
170: return (-1);
171: }
172: bdata[blen] |= HEXVAL(*ascii) << i;
173: ascii++;
174: }
175: }
176: goto done;
177: }
178:
179: /* Get decoding filter */
180: if ((decoder = b64_decoder_create(charmap, 1)) == NULL)
181: return (-1);
182:
183: /* Decode data */
184: blen = filter_process(decoder, ascii, strlen(ascii), 1, &bdata, mtype);
185: filter_destroy(&decoder);
186: if (blen == -1) {
187: strlcpy(ebuf, "invalid encoded binary data", emax);
188: return (-1);
189: }
190:
191: done:
192: /* Fill in structure */
193: d->length = blen;
194: d->data = bdata;
195: return (0);
196: }
197:
198: void
199: structs_data_free(const struct structs_type *type, void *data)
200: {
201: const char *const mtype = type->args[1].v;
202: struct structs_data *const d = data;
203:
204: FREE(mtype, d->data);
205: memset(d, 0, sizeof(*d));
206: }
207:
208: int
209: structs_data_encode(const struct structs_type *type, const char *mtype,
210: struct structs_data *code, const void *data)
211: {
212: const struct structs_data *const d = data;
213: u_int32_t elength;
214:
215: if ((code->data = MALLOC(mtype, 4 + d->length)) == NULL)
216: return (-1);
217: elength = htonl(d->length);
218: memcpy(code->data, &elength, 4);
219: memcpy(code->data + 4, d->data, d->length);
220: code->length = 4 + d->length;
221: return (0);
222: }
223:
224: int
225: structs_data_decode(const struct structs_type *type, const u_char *code,
226: size_t cmax, void *data, char *ebuf, size_t emax)
227: {
228: const char *const mtype = type->args[1].v;
229: struct structs_data *const d = data;
230: u_int32_t elength;
231:
232: if (cmax < 4)
233: goto bogus;
234: memcpy(&elength, code, 4);
235: d->length = ntohl(elength);
236: if (cmax < d->length) {
237: bogus: strlcpy(ebuf, "encoded data is corrupted", emax);
238: errno = EINVAL;
239: return (-1);
240: }
241: if ((d->data = MALLOC(mtype, d->length)) == NULL)
242: return (-1);
243: memcpy(d->data, code + 4, d->length);
244: return (4 + d->length);
245: }
246:
247: const struct structs_type structs_type_data =
248: STRUCTS_DATA_TYPE(NULL, STRUCTS_DATA_MEMTYPE);
249:
250: const struct structs_type structs_type_hexdata =
251: STRUCTS_DATA_TYPE("", STRUCTS_DATA_MEMTYPE);
252:
253: /*********************************************************************
254: FIXED LENGTH BINARY DATA TYPE
255: *********************************************************************/
256:
257: char *
258: structs_fixeddata_ascify(const struct structs_type *type,
259: const char *mtype, const void *data)
260: {
261: const u_char *bytes = data;
262: char *s;
263: int i;
264:
265: if ((s = MALLOC(mtype, type->size * 2 + 1)) == NULL)
266: return (NULL);
267: for (i = 0; i < type->size; i++) {
268: s[i * 2] = hexchars[(bytes[i] >> 4) & 0x0f];
269: s[i * 2 + 1] = hexchars[bytes[i] & 0x0f];
270: }
271: s[i * 2] = '\0';
272: return (s);
273: }
274:
275: int
276: structs_fixeddata_binify(const struct structs_type *type,
277: const char *ascii, void *data, char *ebuf, size_t emax)
278: {
279: u_char *bytes = data;
280: int i;
281: int j;
282:
283: for (i = 0; i < type->size; i++) {
284: bytes[i] = 0;
285: for (j = 4; j >= 0; j -= 4) {
286: while (isspace(*ascii))
287: ascii++;
288: if (!isxdigit(*ascii)) {
289: strlcpy(ebuf, *ascii == '\0' ?
290: "hex string is too short" :
291: "non-hex character seen", emax);
292: goto fail;
293: }
294: bytes[i] |= HEXVAL(*ascii) << j;
295: ascii++;
296: }
297: }
298: while (isspace(*ascii))
299: ascii++;
300: if (*ascii != '\0') {
301: strlcpy(ebuf, "hex string is too long", emax);
302: fail: errno = EINVAL;
303: return (-1);
304: }
305: return (0);
306: }
307:
308: int
309: structs_fixeddata_encode(const struct structs_type *type, const char *mtype,
310: struct structs_data *code, const void *data)
311: {
312: if ((code->data = MALLOC(mtype, type->size)) == NULL)
313: return (-1);
314: memcpy(code->data, data, type->size);
315: code->length = type->size;
316: return (0);
317: }
318:
319: int
320: structs_fixeddata_decode(const struct structs_type *type, const u_char *code,
321: size_t cmax, void *data, char *ebuf, size_t emax)
322: {
323: if (cmax < type->size) {
324: strlcpy(ebuf, "encoded data is truncated", emax);
325: errno = EINVAL;
326: return (-1);
327: }
328: memcpy(data, code, type->size);
329: return (type->size);
330: }
331:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_type_data.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / structs / type