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