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