1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <stdlib.h>
29 #include <ctype.h>
30 #include <strings.h>
31 #include <limits.h>
32 #include <errno.h>
33 #include <dhcp_impl.h>
34
35 #include "dhcp_symbol.h"
36
37 /*
38 * The following structure and table are used to define the attributes
39 * of a DHCP symbol category.
40 */
41 typedef struct dsym_cat {
42 char *dc_string; /* string value for the category */
43 int dc_minlen; /* min. chars of dc_string to match */
44 dsym_category_t dc_id; /* numerical value for the category */
45 boolean_t dc_dhcptab; /* valid for dhcptab use? */
46 ushort_t dc_min; /* minimum valid code */
47 ushort_t dc_max; /* maximum valid code */
48 } dsym_cat_t;
49
50 static dsym_cat_t cats[] = {
51 { "Extend", 6, DSYM_EXTEND, B_TRUE, DHCP_LAST_STD + 1,
52 DHCP_SITE_OPT - 1 },
53 { "Vendor=", 6, DSYM_VENDOR, B_TRUE, DHCP_FIRST_OPT,
54 DHCP_LAST_OPT },
55 { "Site", 4, DSYM_SITE, B_TRUE, DHCP_SITE_OPT, DHCP_LAST_OPT },
56 { "Standard", 8, DSYM_STANDARD, B_FALSE, DHCP_FIRST_OPT,
57 DHCP_LAST_STD },
58 { "Field", 5, DSYM_FIELD, B_FALSE, CD_PACKET_START,
59 CD_PACKET_END },
60 { "Internal", 8, DSYM_INTERNAL, B_FALSE, CD_INTRNL_START,
61 CD_INTRNL_END }
62 };
63
64 /*
65 * The following structure and table are used to define the attributes
66 * of a DHCP symbol type.
67 */
68 typedef struct dsym_type {
69 char *dt_string; /* string value for the type */
70 dsym_cdtype_t dt_id; /* numerical value for the type */
71 boolean_t dt_dhcptab; /* valid for dhcptab use? */
72 } dsym_type_t;
73
74 static dsym_type_t types[] = {
75 { "ASCII", DSYM_ASCII, B_TRUE },
76 { "OCTET", DSYM_OCTET, B_TRUE },
77 { "IP", DSYM_IP, B_TRUE },
78 { "NUMBER", DSYM_NUMBER, B_TRUE },
79 { "BOOL", DSYM_BOOL, B_TRUE },
80 { "INCLUDE", DSYM_INCLUDE, B_FALSE },
81 { "UNUMBER8", DSYM_UNUMBER8, B_TRUE },
82 { "UNUMBER16", DSYM_UNUMBER16, B_TRUE },
83 { "UNUMBER24", DSYM_UNUMBER24, B_TRUE },
84 { "UNUMBER32", DSYM_UNUMBER32, B_TRUE },
85 { "UNUMBER64", DSYM_UNUMBER64, B_TRUE },
86 { "SNUMBER8", DSYM_SNUMBER8, B_TRUE },
87 { "SNUMBER16", DSYM_SNUMBER16, B_TRUE },
88 { "SNUMBER32", DSYM_SNUMBER32, B_TRUE },
89 { "SNUMBER64", DSYM_SNUMBER64, B_TRUE },
90 { "IPV6", DSYM_IPV6, B_TRUE },
91 { "DUID", DSYM_DUID, B_TRUE },
92 { "DOMAIN", DSYM_DOMAIN, B_TRUE }
93 };
94
95 /*
96 * symbol delimiters and constants
97 */
98 #define DSYM_CLASS_DEL " \t\n"
99 #define DSYM_FIELD_DEL ","
100 #define DSYM_VENDOR_DEL '='
101 #define DSYM_QUOTE '"'
102
103 /*
104 * dsym_trim(): trims all whitespace from either side of a string
105 *
106 * input: char **: a pointer to a string to trim of whitespace.
107 * output: none
108 */
109
110 static void
dsym_trim(char ** str)111 dsym_trim(char **str)
112 {
113
114 char *tmpstr = *str;
115
116 /*
117 * Trim all whitespace from the front of the string.
118 */
119 while (*tmpstr != '\0' && isspace(*tmpstr)) {
120 tmpstr++;
121 }
122
123 /*
124 * Move the str pointer to first non-whitespace char.
125 */
126 *str = tmpstr;
127
128 /*
129 * Check case where the string is nothing but whitespace.
130 */
131 if (*tmpstr == '\0') {
132
133 /*
134 * Trim all whitespace from the end of the string.
135 */
136 tmpstr = *str + strlen(*str) - 1;
137 while (tmpstr >= *str && isspace(*tmpstr)) {
138 tmpstr--;
139 }
140
141 /*
142 * terminate after last non-whitespace char.
143 */
144 *(tmpstr+1) = '\0';
145 }
146 }
147
148 /*
149 * dsym_get_token(): strtok_r() like routine, except consecutive delimiters
150 * result in an empty string
151 *
152 * note: original string is modified
153 *
154 * input: char *: string in which to search for tokens
155 * char *: list of possible token delimiter characters
156 * char **: location for next call to routine
157 * boolean_t: should delimiters be ignored if within quoted string?
158 * output: char *: token, or NULL if no more tokens
159 */
160
161 static char *
dsym_get_token(char * str,char * dels,char ** lasts,boolean_t quote_support)162 dsym_get_token(char *str, char *dels, char **lasts, boolean_t quote_support)
163 {
164
165 char *ptr = str;
166 char *del;
167 boolean_t found = B_FALSE;
168 boolean_t in_quote = B_FALSE;
169
170 /*
171 * If incoming string has no tokens return a NULL
172 * pointer to signify no more tokens.
173 */
174 if (*ptr == '\0') {
175 return (NULL);
176 }
177
178 /*
179 * Loop until either a token has been identified or until end
180 * of string has been reached.
181 */
182 while (!found && *ptr != '\0') {
183
184 /*
185 * If pointer currently lies within a quoted string,
186 * then do not check for the delimiter.
187 */
188 if (!in_quote) {
189 for (del = dels; !found && *del != '\0'; del++) {
190 if (*del == *ptr) {
191 *ptr++ = '\0';
192 found = B_TRUE;
193 }
194 }
195 }
196
197 /*
198 * If the pointer is pointing at a delimiter, then
199 * check to see if it points to at a quote and update
200 * the state appropriately.
201 */
202 if (!found) {
203 if (quote_support && *ptr == DSYM_QUOTE) {
204 in_quote = !in_quote;
205 }
206 ptr++;
207 }
208 }
209
210 *lasts = ptr;
211
212 return (str);
213 }
214
215 /*
216 * dsym_get_long(): given a numeric string, returns its long value
217 *
218 * input: const char *: the numeric string
219 * long *: the return location for the long value
220 * output: DSYM_SUCCESS, DSYM_VALUE_OUT_OF_RANGE or DSYM_SYNTAX_ERROR
221 */
222
223 static dsym_errcode_t
dsym_get_long(const char * str,long * val)224 dsym_get_long(const char *str, long *val)
225 {
226
227 int ret = DSYM_SUCCESS;
228 int i;
229
230 for (i = 0; str[i] != '\0'; i++) {
231 if (!isdigit(str[i])) {
232 return (DSYM_SYNTAX_ERROR);
233 }
234 }
235
236 errno = 0;
237 *val = strtol(str, NULL, 10);
238 if (errno != 0) {
239 ret = DSYM_VALUE_OUT_OF_RANGE;
240 }
241
242 return (ret);
243 }
244
245 /*
246 * dsym_free_classes(): frees the classes allocated by dsym_parse_classes()
247 *
248 * input: dhcp_classes_t *: pointer to structure containing classes to free
249 * output: none
250 */
251
252 void
dsym_free_classes(dhcp_classes_t * classes)253 dsym_free_classes(dhcp_classes_t *classes)
254 {
255
256 int i;
257
258 if (classes->dc_names == NULL) {
259 return;
260 }
261
262 for (i = 0; i < classes->dc_cnt; i++) {
263 free(classes->dc_names[i]);
264 }
265
266 free(classes->dc_names);
267 classes->dc_names = NULL;
268 classes->dc_cnt = 0;
269 }
270
271 /*
272 * dsym_parse_classes(): given a "Vendor" class string, builds and returns
273 * the list of vendor classes
274 *
275 * input: char *: the "Vendor" class string
276 * dhcp_classes_t *: pointer to the classes structure
277 * output: DSYM_SUCCESS, DSYM_INVALID_CAT, DSYM_EXCEEDS_MAX_CLASS_SIZE,
278 * DSYM_EXCEEDS_CLASS_SIZE, DSYM_SYNTAX_ERROR, or DSYM_NO_MEMORY
279 */
280
281 static dsym_errcode_t
dsym_parse_classes(char * ptr,dhcp_classes_t * classes_ret)282 dsym_parse_classes(char *ptr, dhcp_classes_t *classes_ret)
283 {
284
285 char **classes = NULL;
286 char *cp;
287 int len;
288 int ret = DSYM_SUCCESS;
289 int i;
290
291 while (*ptr != '\0') {
292 if (*ptr == DSYM_VENDOR_DEL) {
293 ptr++;
294 break;
295 }
296 ptr++;
297 }
298
299 if (*ptr == '\0') {
300 return (DSYM_INVALID_CAT);
301 }
302
303 if (strlen(ptr) > DSYM_MAX_CLASS_SIZE) {
304 return (DSYM_EXCEEDS_MAX_CLASS_SIZE);
305 }
306
307 dsym_trim(&ptr);
308 classes_ret->dc_cnt = 0;
309 for (i = 0; ret == DSYM_SUCCESS; i++) {
310 cp = dsym_get_token(ptr, DSYM_CLASS_DEL, &ptr, B_TRUE);
311 if (cp == NULL) {
312 break;
313 }
314
315 len = strlen(cp);
316
317 if (len == 0) {
318 continue;
319 } else if (len > DSYM_CLASS_SIZE) {
320 ret = DSYM_EXCEEDS_CLASS_SIZE;
321 continue;
322 }
323
324 if (cp[0] == DSYM_QUOTE && cp[len-1] != DSYM_QUOTE) {
325 ret = DSYM_SYNTAX_ERROR;
326 continue;
327 }
328
329 /* Strip off the quotes */
330 if (cp[0] == DSYM_QUOTE) {
331 cp[len-1] = '\0';
332 cp++;
333 }
334
335 classes = realloc(classes_ret->dc_names,
336 (sizeof (char **)) * (classes_ret->dc_cnt + 1));
337 if (classes == NULL ||
338 (classes[classes_ret->dc_cnt] = strdup(cp))
339 == NULL) {
340 ret = DSYM_NO_MEMORY;
341 continue;
342 }
343 classes_ret->dc_names = classes;
344 classes_ret->dc_cnt++;
345 }
346
347 if (ret != DSYM_SUCCESS) {
348 dsym_free_classes(classes_ret);
349 }
350
351 return (ret);
352 }
353
354 /*
355 * dsym_get_cat_by_name(): given a category field, returns the pointer to its
356 * entry in the internal category table.
357 *
358 * input: const char *: the category name
359 * dsym_cat_t *: the return location for the pointer to the table entry
360 * boolean_t: case-sensitive name compare
361 * output: int: DSYM_SUCCESS or DSYM_INVALID_CAT
362 */
363
364 static dsym_errcode_t
dsym_get_cat_by_name(const char * cat,dsym_cat_t ** entry,boolean_t cs)365 dsym_get_cat_by_name(const char *cat, dsym_cat_t **entry, boolean_t cs)
366 {
367
368 dsym_cat_t *entryp = NULL;
369 int ret = DSYM_SUCCESS;
370 int cnt = sizeof (cats) / sizeof (dsym_cat_t);
371 int result;
372 int len;
373 int i;
374
375 for (i = 0; i < cnt; i++) {
376
377 len = cats[i].dc_minlen;
378 if (cs) {
379 result = strncmp(cat, cats[i].dc_string, len);
380 } else {
381 result = strncasecmp(cat, cats[i].dc_string, len);
382 }
383
384 if (result == 0) {
385 entryp = &cats[i];
386 break;
387 }
388 }
389
390 if (entryp != NULL) {
391 /*
392 * Special code required for the Vendor category, because we
393 * allow whitespace between the keyword and the delimiter.
394 * If there is no delimiter, then this is an illegal category.
395 */
396 const char *ptr = cat + entryp->dc_minlen;
397 if (entryp->dc_id == DSYM_VENDOR) {
398 while (*ptr != '\0' && isspace(*ptr)) {
399 ptr++;
400 }
401 if (*ptr != DSYM_VENDOR_DEL) {
402 ret = DSYM_INVALID_CAT;
403 }
404 } else {
405 if (*ptr != '\0') {
406 ret = DSYM_INVALID_CAT;
407 }
408 }
409 } else {
410 ret = DSYM_INVALID_CAT;
411 }
412
413 if (ret == DSYM_SUCCESS) {
414 *entry = entryp;
415 }
416
417 return (ret);
418 }
419
420 /*
421 * dsym_parse_cat(): given a category field, returns the category value
422 * Note: The category must be a valid dhcptab category.
423 *
424 * input: const char *: a category field
425 * dsym_category_t *: the return location for the category value
426 * output: int: DSYM_SUCCESS or DSYM_INVALID_CAT
427 */
428
429 static dsym_errcode_t
dsym_parse_cat(const char * field,dsym_category_t * cat)430 dsym_parse_cat(const char *field, dsym_category_t *cat)
431 {
432
433 dsym_cat_t *entry;
434 int ret;
435
436 ret = dsym_get_cat_by_name(field, &entry, B_TRUE);
437 if (ret == DSYM_SUCCESS) {
438 /*
439 * Since this routine is meant to be used to parse dhcptab
440 * symbol definitions, only a subset of the DHCP categories
441 * are valid in this context.
442 */
443 if (entry->dc_dhcptab) {
444 *cat = entry->dc_id;
445 } else {
446 ret = DSYM_INVALID_CAT;
447 }
448 }
449
450 return (ret);
451 }
452
453 /*
454 * dsym_parse_intrange(): given a DHCP integer field, returns the value
455 *
456 * input: const char *: a DHCP code field
457 * int *: the return location for the value
458 * int: the minimum valid value
459 * int: the maximum valid value
460 * output: int: DSYM_SUCCESS, DSYM_SYNTAX_ERROR, or DSYM_VALUE_OUT_OF_RANGE
461 */
462
463 static dsym_errcode_t
dsym_parse_intrange(const char * field,int * intval,int min,int max)464 dsym_parse_intrange(const char *field, int *intval, int min, int max)
465 {
466
467 int ret;
468 long longval;
469
470 ret = dsym_get_long(field, &longval);
471 if (ret == DSYM_SUCCESS) {
472 if (longval < min || longval > max) {
473 ret = DSYM_VALUE_OUT_OF_RANGE;
474 } else {
475 *intval = (int)longval;
476 }
477 }
478 return (ret);
479 }
480
481 /*
482 * dsym_validate_code(): given a symbol category and code, validates
483 * that the code is valid for the category
484 *
485 * input: dsym_category_t: the symbol category
486 * uint16_t: the symbol code
487 * output: DSYM_SUCCESS, DSYM_INVALID_CAT or DSYM_CODE_OUT_OF_RANGE
488 */
489
490 static dsym_errcode_t
dsym_validate_code(dsym_category_t cat,ushort_t code)491 dsym_validate_code(dsym_category_t cat, ushort_t code)
492 {
493
494 int cnt = sizeof (cats) / sizeof (dsym_cat_t);
495 int i;
496
497 /*
498 * Find the category entry from the internal table.
499 */
500 for (i = 0; i < cnt; i++) {
501 dsym_cat_t *entry;
502 if (cat == cats[i].dc_id) {
503 entry = &cats[i];
504 if (code < entry->dc_min || code > entry->dc_max) {
505 return (DSYM_CODE_OUT_OF_RANGE);
506 }
507 return (DSYM_SUCCESS);
508 }
509 }
510
511 return (DSYM_INVALID_CAT);
512 }
513
514 /*
515 * dsym_validate_granularity(): given a symbol type, validates
516 * that the granularity is valid for the type
517 *
518 * input: dsym_cdtype_t: the symbol type
519 * uchar_t: the symbol granularity
520 * output: DSYM_SUCCESS or DSYM_VALUE_OUT_OF_RANGE
521 */
522
523 static dsym_errcode_t
dsym_validate_granularity(dsym_cdtype_t type,uchar_t gran)524 dsym_validate_granularity(dsym_cdtype_t type, uchar_t gran)
525 {
526 /*
527 * We only need to check for a 0 with non-boolean types, as
528 * anything else is already validated by the ranges passed to
529 * dsym_parse_intrange() in dsym_parse_field().
530 */
531 if (gran == 0 && type != DSYM_BOOL) {
532 return (DSYM_VALUE_OUT_OF_RANGE);
533 }
534 return (DSYM_SUCCESS);
535 }
536
537 /*
538 * dsym_get_type_by_name(): given a type field, returns the pointer to its
539 * entry in the internal type table.
540 *
541 * input: const char *: the type name
542 * dsym_type_t *: the return location for the pointer to the table entry
543 * boolean_t: case-sensitive name compare
544 * output: int: DSYM_SUCCESS or DSYM_INVALID_TYPE
545 */
546
547 static dsym_errcode_t
dsym_get_type_by_name(const char * type,dsym_type_t ** entry,boolean_t cs)548 dsym_get_type_by_name(const char *type, dsym_type_t **entry, boolean_t cs)
549 {
550 int cnt = sizeof (types) / sizeof (dsym_type_t);
551 int result;
552 int i;
553
554 for (i = 0; i < cnt; i++) {
555
556 if (cs) {
557 result = strcmp(type, types[i].dt_string);
558 } else {
559 result = strcasecmp(type, types[i].dt_string);
560 }
561
562 if (result == 0) {
563 *entry = &types[i];
564 return (DSYM_SUCCESS);
565 }
566 }
567
568 return (DSYM_INVALID_TYPE);
569 }
570
571 /*
572 * dsym_parse_type(): given a DHCP type string, returns the type id
573 *
574 * input: char *: a DHCP type string
575 * dsym_cdtype_t *: the return location for the type id
576 * output: int: DSYM_SUCCESS or DSYM_INVALID_TYPE
577 */
578
579 static dsym_errcode_t
dsym_parse_type(char * field,dsym_cdtype_t * type)580 dsym_parse_type(char *field, dsym_cdtype_t *type)
581 {
582
583 dsym_type_t *entry;
584 int ret;
585
586 ret = dsym_get_type_by_name(field, &entry, B_TRUE);
587 if (ret == DSYM_SUCCESS) {
588 /*
589 * Since this routine is meant to be used to parse dhcptab
590 * symbol definitions, only a subset of the DHCP type
591 * are valid in this context.
592 */
593 if (entry->dt_dhcptab) {
594 *type = entry->dt_id;
595 } else {
596 ret = DSYM_INVALID_TYPE;
597 }
598 }
599
600 return (ret);
601 }
602
603 /*
604 * dsym_free_fields(): frees an array of fields allocated by
605 * dsym_init_parser().
606 *
607 * input: char **: array of fields to free
608 * output: none
609 */
610
611 void
dsym_free_fields(char ** fields)612 dsym_free_fields(char **fields)
613 {
614 int i;
615 if (fields != NULL) {
616 for (i = 0; i < DSYM_NUM_FIELDS; i++) {
617 free(fields[i]);
618 }
619 free(fields);
620 }
621 }
622
623 /*
624 * dsym_close_parser(): free up all resources associated with the parser
625 *
626 * input: char **: the fields allocated by dsym_init_parser()
627 * dhcp_symbol_t *: the structure populated by dsym_init_parser()
628 * output: none
629 */
630
631 void
dsym_close_parser(char ** fields,dhcp_symbol_t * sym)632 dsym_close_parser(char **fields, dhcp_symbol_t *sym)
633 {
634 dsym_free_fields(fields);
635 dsym_free_classes(&sym->ds_classes);
636 }
637
638 /*
639 * dsym_init_parser(): initializes the structures used to parse a symbol
640 * value.
641 *
642 * input: const char *: the symbol name
643 * const char *: the symbol value in dhcptab format
644 * char ***: the return location for the symbol fields
645 * dhcp_symbol_t *: the structure which eventually will
646 * be the repository for the parsed symbol data
647 * output: int: DSYM_SUCCESS, DYSM_NO_MEMORY, DSYM_NULL_FIELD or
648 * DSYM_TOO_MANY_FIELDS
649 */
650
651 dsym_errcode_t
dsym_init_parser(const char * name,const char * value,char *** fields_ret,dhcp_symbol_t * sym)652 dsym_init_parser(const char *name, const char *value, char ***fields_ret,
653 dhcp_symbol_t *sym)
654 {
655
656 int ret = DSYM_SUCCESS;
657 char *cp;
658 char *next;
659 char *field;
660 char **fields;
661 int i;
662
663 /*
664 * Initialize the symbol structure.
665 */
666 sym->ds_category = 0;
667 sym->ds_code = 0;
668 (void) strlcpy(sym->ds_name, name, DSYM_MAX_SYM_LEN);
669 sym->ds_type = 0;
670 sym->ds_gran = 0;
671 sym->ds_max = 0;
672 sym->ds_classes.dc_names = NULL;
673 sym->ds_classes.dc_cnt = 0;
674
675 if ((cp = strdup(value)) == NULL ||
676 (fields = calloc(DSYM_NUM_FIELDS, sizeof (char *))) == NULL) {
677 ret = DSYM_NO_MEMORY;
678 }
679
680 next = cp;
681 for (i = 0; ret == DSYM_SUCCESS && i < DSYM_NUM_FIELDS; i++) {
682
683 field = dsym_get_token(next, DSYM_FIELD_DEL, &next,
684 B_FALSE);
685
686 if (field == NULL) {
687 ret = DSYM_NULL_FIELD;
688 continue;
689 }
690
691 dsym_trim(&field);
692
693 if (strlen(field) == 0) {
694 ret = DSYM_NULL_FIELD;
695 continue;
696 }
697
698 if ((fields[i] = strdup(field)) == NULL) {
699 ret = DSYM_NO_MEMORY;
700 continue;
701 }
702 }
703
704 if (ret == DSYM_SUCCESS &&
705 dsym_get_token(next, DSYM_FIELD_DEL, &next, B_FALSE) != NULL) {
706 ret = DSYM_TOO_MANY_FIELDS;
707 }
708
709 if (ret != DSYM_SUCCESS) {
710 dsym_free_fields(fields);
711 } else {
712 *fields_ret = fields;
713 }
714
715 free(cp);
716 return (ret);
717 }
718
719 /*
720 * dsym_parse_field(): parses the specified symbol field.
721 *
722 * input: int: the field number to be parsed.
723 * char **: symbol fields initialized by dsym_init_parser()
724 * dhcp_symbol_t *: the structure which will be the repository
725 * for the parsed field
726 * output: int: DSYM_SUCCESS, DSYM_SYNTAX_ERROR, DSYM_CODE_OUT_OF_RANGE,
727 * DSYM_INVALID_CAT, DSYM_INVALID_TYPE, DSYM_EXCEEDS_CLASS_SIZE,
728 * DSYM_EXCEEDS_MAX_CLASS_SIZE, DSYM_NO_MEMORY,
729 * DSYM_INVALID_FIELD_NUM, DSYM_VALUE_OUT_OF_RANGE
730 */
731
732 dsym_errcode_t
dsym_parse_field(int field_num,char ** fields,dhcp_symbol_t * sym)733 dsym_parse_field(int field_num, char **fields, dhcp_symbol_t *sym)
734 {
735
736 int ret = DSYM_SUCCESS;
737 int intval;
738
739 switch (field_num) {
740
741 case DSYM_CAT_FIELD:
742 ret = dsym_parse_cat(fields[field_num], &sym->ds_category);
743 if (ret == DSYM_SUCCESS && sym->ds_category == DSYM_VENDOR) {
744 ret = dsym_parse_classes(fields[field_num],
745 &sym->ds_classes);
746 }
747 break;
748
749 case DSYM_CODE_FIELD:
750 ret = dsym_parse_intrange(fields[field_num], &intval, 0,
751 USHRT_MAX);
752 if (ret == DSYM_SUCCESS) {
753 sym->ds_code = (ushort_t)intval;
754 ret = dsym_validate_code(sym->ds_category,
755 sym->ds_code);
756 }
757 break;
758
759 case DSYM_TYPE_FIELD:
760 ret = dsym_parse_type(fields[field_num], &sym->ds_type);
761 break;
762
763 case DSYM_GRAN_FIELD:
764 ret = dsym_parse_intrange(fields[field_num], &intval, 0,
765 UCHAR_MAX);
766 if (ret == DSYM_SUCCESS) {
767 sym->ds_gran = (uchar_t)intval;
768 ret = dsym_validate_granularity(sym->ds_type,
769 sym->ds_gran);
770 }
771 break;
772
773 case DSYM_MAX_FIELD:
774 ret = dsym_parse_intrange(fields[field_num], &intval, 0,
775 UCHAR_MAX);
776 if (ret == DSYM_SUCCESS) {
777 sym->ds_max = (uchar_t)intval;
778 }
779 break;
780 default:
781 ret = DSYM_INVALID_FIELD_NUM;
782 }
783
784 return (ret);
785 }
786
787 /*
788 * dsym_parser(): parses a DHCP symbol value
789 *
790 * input: char **: symbol fields initialized by dsym_init_parser()
791 * dhcp_symbol_t *: the structure which will be the repository
792 * for the parsed field
793 * int *: last field processed
794 * boolean_t: parse all fields even though errors occur?
795 * output: int: DSYM_SUCCESS, DSYM_SYNTAX_ERROR, DSYM_CODE_OUT_OF_RANGE,
796 * DSYM_INVALID_CAT, DSYM_INVALID_TYPE, DSYM_EXCEEDS_CLASS_SIZE,
797 * DSYM_EXCEEDS_MAX_CLASS_SIZE, DSYM_NO_MEMORY
798 * DSYM_INVALID_FIELD_NUM, DSYM_VALUE_OUT_OF_RANGE
799 */
800
801 dsym_errcode_t
dsym_parser(char ** fields,dhcp_symbol_t * sym,int * lastField,boolean_t bestEffort)802 dsym_parser(char **fields, dhcp_symbol_t *sym, int *lastField,
803 boolean_t bestEffort)
804 {
805
806 int ret = DSYM_SUCCESS;
807 int tret = DSYM_SUCCESS;
808 int i;
809
810 *lastField = -1;
811 for (i = DSYM_FIRST_FIELD;
812 tret == DSYM_SUCCESS && i < DSYM_NUM_FIELDS; i++) {
813
814 tret = dsym_parse_field(i, fields, sym);
815 if (tret != DSYM_SUCCESS) {
816 if (ret == DSYM_SUCCESS) {
817 ret = tret;
818 }
819 if (bestEffort) {
820 *lastField = i;
821 tret = DSYM_SUCCESS;
822 }
823 }
824 }
825
826 if (*lastField == -1) {
827 *lastField = i - 1;
828 }
829
830 return (ret);
831 }
832
833 /*
834 * dsym_get_cat_id(): given a category string, return the associated id.
835 *
836 * input: const char *: the category name
837 * dsym_category_t *: the return location for the id
838 * boolean_t: case-sensitive name compare
839 * output: int: DSYM_SUCCESS or DSYM_INVALID_CAT
840 */
841
842 dsym_errcode_t
dsym_get_cat_id(const char * cat,dsym_category_t * id,boolean_t cs)843 dsym_get_cat_id(const char *cat, dsym_category_t *id, boolean_t cs)
844 {
845
846 dsym_cat_t *entry;
847 int ret;
848
849 ret = dsym_get_cat_by_name(cat, &entry, cs);
850 if (ret == DSYM_SUCCESS) {
851 *id = entry->dc_id;
852 }
853
854 return (ret);
855 }
856
857 /*
858 * dsym_get_code_ranges(): given a category field, returns its valid code
859 * ranges.
860 *
861 * input: const char *: the category name
862 * ushort *: return location for the minimum code value.
863 * ushort *: return location for the maximum code value.
864 * boolean_t: case-sensitive name compare
865 * output: int: DSYM_SUCCESS or DSYM_INVALID_CAT
866 */
867
868 dsym_errcode_t
dsym_get_code_ranges(const char * cat,ushort_t * min,ushort_t * max,boolean_t cs)869 dsym_get_code_ranges(const char *cat, ushort_t *min, ushort_t *max,
870 boolean_t cs)
871 {
872
873 dsym_cat_t *entry;
874 int ret;
875
876 ret = dsym_get_cat_by_name(cat, &entry, cs);
877 if (ret == DSYM_SUCCESS) {
878 *min = entry->dc_min;
879 *max = entry->dc_max;
880 }
881
882 return (ret);
883 }
884
885 /*
886 * dsym_get_type_id(): given a type string, return the associated type id.
887 *
888 * input: const char *: the type name
889 * dsym_cdtype_t *: the return location for the id
890 * boolean_t: case-sensitive name compare
891 * output: int: DSYM_SUCCESS or DSYM_INVALID_TYPE
892 */
893
894 dsym_errcode_t
dsym_get_type_id(const char * type,dsym_cdtype_t * id,boolean_t cs)895 dsym_get_type_id(const char *type, dsym_cdtype_t *id, boolean_t cs)
896 {
897
898 dsym_type_t *entry;
899 int ret;
900
901 ret = dsym_get_type_by_name(type, &entry, cs);
902 if (ret == DSYM_SUCCESS) {
903 *id = entry->dt_id;
904 }
905
906 return (ret);
907 }
908