Annotation of embedaddon/mpd/src/contrib/libpdel/structs/structs.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:
! 43: #include <stdlib.h>
! 44: #include <stdio.h>
! 45: #include <stdarg.h>
! 46: #include <assert.h>
! 47: #include <string.h>
! 48: #include <ctype.h>
! 49: #include <errno.h>
! 50:
! 51: #include "structs/structs.h"
! 52: #include "structs/type/int.h"
! 53: #include "structs/type/array.h"
! 54: #include "structs/type/string.h"
! 55: #include "structs/type/struct.h"
! 56: #include "structs/type/union.h"
! 57: #include "util/typed_mem.h"
! 58:
! 59: /* Special handling for array length as a read-only field */
! 60: static const struct structs_type structs_type_array_length = {
! 61: sizeof(u_int),
! 62: "uint",
! 63: STRUCTS_TYPE_PRIMITIVE,
! 64: structs_region_init,
! 65: structs_region_copy,
! 66: structs_region_equal,
! 67: structs_int_ascify,
! 68: structs_notsupp_binify,
! 69: structs_region_encode_netorder,
! 70: structs_notsupp_decode,
! 71: structs_nothing_free,
! 72: { { (void *)2 }, { (void *)0 } } /* args for structs_int_ascify */
! 73: };
! 74:
! 75: /* Special handling for union field name as a read-only field */
! 76: static const struct structs_type structs_type_union_field_name = {
! 77: sizeof(char *),
! 78: "string",
! 79: STRUCTS_TYPE_PRIMITIVE,
! 80: structs_notsupp_init,
! 81: structs_notsupp_copy,
! 82: structs_string_equal,
! 83: structs_string_ascify,
! 84: structs_notsupp_binify,
! 85: structs_notsupp_encode,
! 86: structs_notsupp_decode,
! 87: structs_nothing_free,
! 88: { { (void *)"union field_name" }, /* args for structs_type_string */
! 89: { (void *)0 } }
! 90: };
! 91:
! 92: /*
! 93: * Initialize an item.
! 94: */
! 95: int
! 96: structs_init(const struct structs_type *type, const char *name, void *data)
! 97: {
! 98: /* Find item */
! 99: if ((type = structs_find(type, name, &data, 0)) == NULL)
! 100: return (-1);
! 101:
! 102: /* Initialize it */
! 103: return ((*type->init)(type, data));
! 104: }
! 105:
! 106: /*
! 107: * Reset an item.
! 108: */
! 109: int
! 110: structs_reset(const struct structs_type *type, const char *name, void *data)
! 111: {
! 112: void *temp;
! 113:
! 114: /* Find item */
! 115: if ((type = structs_find(type, name, &data, 0)) == NULL)
! 116: return (-1);
! 117:
! 118: /* Make a temporary new copy */
! 119: if ((temp = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL)
! 120: return (-1);
! 121: memset(temp, 0, type->size);
! 122: if ((*type->init)(type, temp) == -1) {
! 123: FREE(TYPED_MEM_TEMP, temp);
! 124: return (-1);
! 125: }
! 126:
! 127: /* Replace existing item, freeing it first */
! 128: (*type->uninit)(type, data);
! 129: memcpy(data, temp, type->size);
! 130: FREE(TYPED_MEM_TEMP, temp);
! 131: return (0);
! 132: }
! 133:
! 134: /*
! 135: * Free an item, returning it to its initialized state.
! 136: *
! 137: * If "name" is NULL or empty string, the entire structure is free'd.
! 138: */
! 139: int
! 140: structs_free(const struct structs_type *type, const char *name, void *data)
! 141: {
! 142: const int errno_save = errno;
! 143:
! 144: /* Find item */
! 145: if ((type = structs_find(type, name, &data, 0)) == NULL)
! 146: return (-1);
! 147:
! 148: /* Free it */
! 149: (*type->uninit)(type, data);
! 150: errno = errno_save;
! 151: return (0);
! 152: }
! 153:
! 154: /*
! 155: * Get a copy of an item.
! 156: *
! 157: * If "name" is NULL or empty string, the entire structure is copied.
! 158: *
! 159: * It is assumed that "to" points to a region big enough to hold
! 160: * the copy of the item. "to" will not be free'd first, so it should
! 161: * not already be initialized.
! 162: *
! 163: * Note: "name" is only applied to "from". The structs types of
! 164: * "from.<name>" and "to" must be the same.
! 165: */
! 166: int
! 167: structs_get(const struct structs_type *type,
! 168: const char *name, const void *from, void *to)
! 169: {
! 170: /* Find item */
! 171: if ((type = structs_find(type, name, (void **)&from, 0)) == NULL)
! 172: return (-1);
! 173:
! 174: /* Copy item */
! 175: return ((*type->copy)(type, from, to));
! 176: }
! 177:
! 178: /*
! 179: * Set an item in a structure.
! 180: *
! 181: * If "name" is NULL or empty string, the entire structure is copied.
! 182: *
! 183: * It is assumed that "to" is already initialized.
! 184: *
! 185: * Note: "name" is only applied to "to". The structs types of
! 186: * "from" and "to.<name>" must be the same.
! 187: */
! 188: int
! 189: structs_set(const struct structs_type *type,
! 190: const void *from, const char *name, void *to)
! 191: {
! 192: void *copy;
! 193:
! 194: /* Find item */
! 195: if ((type = structs_find(type, name, &to, 0)) == NULL)
! 196: return (-1);
! 197:
! 198: /* Make a new copy of 'from' */
! 199: if ((copy = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL)
! 200: return (-1);
! 201: if ((*type->copy)(type, from, copy) == -1) {
! 202: FREE(TYPED_MEM_TEMP, copy);
! 203: return (-1);
! 204: }
! 205:
! 206: /* Free overwritten item in 'to' */
! 207: (*type->uninit)(type, to);
! 208:
! 209: /* Move new item in its place */
! 210: memcpy(to, copy, type->size);
! 211:
! 212: /* Done */
! 213: FREE(TYPED_MEM_TEMP, copy);
! 214: return (0);
! 215: }
! 216:
! 217: /*
! 218: * Get the ASCII form of an item.
! 219: */
! 220: char *
! 221: structs_get_string(const struct structs_type *type,
! 222: const char *name, const void *data, const char *mtype)
! 223: {
! 224: /* Find item */
! 225: if ((type = structs_find(type, name, (void **)&data, 0)) == NULL)
! 226: return (NULL);
! 227:
! 228: /* Ascify it */
! 229: return ((*type->ascify)(type, mtype, data));
! 230: }
! 231:
! 232: /*
! 233: * Set an item's value from a string.
! 234: *
! 235: * The referred to item must be of a type that supports ASCII encoding,
! 236: * and is assumed to be already initialized.
! 237: */
! 238: int
! 239: structs_set_string(const struct structs_type *type, const char *name,
! 240: const char *ascii, void *data, char *ebuf, size_t emax)
! 241: {
! 242: void *temp;
! 243: char dummy[1];
! 244:
! 245: /* Sanity check */
! 246: if (ascii == NULL)
! 247: ascii = "";
! 248: if (ebuf == NULL) {
! 249: ebuf = dummy;
! 250: emax = sizeof(dummy);
! 251: }
! 252:
! 253: /* Initialize error buffer */
! 254: if (emax > 0)
! 255: *ebuf = '\0';
! 256:
! 257: /* Find item */
! 258: if ((type = structs_find(type, name, &data, 1)) == NULL) {
! 259: strlcpy(ebuf, strerror(errno), emax);
! 260: return (-1);
! 261: }
! 262:
! 263: /* Binify item into temporary storage */
! 264: if ((temp = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL)
! 265: return (-1);
! 266: memset(temp, 0, type->size);
! 267: if ((*type->binify)(type, ascii, temp, ebuf, emax) == -1) {
! 268: FREE(TYPED_MEM_TEMP, temp);
! 269: if (emax > 0 && *ebuf == '\0')
! 270: strlcpy(ebuf, strerror(errno), emax);
! 271: return (-1);
! 272: }
! 273:
! 274: /* Replace existing item, freeing it first */
! 275: (*type->uninit)(type, data);
! 276: memcpy(data, temp, type->size);
! 277: FREE(TYPED_MEM_TEMP, temp);
! 278: return (0);
! 279: }
! 280:
! 281: /*
! 282: * Get the binary encoded form of an item, allocated with type 'mtype'.
! 283: */
! 284: int
! 285: structs_get_binary(const struct structs_type *type, const char *name,
! 286: const void *data, const char *mtype, struct structs_data *code)
! 287: {
! 288: /* Find item */
! 289: if ((type = structs_find(type, name, (void **)&data, 0)) == NULL) {
! 290: memset(code, 0, sizeof(*code));
! 291: return (-1);
! 292: }
! 293:
! 294: /* Encode it */
! 295: if ((*type->encode)(type, mtype, code, data) == -1) {
! 296: memset(code, 0, sizeof(*code));
! 297: return (-1);
! 298: }
! 299:
! 300: /* Done */
! 301: return (0);
! 302: }
! 303:
! 304: /*
! 305: * Set an item's value from its binary encoded value.
! 306: */
! 307: int
! 308: structs_set_binary(const struct structs_type *type, const char *name,
! 309: const struct structs_data *code, void *data, char *ebuf, size_t emax)
! 310: {
! 311: void *temp;
! 312: int clen;
! 313:
! 314: /* Initialize error buffer */
! 315: if (emax > 0)
! 316: *ebuf = '\0';
! 317:
! 318: /* Find item */
! 319: if ((type = structs_find(type, name, (void **)&data, 0)) == NULL) {
! 320: strlcpy(ebuf, strerror(errno), emax);
! 321: return (-1);
! 322: }
! 323:
! 324: /* Decode item into temporary storage */
! 325: if ((temp = MALLOC(TYPED_MEM_TEMP, type->size)) == NULL)
! 326: return (-1);
! 327: memset(temp, 0, type->size);
! 328: if ((clen = (*type->decode)(type, code->data,
! 329: code->length, temp, ebuf, emax)) == -1) {
! 330: FREE(TYPED_MEM_TEMP, temp);
! 331: if (emax > 0 && *ebuf == '\0')
! 332: strlcpy(ebuf, strerror(errno), emax);
! 333: return (-1);
! 334: }
! 335: assert(clen <= code->length);
! 336:
! 337: /* Replace existing item, freeing it first */
! 338: (*type->uninit)(type, data);
! 339: memcpy(data, temp, type->size);
! 340: FREE(TYPED_MEM_TEMP, temp);
! 341:
! 342: /* Done */
! 343: return (clen);
! 344: }
! 345:
! 346: /*
! 347: * Test for equality.
! 348: */
! 349: int
! 350: structs_equal(const struct structs_type *type,
! 351: const char *name, const void *data1, const void *data2)
! 352: {
! 353: /* Find items */
! 354: if (structs_find(type, name, (void **)&data1, 0) == NULL)
! 355: return (-1);
! 356: if ((type = structs_find(type, name, (void **)&data2, 0)) == NULL)
! 357: return (-1);
! 358:
! 359: /* Compare them */
! 360: return ((*type->equal)(type, data1, data2));
! 361: }
! 362:
! 363: /*
! 364: * Find an item in a structure.
! 365: */
! 366: const struct structs_type *
! 367: structs_find(const struct structs_type *type, const char *name,
! 368: void **datap, int set_union)
! 369: {
! 370: void *data = *datap;
! 371: const char *next;
! 372:
! 373: /* Empty string means stop recursing */
! 374: if (name == NULL || *name == '\0')
! 375: return (type);
! 376:
! 377: /* Primitive types don't have sub-elements */
! 378: if (type->tclass == STRUCTS_TYPE_PRIMITIVE) {
! 379: errno = ENOENT;
! 380: return (NULL);
! 381: }
! 382:
! 383: /* Dereference through pointer(s) */
! 384: while (type->tclass == STRUCTS_TYPE_POINTER) {
! 385: type = type->args[0].v;
! 386: data = *((void **)data);
! 387: }
! 388:
! 389: /* Get next name component */
! 390: if ((next = strchr(name, STRUCTS_SEPARATOR)) != NULL)
! 391: next++;
! 392:
! 393: /* Find element of aggregate structure update type and data */
! 394: switch (type->tclass) {
! 395: case STRUCTS_TYPE_ARRAY:
! 396: {
! 397: const struct structs_type *const etype = type->args[0].v;
! 398: const struct structs_array *const ary = data;
! 399: u_long index;
! 400: char *eptr;
! 401:
! 402: /* Special handling for "length" */
! 403: if (strcmp(name, "length") == 0) {
! 404: type = &structs_type_array_length;
! 405: data = (void *)&ary->length;
! 406: break;
! 407: }
! 408:
! 409: /* Decode an index */
! 410: index = strtoul(name, &eptr, 10);
! 411: if (!isdigit(*name)
! 412: || eptr == name
! 413: || (*eptr != '\0' && *eptr != STRUCTS_SEPARATOR)) {
! 414: errno = ENOENT;
! 415: return (NULL);
! 416: }
! 417: if (index >= ary->length) {
! 418: errno = EDOM;
! 419: return (NULL);
! 420: }
! 421: type = etype;
! 422: data = (char *)ary->elems + (index * etype->size);
! 423: break;
! 424: }
! 425: case STRUCTS_TYPE_FIXEDARRAY:
! 426: {
! 427: const struct structs_type *const etype = type->args[0].v;
! 428: const u_int length = type->args[2].i;
! 429: u_long index;
! 430: char *eptr;
! 431:
! 432: /* Special handling for "length" */
! 433: if (strcmp(name, "length") == 0) {
! 434: type = &structs_type_array_length;
! 435: data = (void *)&type->args[2].i;
! 436: break;
! 437: }
! 438:
! 439: /* Decode an index */
! 440: index = strtoul(name, &eptr, 10);
! 441: if (!isdigit(*name)
! 442: || eptr == name
! 443: || (*eptr != '\0' && *eptr != STRUCTS_SEPARATOR)) {
! 444: errno = ENOENT;
! 445: return (NULL);
! 446: }
! 447: if (index >= length) {
! 448: errno = EDOM;
! 449: return (NULL);
! 450: }
! 451: type = etype;
! 452: data = (char *)data + (index * etype->size);
! 453: break;
! 454: }
! 455: case STRUCTS_TYPE_STRUCTURE:
! 456: {
! 457: const struct structs_field *field;
! 458:
! 459: /* Find the field */
! 460: for (field = type->args[0].v; field->name != NULL; field++) {
! 461: const size_t fnlen = strlen(field->name);
! 462:
! 463: /* Handle field names with separator in them */
! 464: if (strncmp(name, field->name, fnlen) == 0
! 465: && (name[fnlen] == '\0'
! 466: || name[fnlen] == STRUCTS_SEPARATOR)) {
! 467: next = (name[fnlen] != '\0') ?
! 468: name + fnlen + 1 : NULL;
! 469: break;
! 470: }
! 471: }
! 472: if (field->name == NULL) {
! 473: errno = ENOENT;
! 474: return (NULL);
! 475: }
! 476: type = field->type;
! 477: data = (char *)data + field->offset;
! 478: break;
! 479: }
! 480: case STRUCTS_TYPE_UNION:
! 481: {
! 482: const struct structs_ufield *const fields = type->args[0].v;
! 483: const char *const mtype = type->args[1].s;
! 484: struct structs_union *const un = data;
! 485: const size_t oflen = strlen(un->field_name);
! 486: const struct structs_ufield *ofield;
! 487: const struct structs_ufield *field;
! 488: void *new_un;
! 489: void *data2;
! 490:
! 491: /* Special handling for "field_name" */
! 492: if (strcmp(name, "field_name") == 0) {
! 493: type = &structs_type_union_field_name;
! 494: data = (void *)&un->field_name;
! 495: break;
! 496: }
! 497:
! 498: /* Find the old field */
! 499: for (ofield = fields; ofield->name != NULL; ofield++) {
! 500: if (strcmp(ofield->name, un->field_name) == 0)
! 501: break;
! 502: }
! 503: if (ofield->name == NULL) {
! 504: assert(0);
! 505: errno = EINVAL;
! 506: return (NULL);
! 507: }
! 508:
! 509: /*
! 510: * Check if the union is already set to the desired field,
! 511: * handling field names with the separator char in them.
! 512: */
! 513: if (strncmp(name, un->field_name, oflen) == 0
! 514: && (name[oflen] == '\0'
! 515: || name[oflen] == STRUCTS_SEPARATOR)) {
! 516: next = (name[oflen] != '\0') ? name + oflen + 1 : NULL;
! 517: field = ofield;
! 518: goto union_done;
! 519: }
! 520:
! 521: /* Is modifying the union to get the right name acceptable? */
! 522: if (!set_union) {
! 523: errno = ENOENT;
! 524: return (NULL);
! 525: }
! 526:
! 527: /* Find the new field */
! 528: for (field = fields; field->name != NULL; field++) {
! 529: const size_t fnlen = strlen(field->name);
! 530:
! 531: /* Handle field names with separator in them */
! 532: if (strncmp(name, field->name, fnlen) == 0
! 533: && (name[fnlen] == '\0'
! 534: || name[fnlen] == STRUCTS_SEPARATOR)) {
! 535: next = (name[fnlen] != '\0') ?
! 536: name + fnlen + 1 : NULL;
! 537: break;
! 538: }
! 539: }
! 540: if (field->name == NULL) {
! 541: errno = ENOENT;
! 542: return (NULL);
! 543: }
! 544:
! 545: /* Create a new union with the new field type */
! 546: if ((new_un = MALLOC(mtype, field->type->size)) == NULL)
! 547: return (NULL);
! 548: if ((*field->type->init)(field->type, new_un) == -1) {
! 549: FREE(mtype, new_un);
! 550: return (NULL);
! 551: }
! 552:
! 553: /* See if name would be found with new union instead of old */
! 554: data2 = new_un;
! 555: if (next != NULL
! 556: && structs_find(field->type, next, &data2, 1) == NULL) {
! 557: (*field->type->uninit)(field->type, new_un);
! 558: FREE(mtype, new_un);
! 559: return (NULL);
! 560: }
! 561:
! 562: /* Replace existing union with new one having desired type */
! 563: (*ofield->type->uninit)(ofield->type, un->un);
! 564: FREE(mtype, un->un);
! 565: un->un = new_un;
! 566: *((const char **)&un->field_name) = field->name;
! 567:
! 568: union_done:
! 569: /* Continue recursing */
! 570: type = field->type;
! 571: data = un->un;
! 572: break;
! 573: }
! 574: default:
! 575: assert(0);
! 576: return (NULL);
! 577: }
! 578:
! 579: /* Recurse on sub-element */
! 580: if ((type = structs_find(type, next, &data, set_union)) == NULL)
! 581: return (NULL);
! 582:
! 583: /* Done */
! 584: *datap = data;
! 585: return (type);
! 586: }
! 587:
! 588: /*
! 589: * Traverse a structure.
! 590: */
! 591:
! 592: struct structs_trav {
! 593: char **list;
! 594: u_int len;
! 595: u_int alloc;
! 596: const char *mtype;
! 597: };
! 598:
! 599: static int structs_trav(struct structs_trav *t, const char *name,
! 600: const struct structs_type *type, const void *data);
! 601:
! 602: int
! 603: structs_traverse(const struct structs_type *type,
! 604: const void *data, char ***listp, const char *mtype)
! 605: {
! 606: struct structs_trav t;
! 607:
! 608: /* Initialize traversal structure */
! 609: memset(&t, 0, sizeof(t));
! 610: t.mtype = mtype;
! 611:
! 612: /* Recurse */
! 613: if (structs_trav(&t, "", type, data) == -1) {
! 614: while (t.len > 0)
! 615: FREE(t.mtype, t.list[--t.len]);
! 616: FREE(t.mtype, t.list);
! 617: return (-1);
! 618: }
! 619:
! 620: /* Return the result */
! 621: *listp = t.list;
! 622: return (t.len);
! 623: }
! 624:
! 625: static int
! 626: structs_trav(struct structs_trav *t, const char *name,
! 627: const struct structs_type *type, const void *data)
! 628: {
! 629: const char *const dot = (*name == '\0' ? "" : ".");
! 630: char *ename;
! 631: int i;
! 632:
! 633: /* Dereference through pointer(s) */
! 634: while (type->tclass == STRUCTS_TYPE_POINTER) {
! 635: type = type->args[0].v;
! 636: data = *((void **)data);
! 637: }
! 638:
! 639: switch (type->tclass) {
! 640: case STRUCTS_TYPE_PRIMITIVE:
! 641: {
! 642: /* Grow list as necessary */
! 643: if (t->len == t->alloc) {
! 644: u_int new_alloc;
! 645: char **new_list;
! 646:
! 647: new_alloc = (t->alloc + 32) * 2;
! 648: if ((new_list = REALLOC(t->mtype,
! 649: t->list, new_alloc * sizeof(*t->list))) == NULL)
! 650: return (-1);
! 651: t->list = new_list;
! 652: t->alloc = new_alloc;
! 653: }
! 654:
! 655: /* Add new name to list */
! 656: if ((t->list[t->len] = STRDUP(t->mtype, name)) == NULL)
! 657: return (-1);
! 658: t->len++;
! 659:
! 660: /* Done */
! 661: return (0);
! 662: }
! 663:
! 664: case STRUCTS_TYPE_ARRAY:
! 665: {
! 666: const struct structs_type *const etype = type->args[0].v;
! 667: const struct structs_array *const ary = data;
! 668:
! 669: /* Iterate over array elements */
! 670: for (i = 0; i < ary->length; i++) {
! 671: const void *const edata
! 672: = (char *)ary->elems + (i * etype->size);
! 673:
! 674: if (ASPRINTF(t->mtype,
! 675: &ename, "%s%s%d", name, dot, i) == -1)
! 676: return (-1);
! 677: if (structs_trav(t, ename, etype, edata) == -1) {
! 678: FREE(t->mtype, ename);
! 679: return (-1);
! 680: }
! 681: FREE(t->mtype, ename);
! 682: }
! 683:
! 684: /* Done */
! 685: return (0);
! 686: }
! 687:
! 688: case STRUCTS_TYPE_FIXEDARRAY:
! 689: {
! 690: const struct structs_type *const etype = type->args[0].v;
! 691: const u_int length = type->args[2].i;
! 692:
! 693: /* Iterate over array elements */
! 694: for (i = 0; i < length; i++) {
! 695: const void *const edata
! 696: = (char *)data + (i * etype->size);
! 697:
! 698: if (ASPRINTF(t->mtype,
! 699: &ename, "%s%s%d", name, dot, i) == -1)
! 700: return (-1);
! 701: if (structs_trav(t, ename, etype, edata) == -1) {
! 702: FREE(t->mtype, ename);
! 703: return (-1);
! 704: }
! 705: FREE(t->mtype, ename);
! 706: }
! 707:
! 708: /* Done */
! 709: return (0);
! 710: }
! 711:
! 712: case STRUCTS_TYPE_STRUCTURE:
! 713: {
! 714: const struct structs_field *field;
! 715:
! 716: /* Iterate over structure fields */
! 717: for (field = type->args[0].v; field->name != NULL; field++) {
! 718: const void *const edata
! 719: = (char *)data + field->offset;
! 720:
! 721: if (ASPRINTF(t->mtype,
! 722: &ename, "%s%s%s", name, dot, field->name) == -1)
! 723: return (-1);
! 724: if (structs_trav(t, ename, field->type, edata) == -1) {
! 725: FREE(t->mtype, ename);
! 726: return (-1);
! 727: }
! 728: FREE(t->mtype, ename);
! 729: }
! 730:
! 731: /* Done */
! 732: return (0);
! 733: }
! 734:
! 735: case STRUCTS_TYPE_UNION:
! 736: {
! 737: const struct structs_ufield *const fields = type->args[0].v;
! 738: const struct structs_union *const un = data;
! 739: const struct structs_ufield *field;
! 740:
! 741: /* Find field */
! 742: for (field = fields; field->name != NULL
! 743: && strcmp(un->field_name, field->name) != 0; field++);
! 744: if (field->name == NULL) {
! 745: assert(0);
! 746: errno = EINVAL;
! 747: return (-1);
! 748: }
! 749:
! 750: /* Do selected union field */
! 751: if (ASPRINTF(t->mtype,
! 752: &ename, "%s%s%s", name, dot, field->name) == -1)
! 753: return (-1);
! 754: if (structs_trav(t, ename, field->type, un->un) == -1) {
! 755: FREE(t->mtype, ename);
! 756: return (-1);
! 757: }
! 758: FREE(t->mtype, ename);
! 759:
! 760: /* Done */
! 761: return (0);
! 762: }
! 763:
! 764: default:
! 765: assert(0);
! 766: errno = ECONNABORTED;
! 767: return (-1);
! 768: }
! 769: }
! 770:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs.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