sys/netgraph/netgraph/ng_parse.c

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