Annotation of embedaddon/mpd/src/contrib/libpdel/structs/type/structs_type_array.c, revision 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/param.h>
! 43: #include <netinet/in.h>
! 44: #include <arpa/inet.h>
! 45:
! 46: #include <stdio.h>
! 47: #include <stdlib.h>
! 48: #include <stdarg.h>
! 49: #include <string.h>
! 50: #include <errno.h>
! 51:
! 52: #include "structs/structs.h"
! 53: #include "structs/type/array.h"
! 54: #include "util/typed_mem.h"
! 55:
! 56: #define NUM_BYTES(x) (((x) + 7) / 8)
! 57:
! 58: /*********************************************************************
! 59: ARRAY TYPES
! 60: *********************************************************************/
! 61:
! 62: int
! 63: structs_array_copy(const struct structs_type *type,
! 64: const void *from, void *to)
! 65: {
! 66: const struct structs_type *const etype = type->args[0].v;
! 67: const char *mtype = type->args[1].v;
! 68: const struct structs_array *const fary = from;
! 69: struct structs_array *const tary = to;
! 70: int errno_save;
! 71: u_int i;
! 72:
! 73: /* Make sure it's really an array type */
! 74: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 75: errno = EINVAL;
! 76: return (-1);
! 77: }
! 78:
! 79: /* Allocate a new array */
! 80: memset(tary, 0, sizeof(*tary));
! 81: if ((tary->elems = MALLOC(mtype,
! 82: fary->length * etype->size)) == NULL)
! 83: return (-1);
! 84:
! 85: /* Copy elements into it */
! 86: for (i = 0; i < fary->length; i++) {
! 87: const void *const from_elem
! 88: = (char *)fary->elems + (i * etype->size);
! 89: void *const to_elem = (char *)tary->elems + (i * etype->size);
! 90:
! 91: if ((*etype->copy)(etype, from_elem, to_elem) == -1)
! 92: break;
! 93: tary->length++;
! 94: }
! 95:
! 96: /* If there was a failure, undo the half completed job */
! 97: if (i < fary->length) {
! 98: errno_save = errno;
! 99: while (i-- > 0) {
! 100: (*etype->uninit)(etype,
! 101: (char *)tary->elems + (i * etype->size));
! 102: }
! 103: FREE(mtype, tary->elems);
! 104: memset(tary, 0, sizeof(*tary));
! 105: errno = errno_save;
! 106: return (-1);
! 107: }
! 108:
! 109: /* Done */
! 110: return (0);
! 111: }
! 112:
! 113: int
! 114: structs_array_equal(const struct structs_type *type,
! 115: const void *v1, const void *v2)
! 116: {
! 117: const struct structs_type *const etype = type->args[0].v;
! 118: const struct structs_array *const ary1 = v1;
! 119: const struct structs_array *const ary2 = v2;
! 120: u_int i;
! 121:
! 122: /* Make sure it's really an array type */
! 123: if (type->tclass != STRUCTS_TYPE_ARRAY)
! 124: return (0);
! 125:
! 126: /* Check array lengths first */
! 127: if (ary1->length != ary2->length)
! 128: return (0);
! 129:
! 130: /* Now compare individual elements */
! 131: for (i = 0;
! 132: i < ary1->length && (*etype->equal)(etype,
! 133: (char *)ary1->elems + (i * etype->size),
! 134: (char *)ary2->elems + (i * etype->size));
! 135: i++);
! 136: return (i == ary1->length);
! 137: }
! 138:
! 139: int
! 140: structs_array_encode(const struct structs_type *type, const char *mtype,
! 141: struct structs_data *code, const void *data)
! 142: {
! 143: const struct structs_type *const etype = type->args[0].v;
! 144: const struct structs_array *const ary = data;
! 145: const u_int bitslen = NUM_BYTES(ary->length);
! 146: struct structs_data *ecodes;
! 147: u_int32_t elength;
! 148: u_char *bits;
! 149: void *delem;
! 150: u_int tlen;
! 151: int r = -1;
! 152: u_int i;
! 153:
! 154: /* Make sure it's really an array type */
! 155: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 156: errno = EINVAL;
! 157: return (-1);
! 158: }
! 159:
! 160: /* Get the default value for an element */
! 161: if ((delem = MALLOC(TYPED_MEM_TEMP, etype->size)) == NULL)
! 162: return (-1);
! 163: if (structs_init(etype, NULL, delem) == -1)
! 164: goto fail1;
! 165:
! 166: /* Create bit array. Each bit indicates an element that is present. */
! 167: if ((bits = MALLOC(TYPED_MEM_TEMP, bitslen)) == NULL)
! 168: goto fail2;
! 169: memset(bits, 0, bitslen);
! 170: tlen = 4 + bitslen; /* length word + bits array */
! 171:
! 172: /* Create array of individual encodings, one per element */
! 173: if ((ecodes = MALLOC(TYPED_MEM_TEMP,
! 174: ary->length * sizeof(*ecodes))) == NULL)
! 175: goto fail3;
! 176: for (i = 0; i < ary->length; i++) {
! 177: const void *const elem = (char *)ary->elems + (i * etype->size);
! 178: struct structs_data *const ecode = &ecodes[i];
! 179:
! 180: /* Check for default value, leave out if same as */
! 181: if ((*etype->equal)(etype, elem, delem) == 1) {
! 182: memset(ecode, 0, sizeof(*ecode));
! 183: continue;
! 184: }
! 185: bits[i / 8] |= (1 << (i % 8));
! 186:
! 187: /* Encode element */
! 188: if ((*etype->encode)(etype, TYPED_MEM_TEMP, ecode, elem) == -1)
! 189: goto fail4;
! 190: tlen += ecode->length;
! 191: }
! 192:
! 193: /* Allocate final encoded region */
! 194: if ((code->data = MALLOC(mtype, tlen)) == NULL)
! 195: goto fail4;
! 196:
! 197: /* Copy array length */
! 198: elength = htonl(ary->length);
! 199: memcpy(code->data, &elength, 4);
! 200: code->length = 4;
! 201:
! 202: /* Copy bits array */
! 203: memcpy(code->data + code->length, bits, bitslen);
! 204: code->length += bitslen;
! 205:
! 206: /* Copy encoded elements */
! 207: for (i = 0; i < ary->length; i++) {
! 208: struct structs_data *const ecode = &ecodes[i];
! 209:
! 210: memcpy(code->data + code->length, ecode->data, ecode->length);
! 211: code->length += ecode->length;
! 212: }
! 213:
! 214: /* OK */
! 215: r = 0;
! 216:
! 217: /* Clean up and exit */
! 218: fail4: while (i-- > 0)
! 219: FREE(TYPED_MEM_TEMP, ecodes[i].data);
! 220: FREE(TYPED_MEM_TEMP, ecodes);
! 221: fail3: FREE(TYPED_MEM_TEMP, bits);
! 222: fail2: structs_free(etype, NULL, delem);
! 223: fail1: FREE(TYPED_MEM_TEMP, delem);
! 224: return (r);
! 225: }
! 226:
! 227: int
! 228: structs_array_decode(const struct structs_type *type, const u_char *code,
! 229: size_t cmax, void *data, char *ebuf, size_t emax)
! 230: {
! 231: const struct structs_type *const etype = type->args[0].v;
! 232: const char *const mtype = type->args[1].v;
! 233: struct structs_array *const ary = data;
! 234: const u_char *bits;
! 235: u_int32_t elength;
! 236: u_int bitslen;
! 237: int clen;
! 238: u_int i;
! 239:
! 240: /* Make sure it's really an array type */
! 241: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 242: errno = EINVAL;
! 243: return (-1);
! 244: }
! 245:
! 246: /* Get number of elements */
! 247: if (cmax < 4)
! 248: goto truncated;
! 249: memcpy(&elength, code, 4);
! 250: ary->length = ntohl(elength);
! 251: code += 4;
! 252: cmax -= 4;
! 253: clen = 4;
! 254:
! 255: /* Get bits array */
! 256: bitslen = NUM_BYTES(ary->length);
! 257: if (cmax < bitslen) {
! 258: truncated: strlcpy(ebuf, "encoded array is truncated", emax);
! 259: errno = EINVAL;
! 260: return (-1);
! 261: }
! 262: bits = code;
! 263: code += bitslen;
! 264: cmax -= bitslen;
! 265: clen += bitslen;
! 266:
! 267: /* Allocate array elements */
! 268: if ((ary->elems = MALLOC(mtype, ary->length * etype->size)) == NULL)
! 269: return (-1);
! 270:
! 271: /* Decode elements */
! 272: for (i = 0; i < ary->length; i++) {
! 273: void *const edata = (char *)ary->elems + (i * etype->size);
! 274: int eclen;
! 275:
! 276: /* If element not present, assign it the default value */
! 277: if ((bits[i / 8] & (1 << (i % 8))) == 0) {
! 278: if (structs_init(etype, NULL, edata) == -1)
! 279: goto fail;
! 280: continue;
! 281: }
! 282:
! 283: /* Decode element */
! 284: if ((eclen = (*etype->decode)(etype,
! 285: code, cmax, edata, ebuf, emax)) == -1)
! 286: goto fail;
! 287:
! 288: /* Go to next encoded element */
! 289: code += eclen;
! 290: cmax -= eclen;
! 291: clen += eclen;
! 292: continue;
! 293:
! 294: /* Un-do work done so far */
! 295: fail: while (i-- > 0) {
! 296: structs_free(etype, NULL,
! 297: (char *)ary->elems + (i * etype->size));
! 298: }
! 299: FREE(mtype, ary->elems);
! 300: return (-1);
! 301: }
! 302:
! 303: /* Done */
! 304: return (clen);
! 305: }
! 306:
! 307: void
! 308: structs_array_free(const struct structs_type *type, void *data)
! 309: {
! 310: const struct structs_type *const etype = type->args[0].v;
! 311: const char *mtype = type->args[1].v;
! 312: struct structs_array *const ary = data;
! 313: u_int i;
! 314:
! 315: /* Make sure it's really an array type */
! 316: if (type->tclass != STRUCTS_TYPE_ARRAY)
! 317: return;
! 318:
! 319: /* Free individual elements */
! 320: for (i = 0; i < ary->length; i++)
! 321: (*etype->uninit)(etype, (char *)ary->elems + (i * etype->size));
! 322:
! 323: /* Free array itself */
! 324: FREE(mtype, ary->elems);
! 325: memset(ary, 0, sizeof(*ary));
! 326: }
! 327:
! 328: int
! 329: structs_array_length(const struct structs_type *type,
! 330: const char *name, const void *data)
! 331: {
! 332: const struct structs_array *ary = data;
! 333:
! 334: /* Find array */
! 335: if ((type = structs_find(type, name, (void **)&ary, 0)) == NULL)
! 336: return (-1);
! 337:
! 338: /* Make sure it's really an array type */
! 339: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 340: errno = EINVAL;
! 341: return (-1);
! 342: }
! 343:
! 344: /* Return length */
! 345: return (ary->length);
! 346: }
! 347:
! 348: int
! 349: structs_array_reset(const struct structs_type *type,
! 350: const char *name, void *data)
! 351: {
! 352: /* Find array */
! 353: if ((type = structs_find(type, name, &data, 1)) == NULL)
! 354: return (-1);
! 355:
! 356: /* Make sure it's really an array type */
! 357: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 358: errno = EINVAL;
! 359: return (-1);
! 360: }
! 361:
! 362: /* Free it, which resets it as well */
! 363: structs_array_free(type, data);
! 364: return (0);
! 365: }
! 366:
! 367: int
! 368: structs_array_insert(const struct structs_type *type,
! 369: const char *name, u_int index, void *data)
! 370: {
! 371: struct structs_array *ary = data;
! 372: const struct structs_type *etype;
! 373: const char *mtype;
! 374: void *mem;
! 375:
! 376: /* Find array */
! 377: if ((type = structs_find(type, name, (void **)&ary, 0)) == NULL)
! 378: return (-1);
! 379: etype = type->args[0].v;
! 380: mtype = type->args[1].v;
! 381:
! 382: /* Make sure it's really an array type */
! 383: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 384: errno = EINVAL;
! 385: return (-1);
! 386: }
! 387:
! 388: /* Check index */
! 389: if (index > ary->length) {
! 390: errno = EDOM;
! 391: return (-1);
! 392: }
! 393:
! 394: /* Reallocate array, leaving room for new element and a shift */
! 395: if ((mem = REALLOC(mtype,
! 396: ary->elems, (ary->length + 2) * etype->size)) == NULL)
! 397: return (-1);
! 398: ary->elems = mem;
! 399:
! 400: /* Initialize new element; we'll move it into place later */
! 401: if ((*etype->init)(etype,
! 402: (char *)ary->elems + (ary->length + 1) * etype->size) == -1)
! 403: return (-1);
! 404:
! 405: /* Shift array over by one and move new element into place */
! 406: memmove((char *)ary->elems + (index + 1) * etype->size,
! 407: (char *)ary->elems + index * etype->size,
! 408: (ary->length - index) * etype->size);
! 409: memcpy((char *)ary->elems + index * etype->size,
! 410: (char *)ary->elems + (ary->length + 1) * etype->size, etype->size);
! 411: ary->length++;
! 412: return (0);
! 413: }
! 414:
! 415: int
! 416: structs_array_delete(const struct structs_type *type,
! 417: const char *name, u_int index, void *data)
! 418: {
! 419: const struct structs_type *etype;
! 420: struct structs_array *ary = data;
! 421:
! 422: /* Find array */
! 423: if ((type = structs_find(type, name, (void **)&ary, 0)) == NULL)
! 424: return (-1);
! 425: etype = type->args[0].v;
! 426:
! 427: /* Make sure it's really an array type */
! 428: if (type->tclass != STRUCTS_TYPE_ARRAY) {
! 429: errno = EINVAL;
! 430: return (-1);
! 431: }
! 432:
! 433: /* Check index */
! 434: if (index >= ary->length) {
! 435: errno = EDOM;
! 436: return (-1);
! 437: }
! 438:
! 439: /* Free element */
! 440: (*etype->uninit)(etype, (char *)ary->elems + (index * etype->size));
! 441:
! 442: /* Shift array */
! 443: memmove((char *)ary->elems + index * etype->size,
! 444: (char *)ary->elems + (index + 1) * etype->size,
! 445: (--ary->length - index) * etype->size);
! 446: return (0);
! 447: }
! 448:
! 449: /*
! 450: * Given a name, prepare all arrays in the name path for being
! 451: * set with a new element.
! 452: *
! 453: * This means that any array index equal to the length of the array
! 454: * causes a new element to be appended to the array rather than
! 455: * an element not found error, and that any array index equal to
! 456: * zero means to reset the entire array to be empty.
! 457: *
! 458: * This allows an entire array to be set by setting each element
! 459: * in order, as long as this function is called with the name of
! 460: * the element before each set operation.
! 461: */
! 462: int
! 463: structs_array_prep(const struct structs_type *type,
! 464: const char *name, void *data)
! 465: {
! 466: char *nbuf;
! 467: char *s;
! 468:
! 469: /* Skip if name cannot be an array element name */
! 470: if (name == NULL || *name == '\0')
! 471: return (0);
! 472:
! 473: /* Copy name into writable buffer */
! 474: if ((nbuf = MALLOC(TYPED_MEM_TEMP, strlen(name) + 2)) == NULL)
! 475: return (-1);
! 476: nbuf[0] = '*'; /* for debugging */
! 477: strcpy(nbuf + 1, name);
! 478:
! 479: /* Check all array element names in name path */
! 480: for (s = nbuf; s != NULL; s = strchr(s + 1, STRUCTS_SEPARATOR)) {
! 481: const struct structs_type *atype;
! 482: struct structs_array *ary = data;
! 483: u_long index;
! 484: char *eptr;
! 485: char *t;
! 486: char ch;
! 487:
! 488: /* Go to next descendant node using prefix of name */
! 489: ch = *s;
! 490: *s = '\0';
! 491: if ((atype = structs_find(type,
! 492: nbuf + (s != nbuf), (void **)&ary, 1)) == NULL) {
! 493: FREE(TYPED_MEM_TEMP, nbuf);
! 494: return (-1);
! 495: }
! 496: *s = ch;
! 497:
! 498: /* If not array type, continue */
! 499: if (atype->tclass != STRUCTS_TYPE_ARRAY)
! 500: continue;
! 501:
! 502: /* Get array index */
! 503: if ((t = strchr(s + 1, STRUCTS_SEPARATOR)) != NULL)
! 504: *t = '\0';
! 505: index = strtoul(s + 1, &eptr, 10);
! 506: if (eptr == s + 1 || *eptr != '\0') {
! 507: errno = ENOENT;
! 508: FREE(TYPED_MEM_TEMP, nbuf);
! 509: return (-1);
! 510: }
! 511:
! 512: /* If setting an element that already exists, accept */
! 513: if (index < ary->length)
! 514: goto next;
! 515:
! 516: /* Must be setting the next new item in the array */
! 517: if (index != ary->length) {
! 518: errno = ENOENT;
! 519: FREE(TYPED_MEM_TEMP, nbuf);
! 520: return (-1);
! 521: }
! 522:
! 523: /* Add new item; it will be in an initialized state */
! 524: if (structs_array_insert(atype, NULL, ary->length, ary) == -1) {
! 525: FREE(TYPED_MEM_TEMP, nbuf);
! 526: return (-1);
! 527: }
! 528:
! 529: next:
! 530: /* Repair name buffer for next time */
! 531: if (t != NULL)
! 532: *t = STRUCTS_SEPARATOR;
! 533: }
! 534:
! 535: /* Done */
! 536: FREE(TYPED_MEM_TEMP, nbuf);
! 537: return (0);
! 538: }
! 539:
! 540: /*********************************************************************
! 541: FIXEDARRAY TYPES
! 542: *********************************************************************/
! 543:
! 544: int
! 545: structs_fixedarray_init(const struct structs_type *type, void *data)
! 546: {
! 547: const struct structs_type *const etype = type->args[0].v;
! 548: const u_int length = type->args[2].i;
! 549: u_int i;
! 550:
! 551: for (i = 0; i < length; i++) {
! 552: if ((*etype->init)(etype,
! 553: (char *)data + (i * etype->size)) == -1) {
! 554: while (i-- > 0) {
! 555: (*etype->uninit)(etype,
! 556: (char *)data + (i * etype->size));
! 557: }
! 558: return (-1);
! 559: }
! 560: }
! 561: return (0);
! 562: }
! 563:
! 564: int
! 565: structs_fixedarray_copy(const struct structs_type *type,
! 566: const void *from, void *to)
! 567: {
! 568: const struct structs_type *const etype = type->args[0].v;
! 569: const u_int length = type->args[2].i;
! 570: u_int i;
! 571:
! 572: /* Make sure it's really a fixedarray type */
! 573: if (type->tclass != STRUCTS_TYPE_FIXEDARRAY) {
! 574: errno = EINVAL;
! 575: return (-1);
! 576: }
! 577:
! 578: /* Copy elements into it */
! 579: for (i = 0; i < length; i++) {
! 580: const void *const from_elem = (char *)from + (i * etype->size);
! 581: void *const to_elem = (char *)to + (i * etype->size);
! 582:
! 583: if ((*etype->copy)(etype, from_elem, to_elem) == -1)
! 584: break;
! 585: }
! 586:
! 587: /* If there was a failure, undo the half completed job */
! 588: if (i < length) {
! 589: while (i-- > 0)
! 590: (*etype->uninit)(etype, (char *)to + (i * etype->size));
! 591: return (-1);
! 592: }
! 593:
! 594: /* Done */
! 595: return (0);
! 596: }
! 597:
! 598: int
! 599: structs_fixedarray_equal(const struct structs_type *type,
! 600: const void *v1, const void *v2)
! 601: {
! 602: const struct structs_type *const etype = type->args[0].v;
! 603: const u_int length = type->args[2].i;
! 604: u_int i;
! 605:
! 606: /* Make sure it's really a fixedarray type */
! 607: if (type->tclass != STRUCTS_TYPE_FIXEDARRAY)
! 608: return (0);
! 609:
! 610: /* Compare individual elements */
! 611: for (i = 0;
! 612: i < length && (*etype->equal)(etype,
! 613: (char *)v1 + (i * etype->size), (char *)v2 + (i * etype->size));
! 614: i++);
! 615: return (i == length);
! 616: }
! 617:
! 618: int
! 619: structs_fixedarray_encode(const struct structs_type *type, const char *mtype,
! 620: struct structs_data *code, const void *data)
! 621: {
! 622: const struct structs_type *const etype = type->args[0].v;
! 623: const u_int length = type->args[2].i;
! 624: const u_int bitslen = NUM_BYTES(length);
! 625: struct structs_data *ecodes;
! 626: u_char *bits;
! 627: void *delem;
! 628: u_int tlen;
! 629: int r = -1;
! 630: u_int i;
! 631:
! 632: /* Make sure it's really a fixedarray type */
! 633: if (type->tclass != STRUCTS_TYPE_FIXEDARRAY) {
! 634: errno = EINVAL;
! 635: return (-1);
! 636: }
! 637:
! 638: /* Get the default value for an element */
! 639: if ((delem = MALLOC(TYPED_MEM_TEMP, etype->size)) == NULL)
! 640: return (-1);
! 641: if (structs_init(etype, NULL, delem) == -1)
! 642: goto fail1;
! 643:
! 644: /* Create bit array. Each bit indicates an element that is present. */
! 645: if ((bits = MALLOC(TYPED_MEM_TEMP, bitslen)) == NULL)
! 646: goto fail2;
! 647: memset(bits, 0, bitslen);
! 648: tlen = bitslen;
! 649:
! 650: /* Create array of individual encodings, one per element */
! 651: if ((ecodes = MALLOC(TYPED_MEM_TEMP, length * sizeof(*ecodes))) == NULL)
! 652: goto fail3;
! 653: for (i = 0; i < length; i++) {
! 654: const void *const elem = (char *)data + (i * etype->size);
! 655: struct structs_data *const ecode = &ecodes[i];
! 656:
! 657: /* Check for default value, leave out if same as */
! 658: if ((*etype->equal)(etype, elem, delem) == 1) {
! 659: memset(ecode, 0, sizeof(*ecode));
! 660: continue;
! 661: }
! 662: bits[i / 8] |= (1 << (i % 8));
! 663:
! 664: /* Encode element */
! 665: if ((*etype->encode)(etype, TYPED_MEM_TEMP, ecode, elem) == -1)
! 666: goto fail4;
! 667: tlen += ecode->length;
! 668: }
! 669:
! 670: /* Allocate final encoded region */
! 671: if ((code->data = MALLOC(mtype, tlen)) == NULL)
! 672: goto fail4;
! 673:
! 674: /* Copy bits array */
! 675: memcpy(code->data, bits, bitslen);
! 676: code->length = bitslen;
! 677:
! 678: /* Copy encoded elements */
! 679: for (i = 0; i < length; i++) {
! 680: struct structs_data *const ecode = &ecodes[i];
! 681:
! 682: memcpy(code->data + code->length, ecode->data, ecode->length);
! 683: code->length += ecode->length;
! 684: }
! 685:
! 686: /* OK */
! 687: r = 0;
! 688:
! 689: /* Clean up and exit */
! 690: fail4: while (i-- > 0)
! 691: FREE(TYPED_MEM_TEMP, ecodes[i].data);
! 692: FREE(TYPED_MEM_TEMP, ecodes);
! 693: fail3: FREE(TYPED_MEM_TEMP, bits);
! 694: fail2: structs_free(etype, NULL, delem);
! 695: fail1: FREE(TYPED_MEM_TEMP, delem);
! 696: return (r);
! 697: }
! 698:
! 699: int
! 700: structs_fixedarray_decode(const struct structs_type *type, const u_char *code,
! 701: size_t cmax, void *data, char *ebuf, size_t emax)
! 702: {
! 703: const struct structs_type *const etype = type->args[0].v;
! 704: const u_int length = type->args[2].i;
! 705: const u_int bitslen = NUM_BYTES(length);
! 706: const u_char *bits;
! 707: int clen = 0;
! 708: u_int i;
! 709:
! 710: /* Make sure it's really a fixedarray type */
! 711: if (type->tclass != STRUCTS_TYPE_FIXEDARRAY) {
! 712: errno = EINVAL;
! 713: return (-1);
! 714: }
! 715:
! 716: /* Get bits array */
! 717: if (cmax < bitslen) {
! 718: strlcpy(ebuf, "encoded array is truncated", emax);
! 719: errno = EINVAL;
! 720: return (-1);
! 721: }
! 722: bits = code;
! 723: code += bitslen;
! 724: cmax -= bitslen;
! 725: clen += bitslen;
! 726:
! 727: /* Decode elements */
! 728: for (i = 0; i < length; i++) {
! 729: void *const edata = (char *)data + (i * etype->size);
! 730: int eclen;
! 731:
! 732: /* If element not present, assign it the default value */
! 733: if ((bits[i / 8] & (1 << (i % 8))) == 0) {
! 734: if (structs_init(etype, NULL, edata) == -1)
! 735: goto fail;
! 736: continue;
! 737: }
! 738:
! 739: /* Decode element */
! 740: if ((eclen = (*etype->decode)(etype,
! 741: code, cmax, edata, ebuf, emax)) == -1)
! 742: goto fail;
! 743:
! 744: /* Go to next encoded element */
! 745: code += eclen;
! 746: cmax -= eclen;
! 747: clen += eclen;
! 748: continue;
! 749:
! 750: /* Un-do work done so far */
! 751: fail: while (i-- > 0) {
! 752: structs_free(etype, NULL,
! 753: (char *)data + (i * etype->size));
! 754: }
! 755: return (-1);
! 756: }
! 757:
! 758: /* Done */
! 759: return (clen);
! 760: }
! 761:
! 762: void
! 763: structs_fixedarray_free(const struct structs_type *type, void *data)
! 764: {
! 765: const struct structs_type *const etype = type->args[0].v;
! 766: const u_int length = type->args[2].i;
! 767: u_int i;
! 768:
! 769: /* Make sure it's really a fixedarray type */
! 770: if (type->tclass != STRUCTS_TYPE_FIXEDARRAY)
! 771: return;
! 772:
! 773: /* Free elements */
! 774: for (i = 0; i < length; i++)
! 775: (*etype->uninit)(etype, (char *)data + (i * etype->size));
! 776: }
! 777:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_type_array.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