Annotation of embedaddon/mpd/src/contrib/libpdel/structs/type/structs_type_struct.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:
43: #include <stdio.h>
44: #include <stdlib.h>
45: #include <stdarg.h>
46: #include <string.h>
47: #include <assert.h>
48: #include <errno.h>
49:
50: #include "structs/structs.h"
51: #include "structs/type/array.h"
52: #include "structs/type/struct.h"
53: #include "util/typed_mem.h"
54:
55: #define NUM_BYTES(x) (((x) + 7) / 8)
56:
57: /*********************************************************************
58: STRUCTURE TYPES
59: *********************************************************************/
60:
61: int
62: structs_struct_init(const struct structs_type *type, void *data)
63: {
64: const struct structs_field *field;
65:
66: /* Make sure it's really a structure type */
67: if (type->tclass != STRUCTS_TYPE_STRUCTURE) {
68: errno = EINVAL;
69: return (-1);
70: }
71:
72: /* Initialize each field */
73: memset(data, 0, type->size);
74: for (field = type->args[0].v; field->name != NULL; field++) {
75: assert(field->size == field->type->size); /* safety check */
76: if ((*field->type->init)(field->type,
77: (char *)data + field->offset) == -1)
78: break;
79: }
80:
81: /* If there was a failure, clean up */
82: if (field->name != NULL) {
83: while (field-- != type->args[0].v) {
84: (*field->type->uninit)(field->type,
85: (char *)data + field->offset);
86: }
87: memset((char *)data, 0, type->size);
88: return (-1);
89: }
90: return (0);
91: }
92:
93: int
94: structs_struct_copy(const struct structs_type *type,
95: const void *from, void *to)
96: {
97: const struct structs_field *field;
98:
99: /* Make sure it's really a structure type */
100: if (type->tclass != STRUCTS_TYPE_STRUCTURE) {
101: errno = EINVAL;
102: return (-1);
103: }
104:
105: /* Copy each field */
106: memset(to, 0, type->size);
107: for (field = type->args[0].v; field->name != NULL; field++) {
108: const void *const fdata = (char *)from + field->offset;
109: void *const tdata = (char *)to + field->offset;
110:
111: if ((*field->type->copy)(field->type, fdata, tdata) == -1)
112: break;
113: }
114:
115: /* If there was a failure, clean up */
116: if (field->name != NULL) {
117: while (field-- != type->args[0].v) {
118: (*field->type->uninit)(field->type,
119: (char *)to + field->offset);
120: }
121: memset((char *)to, 0, type->size);
122: }
123: return (0);
124: }
125:
126: int
127: structs_struct_equal(const struct structs_type *type,
128: const void *v1, const void *v2)
129: {
130: const struct structs_field *field;
131:
132: /* Make sure it's really a structure type */
133: if (type->tclass != STRUCTS_TYPE_STRUCTURE)
134: return (0);
135:
136: /* Compare all fields */
137: for (field = type->args[0].v; field->name != NULL; field++) {
138: const void *const data1 = (char *)v1 + field->offset;
139: const void *const data2 = (char *)v2 + field->offset;
140:
141: if (!(*field->type->equal)(field->type, data1, data2))
142: return (0);
143: }
144: return (1);
145: }
146:
147: int
148: structs_struct_encode(const struct structs_type *type, const char *mtype,
149: struct structs_data *code, const void *data)
150: {
151: struct structs_data *fcodes;
152: u_int nfields;
153: u_int bitslen;
154: u_char *bits;
155: int r = -1;
156: u_int tlen;
157: u_int i;
158:
159: /* Count number of fields */
160: for (nfields = 0;
161: ((struct structs_field *)type->args[0].v)[nfields].name != NULL;
162: nfields++);
163:
164: /* Create bit array. Each bit indicates a field as being present. */
165: bitslen = NUM_BYTES(nfields);
166: if ((bits = MALLOC(TYPED_MEM_TEMP, bitslen)) == NULL)
167: return (-1);
168: memset(bits, 0, bitslen);
169: tlen = bitslen;
170:
171: /* Create array of individual encodings, one per field */
172: if ((fcodes = MALLOC(TYPED_MEM_TEMP,
173: nfields * sizeof(*fcodes))) == NULL)
174: goto fail1;
175: for (i = 0; i < nfields; i++) {
176: const struct structs_field *const field
177: = (struct structs_field *)type->args[0].v + i;
178: const void *const fdata = (char *)data + field->offset;
179: struct structs_data *const fcode = &fcodes[i];
180: void *dval;
181: int equal;
182:
183: /* Compare this field to the default value */
184: if ((dval = MALLOC(TYPED_MEM_TEMP, field->type->size)) == NULL)
185: goto fail2;
186: if (structs_init(field->type, NULL, dval) == -1) {
187: FREE(TYPED_MEM_TEMP, dval);
188: goto fail2;
189: }
190: equal = (*field->type->equal)(field->type, fdata, dval);
191: structs_free(field->type, NULL, dval);
192: FREE(TYPED_MEM_TEMP, dval);
193:
194: /* Omit field if value equals default value */
195: if (equal == 1) {
196: memset(fcode, 0, sizeof(*fcode));
197: continue;
198: }
199: bits[i / 8] |= (1 << (i % 8));
200:
201: /* Encode this field */
202: if ((*field->type->encode)(field->type, TYPED_MEM_TEMP,
203: fcode, (char *)data + field->offset) == -1)
204: goto fail2;
205: tlen += fcode->length;
206: }
207:
208: /* Allocate final encoded region */
209: if ((code->data = MALLOC(mtype, tlen)) == NULL)
210: goto done;
211:
212: /* Copy bits */
213: memcpy(code->data, bits, bitslen);
214: code->length = bitslen;
215:
216: /* Copy encoded fields */
217: for (i = 0; i < nfields; i++) {
218: struct structs_data *const fcode = &fcodes[i];
219:
220: memcpy(code->data + code->length, fcode->data, fcode->length);
221: code->length += fcode->length;
222: }
223:
224: /* OK */
225: r = 0;
226:
227: done:
228: /* Clean up and exit */
229: fail2: while (i-- > 0)
230: FREE(TYPED_MEM_TEMP, fcodes[i].data);
231: FREE(TYPED_MEM_TEMP, fcodes);
232: fail1: FREE(TYPED_MEM_TEMP, bits);
233: return (r);
234: }
235:
236: int
237: structs_struct_decode(const struct structs_type *type, const u_char *code,
238: size_t cmax, void *data, char *ebuf, size_t emax)
239: {
240: const u_char *bits;
241: u_int nfields;
242: u_int bitslen;
243: u_int clen;
244: u_int i;
245:
246: /* Count number of fields */
247: for (nfields = 0;
248: ((struct structs_field *)type->args[0].v)[nfields].name != NULL;
249: nfields++);
250:
251: /* Get bits array */
252: bitslen = NUM_BYTES(nfields);
253: if (cmax < bitslen) {
254: strlcpy(ebuf, "encoded structure is truncated", emax);
255: errno = EINVAL;
256: return (-1);
257: }
258: bits = code;
259: code += bitslen;
260: cmax -= bitslen;
261: clen = bitslen;
262:
263: /* Decode fields */
264: for (i = 0; i < nfields; i++) {
265: const struct structs_field *const field
266: = (struct structs_field *)type->args[0].v + i;
267: void *const fdata = (char *)data + field->offset;
268: int fclen;
269:
270: /* If field not present, assign it the default value */
271: if ((bits[i / 8] & (1 << (i % 8))) == 0) {
272: if (structs_init(field->type, NULL, fdata) == -1)
273: goto fail;
274: continue;
275: }
276:
277: /* Decode field */
278: if ((fclen = (*field->type->decode)(field->type,
279: code, cmax, fdata, ebuf, emax)) == -1)
280: goto fail;
281:
282: /* Go to next encoded field */
283: code += fclen;
284: cmax -= fclen;
285: clen += fclen;
286: continue;
287:
288: /* Un-do work done so far */
289: fail: while (i-- > 0) {
290: const struct structs_field *const field2
291: = (struct structs_field *)type->args[0].v + i;
292: void *const fdata2 = (char *)data + field2->offset;
293:
294: structs_free(field2->type, NULL, fdata2);
295: }
296: return (-1);
297: }
298:
299: /* Done */
300: return (clen);
301: }
302:
303: void
304: structs_struct_free(const struct structs_type *type, void *data)
305: {
306: const struct structs_field *field;
307:
308: /* Make sure it's really a structure type */
309: if (type->tclass != STRUCTS_TYPE_STRUCTURE)
310: return;
311:
312: /* Free all fields */
313: for (field = type->args[0].v; field->name != NULL; field++) {
314: (*field->type->uninit)(field->type,
315: (char *)data + field->offset);
316: }
317: memset((char *)data, 0, type->size);
318: }
319:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_type_struct.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src / contrib / libpdel / structs / type