ng_parse.c revision 139823
1/* 2 * ng_parse.c 3 */ 4 5/*- 6 * Copyright (c) 1999 Whistle Communications, Inc. 7 * All rights reserved. 8 * 9 * Subject to the following obligations and disclaimer of warranty, use and 10 * redistribution of this software, in source or object code forms, with or 11 * without modifications are expressly permitted by Whistle Communications; 12 * provided, however, that: 13 * 1. Any and all reproductions of the source or object code must include the 14 * copyright notice above and the following disclaimer of warranties; and 15 * 2. No rights are granted, in any manner or form, to use Whistle 16 * Communications, Inc. trademarks, including the mark "WHISTLE 17 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 18 * such appears in the above copyright notice or in the software. 19 * 20 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 21 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 22 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 23 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 25 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 26 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 27 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 28 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 29 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 30 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 32 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 36 * OF SUCH DAMAGE. 37 * 38 * Author: Archie Cobbs <archie@freebsd.org> 39 * 40 * $Whistle: ng_parse.c,v 1.3 1999/11/29 01:43:48 archie Exp $ 41 * $FreeBSD: head/sys/netgraph/ng_parse.c 139823 2005-01-07 01:45:51Z imp $ 42 */ 43 44#include <sys/types.h> 45#include <sys/param.h> 46#include <sys/systm.h> 47#include <sys/kernel.h> 48#include <sys/errno.h> 49#include <sys/malloc.h> 50#include <sys/mbuf.h> 51#include <sys/ctype.h> 52 53#include <net/ethernet.h> 54 55#include <netinet/in.h> 56 57#include <netgraph/ng_message.h> 58#include <netgraph/netgraph.h> 59#include <netgraph/ng_parse.h> 60 61#ifdef NG_SEPARATE_MALLOC 62MALLOC_DEFINE(M_NETGRAPH_PARSE, "netgraph_parse", "netgraph parse info"); 63#else 64#define M_NETGRAPH_PARSE M_NETGRAPH 65#endif 66 67/* Compute alignment for primitive integral types */ 68struct int16_temp { 69 char x; 70 int16_t y; 71}; 72 73struct int32_temp { 74 char x; 75 int32_t y; 76}; 77 78struct int64_temp { 79 char x; 80 int64_t y; 81}; 82 83#define INT8_ALIGNMENT 1 84#define INT16_ALIGNMENT ((int)&((struct int16_temp *)0)->y) 85#define INT32_ALIGNMENT ((int)&((struct int32_temp *)0)->y) 86#define INT64_ALIGNMENT ((int)&((struct int64_temp *)0)->y) 87 88/* Output format for integral types */ 89#define INT_UNSIGNED 0 90#define INT_SIGNED 1 91#define INT_HEX 2 92 93/* Type of composite object: struct, array, or fixedarray */ 94enum comptype { 95 CT_STRUCT, 96 CT_ARRAY, 97 CT_FIXEDARRAY, 98}; 99 100/* Composite types helper functions */ 101static int ng_parse_composite(const struct ng_parse_type *type, 102 const char *s, int *off, const u_char *start, 103 u_char *const buf, int *buflen, enum comptype ctype); 104static int ng_unparse_composite(const struct ng_parse_type *type, 105 const u_char *data, int *off, char *cbuf, int cbuflen, 106 enum comptype ctype); 107static int ng_get_composite_elem_default(const struct ng_parse_type *type, 108 int index, const u_char *start, u_char *buf, 109 int *buflen, enum comptype ctype); 110static int ng_get_composite_len(const struct ng_parse_type *type, 111 const u_char *start, const u_char *buf, 112 enum comptype ctype); 113static const struct ng_parse_type *ng_get_composite_etype(const struct 114 ng_parse_type *type, int index, enum comptype ctype); 115static int ng_parse_get_elem_pad(const struct ng_parse_type *type, 116 int index, enum comptype ctype, int posn); 117 118/* Parsing helper functions */ 119static int ng_parse_skip_value(const char *s, int off, int *lenp); 120 121/* Poor man's virtual method calls */ 122#define METHOD(t,m) (ng_get_ ## m ## _method(t)) 123#define INVOKE(t,m) (*METHOD(t,m)) 124 125static ng_parse_t *ng_get_parse_method(const struct ng_parse_type *t); 126static ng_unparse_t *ng_get_unparse_method(const struct ng_parse_type *t); 127static ng_getDefault_t *ng_get_getDefault_method(const 128 struct ng_parse_type *t); 129static ng_getAlign_t *ng_get_getAlign_method(const struct ng_parse_type *t); 130 131#define ALIGNMENT(t) (METHOD(t, getAlign) == NULL ? \ 132 0 : INVOKE(t, getAlign)(t)) 133 134/* For converting binary to string */ 135#define NG_PARSE_APPEND(fmt, args...) \ 136 do { \ 137 int len; \ 138 \ 139 len = snprintf((cbuf), (cbuflen), \ 140 fmt , ## args); \ 141 if (len >= (cbuflen)) \ 142 return (ERANGE); \ 143 (cbuf) += len; \ 144 (cbuflen) -= len; \ 145 } while (0) 146 147/************************************************************************ 148 PUBLIC FUNCTIONS 149 ************************************************************************/ 150 151/* 152 * Convert an ASCII string to binary according to the supplied type descriptor 153 */ 154int 155ng_parse(const struct ng_parse_type *type, 156 const char *string, int *off, u_char *buf, int *buflen) 157{ 158 return INVOKE(type, parse)(type, string, off, buf, buf, buflen); 159} 160 161/* 162 * Convert binary to an ASCII string according to the supplied type descriptor 163 */ 164int 165ng_unparse(const struct ng_parse_type *type, 166 const u_char *data, char *cbuf, int cbuflen) 167{ 168 int off = 0; 169 170 return INVOKE(type, unparse)(type, data, &off, cbuf, cbuflen); 171} 172 173/* 174 * Fill in the default value according to the supplied type descriptor 175 */ 176int 177ng_parse_getDefault(const struct ng_parse_type *type, u_char *buf, int *buflen) 178{ 179 ng_getDefault_t *const func = METHOD(type, getDefault); 180 181 if (func == NULL) 182 return (EOPNOTSUPP); 183 return (*func)(type, buf, buf, buflen); 184} 185 186 187/************************************************************************ 188 STRUCTURE TYPE 189 ************************************************************************/ 190 191static int 192ng_struct_parse(const struct ng_parse_type *type, 193 const char *s, int *off, const u_char *const start, 194 u_char *const buf, int *buflen) 195{ 196 return ng_parse_composite(type, s, off, start, buf, buflen, CT_STRUCT); 197} 198 199static int 200ng_struct_unparse(const struct ng_parse_type *type, 201 const u_char *data, int *off, char *cbuf, int cbuflen) 202{ 203 return ng_unparse_composite(type, data, off, cbuf, cbuflen, CT_STRUCT); 204} 205 206static int 207ng_struct_getDefault(const struct ng_parse_type *type, 208 const u_char *const start, u_char *buf, int *buflen) 209{ 210 int off = 0; 211 212 return ng_parse_composite(type, 213 "{}", &off, start, buf, buflen, CT_STRUCT); 214} 215 216static int 217ng_struct_getAlign(const struct ng_parse_type *type) 218{ 219 const struct ng_parse_struct_field *field; 220 int align = 0; 221 222 for (field = type->info; field->name != NULL; field++) { 223 int falign = ALIGNMENT(field->type); 224 225 if (falign > align) 226 align = falign; 227 } 228 return align; 229} 230 231const struct ng_parse_type ng_parse_struct_type = { 232 NULL, 233 NULL, 234 NULL, 235 ng_struct_parse, 236 ng_struct_unparse, 237 ng_struct_getDefault, 238 ng_struct_getAlign 239}; 240 241/************************************************************************ 242 FIXED LENGTH ARRAY TYPE 243 ************************************************************************/ 244 245static int 246ng_fixedarray_parse(const struct ng_parse_type *type, 247 const char *s, int *off, const u_char *const start, 248 u_char *const buf, int *buflen) 249{ 250 return ng_parse_composite(type, 251 s, off, start, buf, buflen, CT_FIXEDARRAY); 252} 253 254static int 255ng_fixedarray_unparse(const struct ng_parse_type *type, 256 const u_char *data, int *off, char *cbuf, int cbuflen) 257{ 258 return ng_unparse_composite(type, 259 data, off, cbuf, cbuflen, CT_FIXEDARRAY); 260} 261 262static int 263ng_fixedarray_getDefault(const struct ng_parse_type *type, 264 const u_char *const start, u_char *buf, int *buflen) 265{ 266 int off = 0; 267 268 return ng_parse_composite(type, 269 "[]", &off, start, buf, buflen, CT_FIXEDARRAY); 270} 271 272static int 273ng_fixedarray_getAlign(const struct ng_parse_type *type) 274{ 275 const struct ng_parse_fixedarray_info *fi = type->info; 276 277 return ALIGNMENT(fi->elementType); 278} 279 280const struct ng_parse_type ng_parse_fixedarray_type = { 281 NULL, 282 NULL, 283 NULL, 284 ng_fixedarray_parse, 285 ng_fixedarray_unparse, 286 ng_fixedarray_getDefault, 287 ng_fixedarray_getAlign 288}; 289 290/************************************************************************ 291 VARIABLE LENGTH ARRAY TYPE 292 ************************************************************************/ 293 294static int 295ng_array_parse(const struct ng_parse_type *type, 296 const char *s, int *off, const u_char *const start, 297 u_char *const buf, int *buflen) 298{ 299 return ng_parse_composite(type, s, off, start, buf, buflen, CT_ARRAY); 300} 301 302static int 303ng_array_unparse(const struct ng_parse_type *type, 304 const u_char *data, int *off, char *cbuf, int cbuflen) 305{ 306 return ng_unparse_composite(type, data, off, cbuf, cbuflen, CT_ARRAY); 307} 308 309static int 310ng_array_getDefault(const struct ng_parse_type *type, 311 const u_char *const start, u_char *buf, int *buflen) 312{ 313 int off = 0; 314 315 return ng_parse_composite(type, 316 "[]", &off, start, buf, buflen, CT_ARRAY); 317} 318 319static int 320ng_array_getAlign(const struct ng_parse_type *type) 321{ 322 const struct ng_parse_array_info *ai = type->info; 323 324 return ALIGNMENT(ai->elementType); 325} 326 327const struct ng_parse_type ng_parse_array_type = { 328 NULL, 329 NULL, 330 NULL, 331 ng_array_parse, 332 ng_array_unparse, 333 ng_array_getDefault, 334 ng_array_getAlign 335}; 336 337/************************************************************************ 338 INT8 TYPE 339 ************************************************************************/ 340 341static int 342ng_int8_parse(const struct ng_parse_type *type, 343 const char *s, int *off, const u_char *const start, 344 u_char *const buf, int *buflen) 345{ 346 long val; 347 int8_t val8; 348 char *eptr; 349 350 val = strtol(s + *off, &eptr, 0); 351 if (val < (int8_t)0x80 || val > (u_int8_t)0xff || eptr == s + *off) 352 return (EINVAL); 353 *off = eptr - s; 354 val8 = (int8_t)val; 355 bcopy(&val8, buf, sizeof(int8_t)); 356 *buflen = sizeof(int8_t); 357 return (0); 358} 359 360static int 361ng_int8_unparse(const struct ng_parse_type *type, 362 const u_char *data, int *off, char *cbuf, int cbuflen) 363{ 364 const char *fmt; 365 int fval; 366 int8_t val; 367 368 bcopy(data + *off, &val, sizeof(int8_t)); 369 switch ((intptr_t)type->info) { 370 case INT_SIGNED: 371 fmt = "%d"; 372 fval = val; 373 break; 374 case INT_UNSIGNED: 375 fmt = "%u"; 376 fval = (u_int8_t)val; 377 break; 378 case INT_HEX: 379 fmt = "0x%x"; 380 fval = (u_int8_t)val; 381 break; 382 default: 383 panic("%s: unknown type", __func__); 384#ifdef RESTARTABLE_PANICS 385 return(0); 386#endif 387 } 388 NG_PARSE_APPEND(fmt, fval); 389 *off += sizeof(int8_t); 390 return (0); 391} 392 393static int 394ng_int8_getDefault(const struct ng_parse_type *type, 395 const u_char *const start, u_char *buf, int *buflen) 396{ 397 int8_t val; 398 399 if (*buflen < sizeof(int8_t)) 400 return (ERANGE); 401 val = 0; 402 bcopy(&val, buf, sizeof(int8_t)); 403 *buflen = sizeof(int8_t); 404 return (0); 405} 406 407static int 408ng_int8_getAlign(const struct ng_parse_type *type) 409{ 410 return INT8_ALIGNMENT; 411} 412 413const struct ng_parse_type ng_parse_int8_type = { 414 NULL, 415 (void *)INT_SIGNED, 416 NULL, 417 ng_int8_parse, 418 ng_int8_unparse, 419 ng_int8_getDefault, 420 ng_int8_getAlign 421}; 422 423const struct ng_parse_type ng_parse_uint8_type = { 424 &ng_parse_int8_type, 425 (void *)INT_UNSIGNED 426}; 427 428const struct ng_parse_type ng_parse_hint8_type = { 429 &ng_parse_int8_type, 430 (void *)INT_HEX 431}; 432 433/************************************************************************ 434 INT16 TYPE 435 ************************************************************************/ 436 437static int 438ng_int16_parse(const struct ng_parse_type *type, 439 const char *s, int *off, const u_char *const start, 440 u_char *const buf, int *buflen) 441{ 442 long val; 443 int16_t val16; 444 char *eptr; 445 446 val = strtol(s + *off, &eptr, 0); 447 if (val < (int16_t)0x8000 448 || val > (u_int16_t)0xffff || eptr == s + *off) 449 return (EINVAL); 450 *off = eptr - s; 451 val16 = (int16_t)val; 452 bcopy(&val16, buf, sizeof(int16_t)); 453 *buflen = sizeof(int16_t); 454 return (0); 455} 456 457static int 458ng_int16_unparse(const struct ng_parse_type *type, 459 const u_char *data, int *off, char *cbuf, int cbuflen) 460{ 461 const char *fmt; 462 int fval; 463 int16_t val; 464 465 bcopy(data + *off, &val, sizeof(int16_t)); 466 switch ((intptr_t)type->info) { 467 case INT_SIGNED: 468 fmt = "%d"; 469 fval = val; 470 break; 471 case INT_UNSIGNED: 472 fmt = "%u"; 473 fval = (u_int16_t)val; 474 break; 475 case INT_HEX: 476 fmt = "0x%x"; 477 fval = (u_int16_t)val; 478 break; 479 default: 480 panic("%s: unknown type", __func__); 481#ifdef RESTARTABLE_PANICS 482 return(0); 483#endif 484 } 485 NG_PARSE_APPEND(fmt, fval); 486 *off += sizeof(int16_t); 487 return (0); 488} 489 490static int 491ng_int16_getDefault(const struct ng_parse_type *type, 492 const u_char *const start, u_char *buf, int *buflen) 493{ 494 int16_t val; 495 496 if (*buflen < sizeof(int16_t)) 497 return (ERANGE); 498 val = 0; 499 bcopy(&val, buf, sizeof(int16_t)); 500 *buflen = sizeof(int16_t); 501 return (0); 502} 503 504static int 505ng_int16_getAlign(const struct ng_parse_type *type) 506{ 507 return INT16_ALIGNMENT; 508} 509 510const struct ng_parse_type ng_parse_int16_type = { 511 NULL, 512 (void *)INT_SIGNED, 513 NULL, 514 ng_int16_parse, 515 ng_int16_unparse, 516 ng_int16_getDefault, 517 ng_int16_getAlign 518}; 519 520const struct ng_parse_type ng_parse_uint16_type = { 521 &ng_parse_int16_type, 522 (void *)INT_UNSIGNED 523}; 524 525const struct ng_parse_type ng_parse_hint16_type = { 526 &ng_parse_int16_type, 527 (void *)INT_HEX 528}; 529 530/************************************************************************ 531 INT32 TYPE 532 ************************************************************************/ 533 534static int 535ng_int32_parse(const struct ng_parse_type *type, 536 const char *s, int *off, const u_char *const start, 537 u_char *const buf, int *buflen) 538{ 539 long val; /* assumes long is at least 32 bits */ 540 int32_t val32; 541 char *eptr; 542 543 val = strtol(s + *off, &eptr, 0); 544 if (val < (int32_t)0x80000000 545 || val > (u_int32_t)0xffffffff || eptr == s + *off) 546 return (EINVAL); 547 *off = eptr - s; 548 val32 = (int32_t)val; 549 bcopy(&val32, buf, sizeof(int32_t)); 550 *buflen = sizeof(int32_t); 551 return (0); 552} 553 554static int 555ng_int32_unparse(const struct ng_parse_type *type, 556 const u_char *data, int *off, char *cbuf, int cbuflen) 557{ 558 const char *fmt; 559 long fval; 560 int32_t val; 561 562 bcopy(data + *off, &val, sizeof(int32_t)); 563 switch ((intptr_t)type->info) { 564 case INT_SIGNED: 565 fmt = "%ld"; 566 fval = val; 567 break; 568 case INT_UNSIGNED: 569 fmt = "%lu"; 570 fval = (u_int32_t)val; 571 break; 572 case INT_HEX: 573 fmt = "0x%lx"; 574 fval = (u_int32_t)val; 575 break; 576 default: 577 panic("%s: unknown type", __func__); 578#ifdef RESTARTABLE_PANICS 579 return(0); 580#endif 581 } 582 NG_PARSE_APPEND(fmt, fval); 583 *off += sizeof(int32_t); 584 return (0); 585} 586 587static int 588ng_int32_getDefault(const struct ng_parse_type *type, 589 const u_char *const start, u_char *buf, int *buflen) 590{ 591 int32_t val; 592 593 if (*buflen < sizeof(int32_t)) 594 return (ERANGE); 595 val = 0; 596 bcopy(&val, buf, sizeof(int32_t)); 597 *buflen = sizeof(int32_t); 598 return (0); 599} 600 601static int 602ng_int32_getAlign(const struct ng_parse_type *type) 603{ 604 return INT32_ALIGNMENT; 605} 606 607const struct ng_parse_type ng_parse_int32_type = { 608 NULL, 609 (void *)INT_SIGNED, 610 NULL, 611 ng_int32_parse, 612 ng_int32_unparse, 613 ng_int32_getDefault, 614 ng_int32_getAlign 615}; 616 617const struct ng_parse_type ng_parse_uint32_type = { 618 &ng_parse_int32_type, 619 (void *)INT_UNSIGNED 620}; 621 622const struct ng_parse_type ng_parse_hint32_type = { 623 &ng_parse_int32_type, 624 (void *)INT_HEX 625}; 626 627/************************************************************************ 628 INT64 TYPE 629 ************************************************************************/ 630 631static int 632ng_int64_parse(const struct ng_parse_type *type, 633 const char *s, int *off, const u_char *const start, 634 u_char *const buf, int *buflen) 635{ 636 quad_t val; 637 int64_t val64; 638 char *eptr; 639 640 val = strtoq(s + *off, &eptr, 0); 641 if (eptr == s + *off) 642 return (EINVAL); 643 *off = eptr - s; 644 val64 = (int64_t)val; 645 bcopy(&val64, buf, sizeof(int64_t)); 646 *buflen = sizeof(int64_t); 647 return (0); 648} 649 650static int 651ng_int64_unparse(const struct ng_parse_type *type, 652 const u_char *data, int *off, char *cbuf, int cbuflen) 653{ 654 const char *fmt; 655 long long fval; 656 int64_t val; 657 658 bcopy(data + *off, &val, sizeof(int64_t)); 659 switch ((intptr_t)type->info) { 660 case INT_SIGNED: 661 fmt = "%lld"; 662 fval = val; 663 break; 664 case INT_UNSIGNED: 665 fmt = "%llu"; 666 fval = (u_int64_t)val; 667 break; 668 case INT_HEX: 669 fmt = "0x%llx"; 670 fval = (u_int64_t)val; 671 break; 672 default: 673 panic("%s: unknown type", __func__); 674#ifdef RESTARTABLE_PANICS 675 return(0); 676#endif 677 } 678 NG_PARSE_APPEND(fmt, fval); 679 *off += sizeof(int64_t); 680 return (0); 681} 682 683static int 684ng_int64_getDefault(const struct ng_parse_type *type, 685 const u_char *const start, u_char *buf, int *buflen) 686{ 687 int64_t val; 688 689 if (*buflen < sizeof(int64_t)) 690 return (ERANGE); 691 val = 0; 692 bcopy(&val, buf, sizeof(int64_t)); 693 *buflen = sizeof(int64_t); 694 return (0); 695} 696 697static int 698ng_int64_getAlign(const struct ng_parse_type *type) 699{ 700 return INT64_ALIGNMENT; 701} 702 703const struct ng_parse_type ng_parse_int64_type = { 704 NULL, 705 (void *)INT_SIGNED, 706 NULL, 707 ng_int64_parse, 708 ng_int64_unparse, 709 ng_int64_getDefault, 710 ng_int64_getAlign 711}; 712 713const struct ng_parse_type ng_parse_uint64_type = { 714 &ng_parse_int64_type, 715 (void *)INT_UNSIGNED 716}; 717 718const struct ng_parse_type ng_parse_hint64_type = { 719 &ng_parse_int64_type, 720 (void *)INT_HEX 721}; 722 723/************************************************************************ 724 STRING TYPE 725 ************************************************************************/ 726 727static int 728ng_string_parse(const struct ng_parse_type *type, 729 const char *s, int *off, const u_char *const start, 730 u_char *const buf, int *buflen) 731{ 732 char *sval; 733 int len; 734 int slen; 735 736 if ((sval = ng_get_string_token(s, off, &len, &slen)) == NULL) 737 return (EINVAL); 738 *off += len; 739 bcopy(sval, buf, slen + 1); 740 FREE(sval, M_NETGRAPH_PARSE); 741 *buflen = slen + 1; 742 return (0); 743} 744 745static int 746ng_string_unparse(const struct ng_parse_type *type, 747 const u_char *data, int *off, char *cbuf, int cbuflen) 748{ 749 const char *const raw = (const char *)data + *off; 750 char *const s = ng_encode_string(raw, strlen(raw)); 751 752 if (s == NULL) 753 return (ENOMEM); 754 NG_PARSE_APPEND("%s", s); 755 *off += strlen(raw) + 1; 756 FREE(s, M_NETGRAPH_PARSE); 757 return (0); 758} 759 760static int 761ng_string_getDefault(const struct ng_parse_type *type, 762 const u_char *const start, u_char *buf, int *buflen) 763{ 764 765 if (*buflen < 1) 766 return (ERANGE); 767 buf[0] = (u_char)'\0'; 768 *buflen = 1; 769 return (0); 770} 771 772const struct ng_parse_type ng_parse_string_type = { 773 NULL, 774 NULL, 775 NULL, 776 ng_string_parse, 777 ng_string_unparse, 778 ng_string_getDefault, 779 NULL 780}; 781 782/************************************************************************ 783 FIXED BUFFER STRING TYPE 784 ************************************************************************/ 785 786static int 787ng_fixedstring_parse(const struct ng_parse_type *type, 788 const char *s, int *off, const u_char *const start, 789 u_char *const buf, int *buflen) 790{ 791 const struct ng_parse_fixedstring_info *const fi = type->info; 792 char *sval; 793 int len; 794 int slen; 795 796 if ((sval = ng_get_string_token(s, off, &len, &slen)) == NULL) 797 return (EINVAL); 798 if (slen + 1 > fi->bufSize) 799 return (E2BIG); 800 *off += len; 801 bcopy(sval, buf, slen); 802 FREE(sval, M_NETGRAPH_PARSE); 803 bzero(buf + slen, fi->bufSize - slen); 804 *buflen = fi->bufSize; 805 return (0); 806} 807 808static int 809ng_fixedstring_unparse(const struct ng_parse_type *type, 810 const u_char *data, int *off, char *cbuf, int cbuflen) 811{ 812 const struct ng_parse_fixedstring_info *const fi = type->info; 813 int error, temp = *off; 814 815 if ((error = ng_string_unparse(type, data, &temp, cbuf, cbuflen)) != 0) 816 return (error); 817 *off += fi->bufSize; 818 return (0); 819} 820 821static int 822ng_fixedstring_getDefault(const struct ng_parse_type *type, 823 const u_char *const start, u_char *buf, int *buflen) 824{ 825 const struct ng_parse_fixedstring_info *const fi = type->info; 826 827 if (*buflen < fi->bufSize) 828 return (ERANGE); 829 bzero(buf, fi->bufSize); 830 *buflen = fi->bufSize; 831 return (0); 832} 833 834const struct ng_parse_type ng_parse_fixedstring_type = { 835 NULL, 836 NULL, 837 NULL, 838 ng_fixedstring_parse, 839 ng_fixedstring_unparse, 840 ng_fixedstring_getDefault, 841 NULL 842}; 843 844const struct ng_parse_fixedstring_info ng_parse_nodebuf_info = { 845 NG_NODESIZ 846}; 847const struct ng_parse_type ng_parse_nodebuf_type = { 848 &ng_parse_fixedstring_type, 849 &ng_parse_nodebuf_info 850}; 851 852const struct ng_parse_fixedstring_info ng_parse_hookbuf_info = { 853 NG_HOOKSIZ 854}; 855const struct ng_parse_type ng_parse_hookbuf_type = { 856 &ng_parse_fixedstring_type, 857 &ng_parse_hookbuf_info 858}; 859 860const struct ng_parse_fixedstring_info ng_parse_pathbuf_info = { 861 NG_PATHSIZ 862}; 863const struct ng_parse_type ng_parse_pathbuf_type = { 864 &ng_parse_fixedstring_type, 865 &ng_parse_pathbuf_info 866}; 867 868const struct ng_parse_fixedstring_info ng_parse_typebuf_info = { 869 NG_TYPESIZ 870}; 871const struct ng_parse_type ng_parse_typebuf_type = { 872 &ng_parse_fixedstring_type, 873 &ng_parse_typebuf_info 874}; 875 876const struct ng_parse_fixedstring_info ng_parse_cmdbuf_info = { 877 NG_CMDSTRSIZ 878}; 879const struct ng_parse_type ng_parse_cmdbuf_type = { 880 &ng_parse_fixedstring_type, 881 &ng_parse_cmdbuf_info 882}; 883 884/************************************************************************ 885 EXPLICITLY SIZED STRING TYPE 886 ************************************************************************/ 887 888static int 889ng_sizedstring_parse(const struct ng_parse_type *type, 890 const char *s, int *off, const u_char *const start, 891 u_char *const buf, int *buflen) 892{ 893 char *sval; 894 int len; 895 int slen; 896 897 if ((sval = ng_get_string_token(s, off, &len, &slen)) == NULL) 898 return (EINVAL); 899 if (slen > 0xffff) 900 return (EINVAL); 901 *off += len; 902 *((u_int16_t *)buf) = (u_int16_t)slen; 903 bcopy(sval, buf + 2, slen); 904 FREE(sval, M_NETGRAPH_PARSE); 905 *buflen = 2 + slen; 906 return (0); 907} 908 909static int 910ng_sizedstring_unparse(const struct ng_parse_type *type, 911 const u_char *data, int *off, char *cbuf, int cbuflen) 912{ 913 const char *const raw = (const char *)data + *off + 2; 914 const int slen = *((const u_int16_t *)(data + *off)); 915 char *const s = ng_encode_string(raw, slen); 916 917 if (s == NULL) 918 return (ENOMEM); 919 NG_PARSE_APPEND("%s", s); 920 FREE(s, M_NETGRAPH_PARSE); 921 *off += slen + 2; 922 return (0); 923} 924 925static int 926ng_sizedstring_getDefault(const struct ng_parse_type *type, 927 const u_char *const start, u_char *buf, int *buflen) 928{ 929 if (*buflen < 2) 930 return (ERANGE); 931 bzero(buf, 2); 932 *buflen = 2; 933 return (0); 934} 935 936const struct ng_parse_type ng_parse_sizedstring_type = { 937 NULL, 938 NULL, 939 NULL, 940 ng_sizedstring_parse, 941 ng_sizedstring_unparse, 942 ng_sizedstring_getDefault, 943 NULL 944}; 945 946/************************************************************************ 947 IP ADDRESS TYPE 948 ************************************************************************/ 949 950static int 951ng_ipaddr_parse(const struct ng_parse_type *type, 952 const char *s, int *off, const u_char *const start, 953 u_char *const buf, int *buflen) 954{ 955 int i, error; 956 957 for (i = 0; i < 4; i++) { 958 if ((error = ng_int8_parse(&ng_parse_int8_type, 959 s, off, start, buf + i, buflen)) != 0) 960 return (error); 961 if (i < 3 && s[*off] != '.') 962 return (EINVAL); 963 (*off)++; 964 } 965 *buflen = 4; 966 return (0); 967} 968 969static int 970ng_ipaddr_unparse(const struct ng_parse_type *type, 971 const u_char *data, int *off, char *cbuf, int cbuflen) 972{ 973 struct in_addr ip; 974 975 bcopy(data + *off, &ip, sizeof(ip)); 976 NG_PARSE_APPEND("%d.%d.%d.%d", ((u_char *)&ip)[0], 977 ((u_char *)&ip)[1], ((u_char *)&ip)[2], ((u_char *)&ip)[3]); 978 *off += sizeof(ip); 979 return (0); 980} 981 982static int 983ng_ipaddr_getDefault(const struct ng_parse_type *type, 984 const u_char *const start, u_char *buf, int *buflen) 985{ 986 struct in_addr ip = { 0 }; 987 988 if (*buflen < sizeof(ip)) 989 return (ERANGE); 990 bcopy(&ip, buf, sizeof(ip)); 991 *buflen = sizeof(ip); 992 return (0); 993} 994 995const struct ng_parse_type ng_parse_ipaddr_type = { 996 NULL, 997 NULL, 998 NULL, 999 ng_ipaddr_parse, 1000 ng_ipaddr_unparse, 1001 ng_ipaddr_getDefault, 1002 ng_int32_getAlign 1003}; 1004 1005/************************************************************************ 1006 ETHERNET ADDRESS TYPE 1007 ************************************************************************/ 1008 1009static int 1010ng_enaddr_parse(const struct ng_parse_type *type, 1011 const char *s, int *const off, const u_char *const start, 1012 u_char *const buf, int *const buflen) 1013{ 1014 char *eptr; 1015 u_long val; 1016 int i; 1017 1018 if (*buflen < ETHER_ADDR_LEN) 1019 return (ERANGE); 1020 for (i = 0; i < ETHER_ADDR_LEN; i++) { 1021 val = strtoul(s + *off, &eptr, 16); 1022 if (val > 0xff || eptr == s + *off) 1023 return (EINVAL); 1024 buf[i] = (u_char)val; 1025 *off = (eptr - s); 1026 if (i < ETHER_ADDR_LEN - 1) { 1027 if (*eptr != ':') 1028 return (EINVAL); 1029 (*off)++; 1030 } 1031 } 1032 *buflen = ETHER_ADDR_LEN; 1033 return (0); 1034} 1035 1036static int 1037ng_enaddr_unparse(const struct ng_parse_type *type, 1038 const u_char *data, int *off, char *cbuf, int cbuflen) 1039{ 1040 int len; 1041 1042 len = snprintf(cbuf, cbuflen, "%02x:%02x:%02x:%02x:%02x:%02x", 1043 data[*off], data[*off + 1], data[*off + 2], 1044 data[*off + 3], data[*off + 4], data[*off + 5]); 1045 if (len >= cbuflen) 1046 return (ERANGE); 1047 *off += ETHER_ADDR_LEN; 1048 return (0); 1049} 1050 1051const struct ng_parse_type ng_parse_enaddr_type = { 1052 NULL, 1053 NULL, 1054 NULL, 1055 ng_enaddr_parse, 1056 ng_enaddr_unparse, 1057 NULL, 1058 0 1059}; 1060 1061/************************************************************************ 1062 BYTE ARRAY TYPE 1063 ************************************************************************/ 1064 1065/* Get the length of a byte array */ 1066static int 1067ng_parse_bytearray_subtype_getLength(const struct ng_parse_type *type, 1068 const u_char *start, const u_char *buf) 1069{ 1070 ng_parse_array_getLength_t *const getLength = type->private; 1071 1072 return (*getLength)(type, start, buf); 1073} 1074 1075/* Byte array element type is hex int8 */ 1076static const struct ng_parse_array_info ng_parse_bytearray_subtype_info = { 1077 &ng_parse_hint8_type, 1078 &ng_parse_bytearray_subtype_getLength, 1079 NULL 1080}; 1081static const struct ng_parse_type ng_parse_bytearray_subtype = { 1082 &ng_parse_array_type, 1083 &ng_parse_bytearray_subtype_info 1084}; 1085 1086static int 1087ng_bytearray_parse(const struct ng_parse_type *type, 1088 const char *s, int *off, const u_char *const start, 1089 u_char *const buf, int *buflen) 1090{ 1091 char *str; 1092 int toklen; 1093 int slen; 1094 1095 /* We accept either an array of bytes or a string constant */ 1096 if ((str = ng_get_string_token(s, off, &toklen, &slen)) != NULL) { 1097 ng_parse_array_getLength_t *const getLength = type->info; 1098 int arraylen; 1099 1100 arraylen = (*getLength)(type, start, buf); 1101 if (arraylen > *buflen) { 1102 FREE(str, M_NETGRAPH_PARSE); 1103 return (ERANGE); 1104 } 1105 if (slen > arraylen) { 1106 FREE(str, M_NETGRAPH_PARSE); 1107 return (E2BIG); 1108 } 1109 bcopy(str, buf, slen); 1110 bzero(buf + slen, arraylen - slen); 1111 FREE(str, M_NETGRAPH_PARSE); 1112 *off += toklen; 1113 *buflen = arraylen; 1114 return (0); 1115 } else { 1116 struct ng_parse_type subtype; 1117 1118 subtype = ng_parse_bytearray_subtype; 1119 *(const void **)&subtype.private = type->info; 1120 return ng_array_parse(&subtype, s, off, start, buf, buflen); 1121 } 1122} 1123 1124static int 1125ng_bytearray_unparse(const struct ng_parse_type *type, 1126 const u_char *data, int *off, char *cbuf, int cbuflen) 1127{ 1128 struct ng_parse_type subtype; 1129 1130 subtype = ng_parse_bytearray_subtype; 1131 *(const void **)&subtype.private = type->info; 1132 return ng_array_unparse(&subtype, data, off, cbuf, cbuflen); 1133} 1134 1135static int 1136ng_bytearray_getDefault(const struct ng_parse_type *type, 1137 const u_char *const start, u_char *buf, int *buflen) 1138{ 1139 struct ng_parse_type subtype; 1140 1141 subtype = ng_parse_bytearray_subtype; 1142 *(const void **)&subtype.private = type->info; 1143 return ng_array_getDefault(&subtype, start, buf, buflen); 1144} 1145 1146const struct ng_parse_type ng_parse_bytearray_type = { 1147 NULL, 1148 NULL, 1149 NULL, 1150 ng_bytearray_parse, 1151 ng_bytearray_unparse, 1152 ng_bytearray_getDefault, 1153 NULL 1154}; 1155 1156/************************************************************************ 1157 STRUCT NG_MESG TYPE 1158 ************************************************************************/ 1159 1160/* Get msg->header.arglen when "buf" is pointing to msg->data */ 1161static int 1162ng_parse_ng_mesg_getLength(const struct ng_parse_type *type, 1163 const u_char *start, const u_char *buf) 1164{ 1165 const struct ng_mesg *msg; 1166 1167 msg = (const struct ng_mesg *)(buf - sizeof(*msg)); 1168 return msg->header.arglen; 1169} 1170 1171/* Type for the variable length data portion of a struct ng_mesg */ 1172static const struct ng_parse_type ng_msg_data_type = { 1173 &ng_parse_bytearray_type, 1174 &ng_parse_ng_mesg_getLength 1175}; 1176 1177/* Type for the entire struct ng_mesg header with data section */ 1178static const struct ng_parse_struct_field ng_parse_ng_mesg_type_fields[] 1179 = NG_GENERIC_NG_MESG_INFO(&ng_msg_data_type); 1180const struct ng_parse_type ng_parse_ng_mesg_type = { 1181 &ng_parse_struct_type, 1182 &ng_parse_ng_mesg_type_fields, 1183}; 1184 1185/************************************************************************ 1186 COMPOSITE HELPER ROUTINES 1187 ************************************************************************/ 1188 1189/* 1190 * Convert a structure or array from ASCII to binary 1191 */ 1192static int 1193ng_parse_composite(const struct ng_parse_type *type, const char *s, 1194 int *off, const u_char *const start, u_char *const buf, int *buflen, 1195 const enum comptype ctype) 1196{ 1197 const int num = ng_get_composite_len(type, start, buf, ctype); 1198 int nextIndex = 0; /* next implicit array index */ 1199 u_int index; /* field or element index */ 1200 int *foff; /* field value offsets in string */ 1201 int align, len, blen, error = 0; 1202 1203 /* Initialize */ 1204 MALLOC(foff, int *, num * sizeof(*foff), M_NETGRAPH_PARSE, M_NOWAIT | M_ZERO); 1205 if (foff == NULL) { 1206 error = ENOMEM; 1207 goto done; 1208 } 1209 1210 /* Get opening brace/bracket */ 1211 if (ng_parse_get_token(s, off, &len) 1212 != (ctype == CT_STRUCT ? T_LBRACE : T_LBRACKET)) { 1213 error = EINVAL; 1214 goto done; 1215 } 1216 *off += len; 1217 1218 /* Get individual element value positions in the string */ 1219 for (;;) { 1220 enum ng_parse_token tok; 1221 1222 /* Check for closing brace/bracket */ 1223 tok = ng_parse_get_token(s, off, &len); 1224 if (tok == (ctype == CT_STRUCT ? T_RBRACE : T_RBRACKET)) { 1225 *off += len; 1226 break; 1227 } 1228 1229 /* For arrays, the 'name' (ie, index) is optional, so 1230 distinguish name from values by seeing if the next 1231 token is an equals sign */ 1232 if (ctype != CT_STRUCT) { 1233 int len2, off2; 1234 char *eptr; 1235 1236 /* If an opening brace/bracket, index is implied */ 1237 if (tok == T_LBRACE || tok == T_LBRACKET) { 1238 index = nextIndex++; 1239 goto gotIndex; 1240 } 1241 1242 /* Might be an index, might be a value, either way... */ 1243 if (tok != T_WORD) { 1244 error = EINVAL; 1245 goto done; 1246 } 1247 1248 /* If no equals sign follows, index is implied */ 1249 off2 = *off + len; 1250 if (ng_parse_get_token(s, &off2, &len2) != T_EQUALS) { 1251 index = nextIndex++; 1252 goto gotIndex; 1253 } 1254 1255 /* Index was specified explicitly; parse it */ 1256 index = (u_int)strtoul(s + *off, &eptr, 0); 1257 if (index < 0 || eptr - (s + *off) != len) { 1258 error = EINVAL; 1259 goto done; 1260 } 1261 nextIndex = index + 1; 1262 *off += len + len2; 1263 } else { /* a structure field */ 1264 const struct ng_parse_struct_field *const 1265 fields = type->info; 1266 1267 /* Find the field by name (required) in field list */ 1268 if (tok != T_WORD) { 1269 error = EINVAL; 1270 goto done; 1271 } 1272 for (index = 0; index < num; index++) { 1273 const struct ng_parse_struct_field *const 1274 field = &fields[index]; 1275 1276 if (strncmp(&s[*off], field->name, len) == 0 1277 && field->name[len] == '\0') 1278 break; 1279 } 1280 if (index == num) { 1281 error = ENOENT; 1282 goto done; 1283 } 1284 *off += len; 1285 1286 /* Get equals sign */ 1287 if (ng_parse_get_token(s, off, &len) != T_EQUALS) { 1288 error = EINVAL; 1289 goto done; 1290 } 1291 *off += len; 1292 } 1293gotIndex: 1294 1295 /* Check array index */ 1296 if (index >= num) { 1297 error = E2BIG; 1298 goto done; 1299 } 1300 1301 /* Save value's position and skip over it for now */ 1302 if (foff[index] != 0) { 1303 error = EALREADY; /* duplicate */ 1304 goto done; 1305 } 1306 while (isspace(s[*off])) 1307 (*off)++; 1308 foff[index] = *off; 1309 if ((error = ng_parse_skip_value(s, *off, &len)) != 0) 1310 goto done; 1311 *off += len; 1312 } 1313 1314 /* Now build binary structure from supplied values and defaults */ 1315 for (blen = index = 0; index < num; index++) { 1316 const struct ng_parse_type *const 1317 etype = ng_get_composite_etype(type, index, ctype); 1318 int k, pad, vlen; 1319 1320 /* Zero-pad any alignment bytes */ 1321 pad = ng_parse_get_elem_pad(type, index, ctype, blen); 1322 for (k = 0; k < pad; k++) { 1323 if (blen >= *buflen) { 1324 error = ERANGE; 1325 goto done; 1326 } 1327 buf[blen++] = 0; 1328 } 1329 1330 /* Get value */ 1331 vlen = *buflen - blen; 1332 if (foff[index] == 0) { /* use default value */ 1333 error = ng_get_composite_elem_default(type, index, 1334 start, buf + blen, &vlen, ctype); 1335 } else { /* parse given value */ 1336 *off = foff[index]; 1337 error = INVOKE(etype, parse)(etype, 1338 s, off, start, buf + blen, &vlen); 1339 } 1340 if (error != 0) 1341 goto done; 1342 blen += vlen; 1343 } 1344 1345 /* Make total composite structure size a multiple of its alignment */ 1346 if ((align = ALIGNMENT(type)) != 0) { 1347 while (blen % align != 0) { 1348 if (blen >= *buflen) { 1349 error = ERANGE; 1350 goto done; 1351 } 1352 buf[blen++] = 0; 1353 } 1354 } 1355 1356 /* Done */ 1357 *buflen = blen; 1358done: 1359 if (foff != NULL) 1360 FREE(foff, M_NETGRAPH_PARSE); 1361 return (error); 1362} 1363 1364/* 1365 * Convert an array or structure from binary to ASCII 1366 */ 1367static int 1368ng_unparse_composite(const struct ng_parse_type *type, const u_char *data, 1369 int *off, char *cbuf, int cbuflen, const enum comptype ctype) 1370{ 1371 const struct ng_mesg *const hdr 1372 = (const struct ng_mesg *)(data - sizeof(*hdr)); 1373 const int num = ng_get_composite_len(type, data, data + *off, ctype); 1374 const int workSize = 20 * 1024; /* XXX hard coded constant */ 1375 int nextIndex = 0, didOne = 0; 1376 int error, index; 1377 u_char *workBuf; 1378 1379 /* Get workspace for checking default values */ 1380 MALLOC(workBuf, u_char *, workSize, M_NETGRAPH_PARSE, M_NOWAIT); 1381 if (workBuf == NULL) 1382 return (ENOMEM); 1383 1384 /* Opening brace/bracket */ 1385 NG_PARSE_APPEND("%c", (ctype == CT_STRUCT) ? '{' : '['); 1386 1387 /* Do each item */ 1388 for (index = 0; index < num; index++) { 1389 const struct ng_parse_type *const 1390 etype = ng_get_composite_etype(type, index, ctype); 1391 1392 /* Skip any alignment pad bytes */ 1393 *off += ng_parse_get_elem_pad(type, index, ctype, *off); 1394 1395 /* 1396 * See if element is equal to its default value; skip if so. 1397 * Copy struct ng_mesg header for types that peek into it. 1398 */ 1399 if (sizeof(*hdr) + *off < workSize) { 1400 int tempsize = workSize - sizeof(*hdr) - *off; 1401 1402 bcopy(hdr, workBuf, sizeof(*hdr) + *off); 1403 if (ng_get_composite_elem_default(type, index, workBuf 1404 + sizeof(*hdr), workBuf + sizeof(*hdr) + *off, 1405 &tempsize, ctype) == 0 1406 && bcmp(workBuf + sizeof(*hdr) + *off, 1407 data + *off, tempsize) == 0) { 1408 *off += tempsize; 1409 continue; 1410 } 1411 } 1412 1413 /* Print name= */ 1414 NG_PARSE_APPEND(" "); 1415 if (ctype != CT_STRUCT) { 1416 if (index != nextIndex) { 1417 nextIndex = index; 1418 NG_PARSE_APPEND("%d=", index); 1419 } 1420 nextIndex++; 1421 } else { 1422 const struct ng_parse_struct_field *const 1423 fields = type->info; 1424 1425 NG_PARSE_APPEND("%s=", fields[index].name); 1426 } 1427 1428 /* Print value */ 1429 if ((error = INVOKE(etype, unparse) 1430 (etype, data, off, cbuf, cbuflen)) != 0) { 1431 FREE(workBuf, M_NETGRAPH_PARSE); 1432 return (error); 1433 } 1434 cbuflen -= strlen(cbuf); 1435 cbuf += strlen(cbuf); 1436 didOne = 1; 1437 } 1438 FREE(workBuf, M_NETGRAPH_PARSE); 1439 1440 /* Closing brace/bracket */ 1441 NG_PARSE_APPEND("%s%c", 1442 didOne ? " " : "", (ctype == CT_STRUCT) ? '}' : ']'); 1443 return (0); 1444} 1445 1446/* 1447 * Generate the default value for an element of an array or structure 1448 * Returns EOPNOTSUPP if default value is unspecified. 1449 */ 1450static int 1451ng_get_composite_elem_default(const struct ng_parse_type *type, 1452 int index, const u_char *const start, u_char *buf, int *buflen, 1453 const enum comptype ctype) 1454{ 1455 const struct ng_parse_type *etype; 1456 ng_getDefault_t *func; 1457 1458 switch (ctype) { 1459 case CT_STRUCT: 1460 break; 1461 case CT_ARRAY: 1462 { 1463 const struct ng_parse_array_info *const ai = type->info; 1464 1465 if (ai->getDefault != NULL) { 1466 return (*ai->getDefault)(type, 1467 index, start, buf, buflen); 1468 } 1469 break; 1470 } 1471 case CT_FIXEDARRAY: 1472 { 1473 const struct ng_parse_fixedarray_info *const fi = type->info; 1474 1475 if (*fi->getDefault != NULL) { 1476 return (*fi->getDefault)(type, 1477 index, start, buf, buflen); 1478 } 1479 break; 1480 } 1481 default: 1482 panic("%s", __func__); 1483 } 1484 1485 /* Default to element type default */ 1486 etype = ng_get_composite_etype(type, index, ctype); 1487 func = METHOD(etype, getDefault); 1488 if (func == NULL) 1489 return (EOPNOTSUPP); 1490 return (*func)(etype, start, buf, buflen); 1491} 1492 1493/* 1494 * Get the number of elements in a struct, variable or fixed array. 1495 */ 1496static int 1497ng_get_composite_len(const struct ng_parse_type *type, 1498 const u_char *const start, const u_char *buf, 1499 const enum comptype ctype) 1500{ 1501 switch (ctype) { 1502 case CT_STRUCT: 1503 { 1504 const struct ng_parse_struct_field *const fields = type->info; 1505 int numFields = 0; 1506 1507 for (numFields = 0; ; numFields++) { 1508 const struct ng_parse_struct_field *const 1509 fi = &fields[numFields]; 1510 1511 if (fi->name == NULL) 1512 break; 1513 } 1514 return (numFields); 1515 } 1516 case CT_ARRAY: 1517 { 1518 const struct ng_parse_array_info *const ai = type->info; 1519 1520 return (*ai->getLength)(type, start, buf); 1521 } 1522 case CT_FIXEDARRAY: 1523 { 1524 const struct ng_parse_fixedarray_info *const fi = type->info; 1525 1526 return fi->length; 1527 } 1528 default: 1529 panic("%s", __func__); 1530 } 1531 return (0); 1532} 1533 1534/* 1535 * Return the type of the index'th element of a composite structure 1536 */ 1537static const struct ng_parse_type * 1538ng_get_composite_etype(const struct ng_parse_type *type, 1539 int index, const enum comptype ctype) 1540{ 1541 const struct ng_parse_type *etype = NULL; 1542 1543 switch (ctype) { 1544 case CT_STRUCT: 1545 { 1546 const struct ng_parse_struct_field *const fields = type->info; 1547 1548 etype = fields[index].type; 1549 break; 1550 } 1551 case CT_ARRAY: 1552 { 1553 const struct ng_parse_array_info *const ai = type->info; 1554 1555 etype = ai->elementType; 1556 break; 1557 } 1558 case CT_FIXEDARRAY: 1559 { 1560 const struct ng_parse_fixedarray_info *const fi = type->info; 1561 1562 etype = fi->elementType; 1563 break; 1564 } 1565 default: 1566 panic("%s", __func__); 1567 } 1568 return (etype); 1569} 1570 1571/* 1572 * Get the number of bytes to skip to align for the next 1573 * element in a composite structure. 1574 */ 1575static int 1576ng_parse_get_elem_pad(const struct ng_parse_type *type, 1577 int index, enum comptype ctype, int posn) 1578{ 1579 const struct ng_parse_type *const 1580 etype = ng_get_composite_etype(type, index, ctype); 1581 int align; 1582 1583 /* Get element's alignment, and possibly override */ 1584 align = ALIGNMENT(etype); 1585 if (ctype == CT_STRUCT) { 1586 const struct ng_parse_struct_field *const fields = type->info; 1587 1588 if (fields[index].alignment != 0) 1589 align = fields[index].alignment; 1590 } 1591 1592 /* Return number of bytes to skip to align */ 1593 return (align ? (align - (posn % align)) % align : 0); 1594} 1595 1596/************************************************************************ 1597 PARSING HELPER ROUTINES 1598 ************************************************************************/ 1599 1600/* 1601 * Skip over a value 1602 */ 1603static int 1604ng_parse_skip_value(const char *s, int off0, int *lenp) 1605{ 1606 int len, nbracket, nbrace; 1607 int off = off0; 1608 1609 len = nbracket = nbrace = 0; 1610 do { 1611 switch (ng_parse_get_token(s, &off, &len)) { 1612 case T_LBRACKET: 1613 nbracket++; 1614 break; 1615 case T_LBRACE: 1616 nbrace++; 1617 break; 1618 case T_RBRACKET: 1619 if (nbracket-- == 0) 1620 return (EINVAL); 1621 break; 1622 case T_RBRACE: 1623 if (nbrace-- == 0) 1624 return (EINVAL); 1625 break; 1626 case T_EOF: 1627 return (EINVAL); 1628 default: 1629 break; 1630 } 1631 off += len; 1632 } while (nbracket > 0 || nbrace > 0); 1633 *lenp = off - off0; 1634 return (0); 1635} 1636 1637/* 1638 * Find the next token in the string, starting at offset *startp. 1639 * Returns the token type, with *startp pointing to the first char 1640 * and *lenp the length. 1641 */ 1642enum ng_parse_token 1643ng_parse_get_token(const char *s, int *startp, int *lenp) 1644{ 1645 char *t; 1646 int i; 1647 1648 while (isspace(s[*startp])) 1649 (*startp)++; 1650 switch (s[*startp]) { 1651 case '\0': 1652 *lenp = 0; 1653 return T_EOF; 1654 case '{': 1655 *lenp = 1; 1656 return T_LBRACE; 1657 case '}': 1658 *lenp = 1; 1659 return T_RBRACE; 1660 case '[': 1661 *lenp = 1; 1662 return T_LBRACKET; 1663 case ']': 1664 *lenp = 1; 1665 return T_RBRACKET; 1666 case '=': 1667 *lenp = 1; 1668 return T_EQUALS; 1669 case '"': 1670 if ((t = ng_get_string_token(s, startp, lenp, NULL)) == NULL) 1671 return T_ERROR; 1672 FREE(t, M_NETGRAPH_PARSE); 1673 return T_STRING; 1674 default: 1675 for (i = *startp + 1; s[i] != '\0' && !isspace(s[i]) 1676 && s[i] != '{' && s[i] != '}' && s[i] != '[' 1677 && s[i] != ']' && s[i] != '=' && s[i] != '"'; i++) 1678 ; 1679 *lenp = i - *startp; 1680 return T_WORD; 1681 } 1682} 1683 1684/* 1685 * Get a string token, which must be enclosed in double quotes. 1686 * The normal C backslash escapes are recognized. 1687 */ 1688char * 1689ng_get_string_token(const char *s, int *startp, int *lenp, int *slenp) 1690{ 1691 char *cbuf, *p; 1692 int start, off; 1693 int slen; 1694 1695 while (isspace(s[*startp])) 1696 (*startp)++; 1697 start = *startp; 1698 if (s[*startp] != '"') 1699 return (NULL); 1700 MALLOC(cbuf, char *, strlen(s + start), M_NETGRAPH_PARSE, M_NOWAIT); 1701 if (cbuf == NULL) 1702 return (NULL); 1703 strcpy(cbuf, s + start + 1); 1704 for (slen = 0, off = 1, p = cbuf; *p != '\0'; slen++, off++, p++) { 1705 if (*p == '"') { 1706 *p = '\0'; 1707 *lenp = off + 1; 1708 if (slenp != NULL) 1709 *slenp = slen; 1710 return (cbuf); 1711 } else if (p[0] == '\\' && p[1] != '\0') { 1712 int x, k; 1713 char *v; 1714 1715 strcpy(p, p + 1); 1716 v = p; 1717 switch (*p) { 1718 case 't': 1719 *v = '\t'; 1720 off++; 1721 continue; 1722 case 'n': 1723 *v = '\n'; 1724 off++; 1725 continue; 1726 case 'r': 1727 *v = '\r'; 1728 off++; 1729 continue; 1730 case 'v': 1731 *v = '\v'; 1732 off++; 1733 continue; 1734 case 'f': 1735 *v = '\f'; 1736 off++; 1737 continue; 1738 case '"': 1739 *v = '"'; 1740 off++; 1741 continue; 1742 case '0': case '1': case '2': case '3': 1743 case '4': case '5': case '6': case '7': 1744 for (x = k = 0; 1745 k < 3 && *v >= '0' && *v <= '7'; v++) { 1746 x = (x << 3) + (*v - '0'); 1747 off++; 1748 } 1749 *--v = (char)x; 1750 break; 1751 case 'x': 1752 for (v++, x = k = 0; 1753 k < 2 && isxdigit(*v); v++) { 1754 x = (x << 4) + (isdigit(*v) ? 1755 (*v - '0') : 1756 (tolower(*v) - 'a' + 10)); 1757 off++; 1758 } 1759 *--v = (char)x; 1760 break; 1761 default: 1762 continue; 1763 } 1764 strcpy(p, v); 1765 } 1766 } 1767 FREE(cbuf, M_NETGRAPH_PARSE); 1768 return (NULL); /* no closing quote */ 1769} 1770 1771/* 1772 * Encode a string so it can be safely put in double quotes. 1773 * Caller must free the result. Exactly "slen" characters 1774 * are encoded. 1775 */ 1776char * 1777ng_encode_string(const char *raw, int slen) 1778{ 1779 char *cbuf; 1780 int off = 0; 1781 int i; 1782 1783 MALLOC(cbuf, char *, strlen(raw) * 4 + 3, M_NETGRAPH_PARSE, M_NOWAIT); 1784 if (cbuf == NULL) 1785 return (NULL); 1786 cbuf[off++] = '"'; 1787 for (i = 0; i < slen; i++, raw++) { 1788 switch (*raw) { 1789 case '\t': 1790 cbuf[off++] = '\\'; 1791 cbuf[off++] = 't'; 1792 break; 1793 case '\f': 1794 cbuf[off++] = '\\'; 1795 cbuf[off++] = 'f'; 1796 break; 1797 case '\n': 1798 cbuf[off++] = '\\'; 1799 cbuf[off++] = 'n'; 1800 break; 1801 case '\r': 1802 cbuf[off++] = '\\'; 1803 cbuf[off++] = 'r'; 1804 break; 1805 case '\v': 1806 cbuf[off++] = '\\'; 1807 cbuf[off++] = 'v'; 1808 break; 1809 case '"': 1810 case '\\': 1811 cbuf[off++] = '\\'; 1812 cbuf[off++] = *raw; 1813 break; 1814 default: 1815 if (*raw < 0x20 || *raw > 0x7e) { 1816 off += sprintf(cbuf + off, 1817 "\\x%02x", (u_char)*raw); 1818 break; 1819 } 1820 cbuf[off++] = *raw; 1821 break; 1822 } 1823 } 1824 cbuf[off++] = '"'; 1825 cbuf[off] = '\0'; 1826 return (cbuf); 1827} 1828 1829/************************************************************************ 1830 VIRTUAL METHOD LOOKUP 1831 ************************************************************************/ 1832 1833static ng_parse_t * 1834ng_get_parse_method(const struct ng_parse_type *t) 1835{ 1836 while (t != NULL && t->parse == NULL) 1837 t = t->supertype; 1838 return (t ? t->parse : NULL); 1839} 1840 1841static ng_unparse_t * 1842ng_get_unparse_method(const struct ng_parse_type *t) 1843{ 1844 while (t != NULL && t->unparse == NULL) 1845 t = t->supertype; 1846 return (t ? t->unparse : NULL); 1847} 1848 1849static ng_getDefault_t * 1850ng_get_getDefault_method(const struct ng_parse_type *t) 1851{ 1852 while (t != NULL && t->getDefault == NULL) 1853 t = t->supertype; 1854 return (t ? t->getDefault : NULL); 1855} 1856 1857static ng_getAlign_t * 1858ng_get_getAlign_method(const struct ng_parse_type *t) 1859{ 1860 while (t != NULL && t->getAlign == NULL) 1861 t = t->supertype; 1862 return (t ? t->getAlign : NULL); 1863} 1864 1865