?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / picl / plugins / lib / picld_pluginutil / picld_pluginutil.c
blob9c71ebf7200b671b29eaba3544be75c69597a239
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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * This module implements the routine to parse the configuration file.
28 */
29
30
31 #include <stdio.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <stdlib.h>
35 #include <stdarg.h>
36 #include <string.h>
37 #include <ctype.h>
38 #include <alloca.h>
39 #include <limits.h>
40 #include <sys/utsname.h>
41 #include <sys/systeminfo.h>
42 #include <sys/types.h>
43 #include <libintl.h>
44 #include <syslog.h>
45 #include <locale.h>
46 #include <picl.h>
47 #include <picltree.h>
48 #include "picld_pluginutil.h"
49 #include "picld_pluginutil_impl.h"
50
51 /* error codes returned from syntax checking */
52 #define EC_SYNTAX_OK 0
53 #define EC_INSUFFICIENT_TOKEN 1
54 #define EC_SYNTAX_ERR 2
55 #define EC_UNSUPPORTED 3
56 #define EC_PATH_ERR 4
57 #define EC_NODE_MISMATCH 5
58 #define EC_FAILURE 6
59 #define EC_PICL_ERR 7
60 #define EC_TABLE_MISMATCH 8
61 #define EC_ROW_MISMATCH 9
62 #define EC_ROW_EMPTY 10
63
64 /*
65 * Error message texts
66 */
67 static char *err_msg[] = {
68 "%s: Syntax OK", /* 0 */
69 "%s::%s[line %d]: Insufficient token\n", /* 1 */
70 "%s::%s[line %d]: Syntax error\n", /* 2 */
71 "%s::%s[line %d]: Unsupported or missing version\n", /* 3 */
72 "%s::%s[line %d]: Illegal use of nodepath or namepath\n", /* 4 */
73 "%s::%s[line %d]: Node and endnode mismatch\n", /* 5 */
74 "%s::%s[line %d]: General system failure\n", /* 6 */
75 "%s: PICL error code %d\n", /* 7 */
76 "%s::%s[line %d]: Table and endtable mismatch\n", /* 8 */
77 "%s::%s[line %d]: Row and endrow mismatch\n", /* 9 */
78 "%s::%s[line %d]: Row has no entries \n" /* 10 */
79 };
80
81 /* token per directive */
82 #define TOK_CLASSPATH 0
83 #define TOK_NAMEPATH 1
84 #define TOK_NODE 2
85 #define TOK_ENDNODE 3
86 #define TOK_PROP 4
87 #define TOK_REFPROP 5
88 #define TOK_VERSION 6
89 #define TOK_REFNODE 7
90 #define TOK_VERBOSE 8
91 #define TOK_TABLE 9
92 #define TOK_ENDTABLE 10
93 #define TOK_ROW 11
94 #define TOK_ENDROW 12
95
96 static const char *tokens[] = {
97 "_class", /* _CLASS:<classpath> */
98 "name", /* NAME:<namepath> */
99 "node", /* NODE <name> <class> */
100 "endnode", /* ENDNODE */
101 "prop", /* PROP <name> <type> <access_mode> <size> <value> */
102 "refprop", /* REFPROP <prop> <destnode> */
103 "version", /* VERSION <version_number> */
104 "refnode", /* REFNODE <node> <class> WITH <destnode> */
105 "verbose", /* VERBOSE <level> */
106 "table", /* TABLE <table_prop_name> */
107 "endtable", /* ENDTABLE */
108 "row", /* ROW */
109 "endrow" /* ENDROW */
110 };
111
112 #define BUF_SIZE_MAX 1024
113
114 /*
115 * print error message
116 */
117 /*VARARGS2*/
118 static void
119 verbose_log(int pri, const char *fmt, ...)
120 {
121 va_list ap;
122
123 va_start(ap, fmt);
124 vsyslog(pri, fmt, ap);
125 va_end(ap);
126 }
127
128 /*
129 * Undo the commands which have created valid node/prop handle
130 * The undo order is from last command to the first command.
131 */
132 static void
133 undo_commands(cmdbuf_t *cmds, int last_cmd_index)
134 {
135 int i;
136 command_t *com = cmds->commands;
137
138 for (i = last_cmd_index; i >= 0; i--) {
139 switch (com[i].type) {
140 case TOK_NODE:
141 if (com[i].nodecmd_nodeh == NULL)
142 break;
143
144 (void) ptree_delete_node(com[i].nodecmd_nodeh);
145 (void) ptree_destroy_node(com[i].nodecmd_nodeh);
146 break;
147 case TOK_REFNODE:
148 if (com[i].refnodecmd_nodeh == NULL)
149 break;
150 (void) ptree_delete_node(com[i].refnodecmd_nodeh);
151 (void) ptree_destroy_node(com[i].refnodecmd_nodeh);
152 break;
153 case TOK_PROP:
154 if (com[i].propcmd_proph == NULL)
155 break;
156 (void) ptree_delete_prop(com[i].propcmd_proph);
157 (void) ptree_destroy_prop(com[i].propcmd_proph);
158 break;
159 case TOK_REFPROP:
160 if (com[i].refpropcmd_proph == NULL)
161 break;
162 (void) ptree_delete_prop(com[i].refpropcmd_proph);
163 (void) ptree_destroy_prop(com[i].refpropcmd_proph);
164 break;
165 case TOK_TABLE:
166 if ((com[i].tablecmd_tblh == NULL) ||
167 (com[i].tablecmd_newtbl == 0))
168 break;
169 (void) ptree_delete_prop(com[i].tablecmd_tblh);
170 (void) ptree_destroy_prop(com[i].tablecmd_tblh);
171 break;
172 case TOK_ENDTABLE:
173 /*FALLTHROUGH*/
174 case TOK_ROW:
175 /*FALLTHROUGH*/
176 case TOK_ENDROW:
177 /*FALLTHROUGH*/
178 case TOK_NAMEPATH:
179 /*FALLTHROUGH*/
180 case TOK_CLASSPATH:
181 /*FALLTHROUGH*/
182 case TOK_ENDNODE:
183 /*FALLTHROUGH*/
184 case TOK_VERBOSE:
185 /*FALLTHROUGH*/
186 default:
187 break;
188 }
189 }
190 }
191
192 /*
193 * Get the token index from the tokens table
194 */
195 static int
196 get_token_id(char *t)
197 {
198 int i;
199
200 for (i = 0; i < sizeof (tokens)/ sizeof (char *); ++i)
201 if (strcasecmp(tokens[i], t) == 0)
202 return (i);
203
204 return (-1);
205 }
206
207 /*
208 * Check the version syntax and set the version_no
209 *
210 * VERSION <version_num> -- specify the configuration version
211 */
212 static int
213 parse_version(cmdbuf_t *cmds, char *line)
214 {
215 char *tok;
216 char *vertok;
217 char *last;
218 char *endptr;
219
220 /* get the VERSION directive */
221 tok = strtok_r(line, WHITESPACE, &last);
222 if (tok == NULL)
223 return (EC_INSUFFICIENT_TOKEN);
224
225 /* get the version number */
226 vertok = strtok_r(last, WHITESPACE, &last);
227 if (vertok == NULL)
228 return (EC_INSUFFICIENT_TOKEN);
229
230 cmds->version_no = (float)strtod(vertok, &endptr);
231 if (endptr != (vertok + strlen(vertok)))
232 return (EC_UNSUPPORTED);
233
234 if (cmds->version_no > (float)SUPPORTED_VERSION_NUM)
235 return (EC_UNSUPPORTED);
236
237 /* check if more tokens */
238 tok = strtok_r(last, WHITESPACE, &last);
239 if (tok != NULL)
240 return (EC_SYNTAX_ERR);
241
242 return (EC_SYNTAX_OK);
243 }
244
245 /*
246 * free path_cmd_t
247 */
248 static void
249 free_path(command_t *command)
250 {
251 free(command->pathcmd_name);
252 }
253
254 /*
255 * Check the path syntax
256 * NAMEPATH:<namepath> -- gives the anchor node
257 * or
258 * CLASSPATH:<classpath> -- gives the anchor node
259 */
260 static int
261 parse_path(char *line, command_t *command)
262 {
263 char *tok;
264 char *pathtok;
265 char *last;
266
267 pathtok = strtok_r(line, WHITESPACE, &last);
268 if (pathtok == NULL)
269 return (EC_INSUFFICIENT_TOKEN);
270
271 /* check if more tokens */
272 tok = strtok_r(last, WHITESPACE, &last);
273 if (tok != NULL)
274 return (EC_SYNTAX_ERR);
275
276 command->pathcmd_name = strdup(pathtok);
277 if (command->pathcmd_name == NULL)
278 return (EC_FAILURE);
279
280 return (EC_SYNTAX_OK);
281 }
282
283 /*
284 * Process the path command and return PICL node handle
285 */
286 static int
287 process_path(command_t *command, picl_nodehdl_t *nodeh)
288 {
289 int err;
290
291 err = ptree_get_node_by_path(command->pathcmd_name, nodeh);
292 return (err);
293 }
294
295 /*
296 * free node_cmd_t
297 */
298 static void
299 free_node(command_t *command)
300 {
301 free(command->nodecmd_nodename);
302 free(command->nodecmd_classname);
303 }
304
305 /*
306 * Check the NODE syntax
307 * NODE <name> <class>
308 */
309 static int
310 parse_node(char *line, command_t *command)
311 {
312 char *tok;
313 char *nametok;
314 char *classtok;
315 char *last;
316
317 /* get the NODE directive */
318 tok = strtok_r(line, WHITESPACE, &last);
319 if (tok == NULL)
320 return (EC_INSUFFICIENT_TOKEN);
321
322 /* get name */
323 nametok = strtok_r(last, WHITESPACE, &last);
324 if (nametok == NULL)
325 return (EC_INSUFFICIENT_TOKEN);
326
327 classtok = strtok_r(last, WHITESPACE, &last);
328 if (classtok == NULL)
329 return (EC_INSUFFICIENT_TOKEN);
330
331 /* check if more tokens */
332 tok = strtok_r(last, WHITESPACE, &last);
333 if (tok != NULL)
334 return (EC_SYNTAX_ERR);
335
336 command->nodecmd_nodename = strdup(nametok);
337 command->nodecmd_classname = strdup(classtok);
338 command->nodecmd_nodeh = NULL;
339 if ((command->nodecmd_nodename == NULL) ||
340 (command->nodecmd_classname == NULL))
341 return (EC_FAILURE);
342
343 return (EC_SYNTAX_OK);
344 }
345
346 /*
347 * Process the NODE command and return PICL node handle
348 */
349 static int
350 process_node(command_t *command, picl_nodehdl_t parh, picl_nodehdl_t *nodeh)
351 {
352 int err;
353
354 err = ptree_create_and_add_node(parh, command->nodecmd_nodename,
355 command->nodecmd_classname, nodeh);
356
357 if (err == PICL_SUCCESS)
358 command->nodecmd_nodeh = *nodeh;
359
360 return (err);
361 }
362
363 /*
364 * get the PICL property type
365 */
366 static int
367 getpicltype(char *type)
368 {
369 if (strcasecmp(type, KEYWORD_INT_TYPE) == 0)
370 return (PICL_PTYPE_INT);
371 else if (strcasecmp(type, KEYWORD_UINT_TYPE) == 0)
372 return (PICL_PTYPE_UNSIGNED_INT);
373 else if (strcasecmp(type, KEYWORD_FLOAT_TYPE) == 0)
374 return (PICL_PTYPE_FLOAT);
375 else if (strcasecmp(type, KEYWORD_STRING_TYPE) == 0)
376 return (PICL_PTYPE_CHARSTRING);
377 else if (strcasecmp(type, KEYWORD_VOID_TYPE) == 0)
378 return (PICL_PTYPE_VOID);
379 else
380 return (-1);
381 }
382
383 /*
384 * get the PICL accessmode mode
385 */
386 static int
387 getpiclmode(char *mode)
388 {
389 if (strcasecmp(mode, KEYWORD_READ_MODE) == 0)
390 return (PICL_READ);
391 else if (strcasecmp(mode, KEYWORD_WRITE_MODE) == 0)
392 return (PICL_WRITE);
393 else if (strcasecmp(mode, KEYWORD_READWRITE_MODE) == 0)
394 return (PICL_READ|PICL_WRITE);
395 else
396 return (-1);
397 }
398
399 /*
400 * check if the size and value are valid given by the prop type
401 */
402 static int
403 validate_size_and_cvt_val(void *outbuf, size_t size, int type, char *val)
404 {
405 int64_t llval;
406 int32_t intval;
407 int16_t sval;
408 int8_t cval;
409 uint64_t ullval;
410 uint32_t uintval;
411 uint16_t usval;
412 uint8_t ucval;
413 float fval;
414 double dval;
415 char *endptr;
416
417 switch (type) {
418 case PICL_PTYPE_CHARSTRING:
419 break;
420 case PICL_PTYPE_INT:
421 switch (size) {
422 case sizeof (int64_t):
423 llval = strtoll(val, &endptr, 0);
424 if (endptr != (val + strlen(val)))
425 return (EC_SYNTAX_ERR);
426 (void) memcpy(outbuf, &llval, size);
427 break;
428 case sizeof (int32_t):
429 intval = strtol(val, &endptr, 0);
430 if (endptr != (val + strlen(val)))
431 return (EC_SYNTAX_ERR);
432 (void) memcpy(outbuf, &intval, size);
433 break;
434 case sizeof (int16_t):
435 sval = (int16_t)strtol(val, &endptr, 0);
436 if (endptr != (val + strlen(val)))
437 return (EC_SYNTAX_ERR);
438 (void) memcpy(outbuf, &sval, size);
439 break;
440 case sizeof (int8_t):
441 cval = (int8_t)strtol(val, &endptr, 0);
442 if (endptr != (val + strlen(val)))
443 return (EC_SYNTAX_ERR);
444 (void) memcpy(outbuf, &cval, size);
445 break;
446 default: /* invalid size */
447 return (EC_SYNTAX_ERR);
448 }
449 break;
450 case PICL_PTYPE_UNSIGNED_INT:
451 switch (size) {
452 case sizeof (uint64_t):
453 ullval = strtoull(val, &endptr, 0);
454 if (endptr != (val + strlen(val)))
455 return (EC_SYNTAX_ERR);
456 (void) memcpy(outbuf, &ullval, size);
457 break;
458 case sizeof (uint32_t):
459 uintval = strtoul(val, &endptr, 0);
460 if (endptr != (val + strlen(val)))
461 return (EC_SYNTAX_ERR);
462 (void) memcpy(outbuf, &uintval, size);
463 break;
464 case sizeof (uint16_t):
465 usval = (uint16_t)strtoul(val, &endptr, 0);
466 if (endptr != (val + strlen(val)))
467 return (EC_SYNTAX_ERR);
468 (void) memcpy(outbuf, &usval, size);
469 break;
470 case sizeof (uint8_t):
471 ucval = (uint8_t)strtoul(val, &endptr, 0);
472 if (endptr != (val + strlen(val)))
473 return (EC_SYNTAX_ERR);
474 (void) memcpy(outbuf, &ucval, size);
475 break;
476 default: /* invalid size */
477 return (EC_SYNTAX_ERR);
478 }
479 break;
480 case PICL_PTYPE_FLOAT:
481 switch (size) {
482 case sizeof (double):
483 dval = strtod(val, &endptr);
484 if (endptr != (val + strlen(val)))
485 return (EC_SYNTAX_ERR);
486 (void) memcpy(outbuf, &dval, size);
487 break;
488 case sizeof (float):
489 fval = (float)strtod(val, &endptr);
490 if (endptr != (val + strlen(val)))
491 return (EC_SYNTAX_ERR);
492 (void) memcpy(outbuf, &fval, size);
493 break;
494 default: /* invalid size */
495 return (EC_SYNTAX_ERR);
496 }
497 break;
498 default: /* not supported type */
499 return (EC_SYNTAX_ERR);
500 }
501
502 return (EC_SYNTAX_OK);
503 }
504
505 /*
506 * free prop_cmd_t
507 */
508 static void
509 free_prop(command_t *command)
510 {
511 free(command->propcmd_pname);
512 if (command->propcmd_type != PICL_PTYPE_VOID)
513 free(command->propcmd_valbuf);
514 }
515
516 /*
517 * return the string token in two double quotes
518 * The current version won't support multiple-line string
519 */
520 static int
521 get_string_token(char *line, char **valtok)
522 {
523 char *optr; /* ptr to the open quote */
524 char *cptr; /* ptr to the close quote */
525 char *ptr;
526 char *tmpbuf;
527
528 if (line == NULL)
529 return (EC_INSUFFICIENT_TOKEN);
530
531 /* skipping leading white spaces */
532 optr = line;
533 while ((*optr == ' ') || (*optr == '\t') || (*optr == '\n'))
534 optr++;
535
536 /* reach end of string */
537 if (*optr == '\0')
538 return (EC_INSUFFICIENT_TOKEN);
539
540 /* it's not an open double quote */
541 if (*optr != '"')
542 return (EC_SYNTAX_ERR);
543
544 /* skipping ending white spaces */
545 cptr = line + strlen(line) - 1;
546 while ((*cptr == ' ') || (*cptr == '\t') || (*cptr == '\n'))
547 cptr--;
548
549 /* it's not an close double quote */
550 if (*cptr != '"')
551 return (EC_SYNTAX_ERR);
552
553 /* close double quote is missing */
554 if (cptr == optr)
555 return (EC_SYNTAX_ERR);
556
557 /* replace close qoute by null to make a string */
558 *cptr = '\0';
559 /* move the begin pointer to the first char of string */
560 optr++;
561
562 tmpbuf = malloc(strlen(optr) + 1);
563 if (tmpbuf == NULL)
564 return (EC_FAILURE);
565
566 for (ptr = tmpbuf; *optr != '\0'; ptr++, optr++) {
567 /* if escape character, go to next character */
568 if (*optr == '\\') {
569 optr++;
570 if (*optr == '\0') { /* for exampe, "xxx\" */
571 free(tmpbuf);
572 return (EC_SYNTAX_ERR);
573 }
574 }
575 *ptr = *optr;
576 }
577
578 *ptr = '\0';
579 *valtok = tmpbuf;
580 return (EC_SYNTAX_OK);
581 }
582
583 /*
584 * Check the PROP syntax
585 * PROP <name> <type> <access_mode> [<size> <value>]
586 * supported prop types: void, int, uint, float, string
587 * supported prop access_modes: r, w, rw
588 * For void prop, <size> and <value> are not needed
589 * For string prop, <size> will be set the actual string size if <size>
590 * is 0
591 */
592 static int
593 parse_prop(char *line, command_t *command)
594 {
595 char *tok;
596 char *pnametok;
597 int typetok;
598 size_t sizetok;
599 int modetok;
600 char *valtok;
601 char *last;
602 char *endptr;
603 int err;
604
605 /* get the PROP directive */
606 tok = strtok_r(line, WHITESPACE, &last);
607 if (tok == NULL)
608 return (EC_INSUFFICIENT_TOKEN);
609
610 /* get the property name */
611 pnametok = strtok_r(last, WHITESPACE, &last);
612 if (pnametok == NULL)
613 return (EC_INSUFFICIENT_TOKEN);
614
615 /* get the type */
616 tok = strtok_r(last, WHITESPACE, &last);
617 if (tok == NULL)
618 return (EC_INSUFFICIENT_TOKEN);
619
620 if ((typetok = getpicltype(tok)) < 0)
621 return (EC_SYNTAX_ERR);
622
623 /* get mode */
624 tok = strtok_r(last, WHITESPACE, &last);
625 if (tok == NULL)
626 return (EC_INSUFFICIENT_TOKEN);
627
628 if ((modetok = getpiclmode(tok)) < 0)
629 return (EC_SYNTAX_ERR);
630
631 if (typetok == PICL_PTYPE_VOID) {
632 /* ignore the rest of arguments */
633 command->propcmd_valbuf = NULL;
634 command->propcmd_pname = strdup(pnametok);
635 if (command->propcmd_pname == NULL)
636 return (EC_FAILURE);
637 command->propcmd_type = typetok;
638 command->propcmd_accessmode = modetok;
639 command->propcmd_size = 0;
640 command->propcmd_proph = NULL;
641 return (EC_SYNTAX_OK);
642 }
643
644 /* get size */
645 tok = strtok_r(last, WHITESPACE, &last);
646 if (tok == NULL)
647 return (EC_INSUFFICIENT_TOKEN);
648
649 sizetok = (size_t)strtol(tok, &endptr, 0);
650 if (endptr != (tok + strlen(tok)))
651 return (EC_SYNTAX_ERR);
652
653 /* get val */
654 if (typetok == PICL_PTYPE_CHARSTRING) {
655 err = get_string_token(last, &valtok);
656 if (err != EC_SYNTAX_OK)
657 return (err);
658 if (sizetok == 0)
659 sizetok = strlen(valtok) + 1;
660 command->propcmd_valbuf = valtok;
661 } else {
662 valtok = strtok_r(last, WHITESPACE, &last);
663 if (valtok == NULL)
664 return (EC_INSUFFICIENT_TOKEN);
665 /* check if more tokens */
666 tok = strtok_r(last, WHITESPACE, &last);
667 if (tok != NULL)
668 return (EC_SYNTAX_ERR);
669 command->propcmd_valbuf = malloc(sizetok);
670 if (command->propcmd_valbuf == NULL)
671 return (EC_FAILURE);
672 err = validate_size_and_cvt_val(command->propcmd_valbuf,
673 sizetok, typetok, valtok);
674 if (err != EC_SYNTAX_OK) {
675 free(command->propcmd_valbuf);
676 return (err);
677 }
678 }
679
680 command->propcmd_pname = strdup(pnametok);
681 if (command->propcmd_pname == NULL)
682 return (EC_FAILURE);
683 command->propcmd_type = typetok;
684 command->propcmd_accessmode = modetok;
685 command->propcmd_size = sizetok;
686 command->propcmd_proph = NULL;
687 return (EC_SYNTAX_OK);
688 }
689
690 /*
691 * Add a property to the row, the row gets added to the node at endrow
692 */
693 static int
694 add_proph_to_row(command_t *command, picl_prophdl_t proph)
695 {
696 if (command->rowcmd_index >= command->rowcmd_nproph)
697 return (PICL_FAILURE);
698 command->rowcmd_prophs[command->rowcmd_index] = proph;
699 command->rowcmd_index++;
700 return (PICL_SUCCESS);
701 }
702
703 /*
704 * Process the PROP command and add the specified property under the given
705 * node handle
706 */
707 static int
708 process_prop(cmdbuf_t *cmds, command_t *command, picl_nodehdl_t nodeh)
709 {
710 ptree_propinfo_t propinfo;
711 picl_prophdl_t proph;
712 int err;
713
714 /* prop in discarded row */
715 if (cmds->inside_row_block &&
716 cmds->commands[cmds->current_row].rowcmd_nproph == 0)
717 return (PICL_SUCCESS);
718
719 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
720 command->propcmd_type, command->propcmd_accessmode,
721 command->propcmd_size, command->propcmd_pname, NULL,
722 NULL);
723
724 if (err != PICL_SUCCESS)
725 return (err);
726
727 err = ptree_create_prop(&propinfo, command->propcmd_valbuf, &proph);
728
729 if (err != PICL_SUCCESS)
730 return (err);
731
732 command->propcmd_proph = proph;
733
734 if (cmds->inside_row_block) {
735 err = add_proph_to_row(&cmds->commands[cmds->current_row],
736 proph);
737 } else {
738 err = ptree_add_prop(nodeh, proph);
739 }
740
741 return (err);
742 }
743
744 /*
745 * free refnode_cmd_t
746 */
747 static void
748 free_refnode(command_t *command)
749 {
750 free(command->refnodecmd_name);
751 free(command->refnodecmd_class);
752 free(command->refnodecmd_dstnode);
753 }
754
755 /*
756 * Check the REFNODE syntax
757 *
758 * REFNODE <name> <class> with <destnode> -- if <destnode> exists,
759 * create node with nodename <name> and piclclass <class>
760 */
761 static int
762 parse_refnode(char *line, command_t *command)
763 {
764 char *tok;
765 char *dsttok;
766 char *classnm;
767 char *nodenm;
768 char *last;
769
770 /* get the directive */
771 tok = strtok_r(line, WHITESPACE, &last);
772 if (tok == NULL)
773 return (EC_INSUFFICIENT_TOKEN);
774
775 /* get the nodename */
776 nodenm = strtok_r(last, WHITESPACE, &last);
777 if (nodenm == NULL)
778 return (EC_INSUFFICIENT_TOKEN);
779
780 /* get the class */
781 classnm = strtok_r(last, WHITESPACE, &last);
782 if (classnm == NULL)
783 return (EC_INSUFFICIENT_TOKEN);
784
785 /* get the WITH keyword */
786 tok = strtok_r(last, WHITESPACE, &last);
787 if (tok == NULL)
788 return (EC_INSUFFICIENT_TOKEN);
789
790 if (strcasecmp(tok, KEYWORD_WITH_STR) != 0)
791 return (EC_SYNTAX_ERR);
792
793 /* get the dst node */
794 dsttok = strtok_r(last, WHITESPACE, &last);
795 if (dsttok == NULL)
796 return (EC_INSUFFICIENT_TOKEN);
797
798 /* check if more tokens */
799 tok = strtok_r(last, WHITESPACE, &last);
800 if (tok != NULL)
801 return (EC_SYNTAX_ERR);
802
803 command->refnodecmd_name = strdup(nodenm);
804 command->refnodecmd_class = strdup(classnm);
805 command->refnodecmd_dstnode = strdup(dsttok);
806 command->refnodecmd_nodeh = NULL;
807 if ((command->refnodecmd_name == NULL) ||
808 (command->refnodecmd_class == NULL) ||
809 (command->refnodecmd_dstnode == NULL))
810 return (EC_FAILURE);
811
812 return (EC_SYNTAX_OK);
813 }
814
815 /*
816 * Process the REFNODE command
817 */
818 static int
819 process_refnode(command_t *command, picl_nodehdl_t parh)
820 {
821 picl_nodehdl_t dsth;
822 picl_nodehdl_t nodeh;
823 int err;
824
825 if ((ptree_get_node_by_path(command->refnodecmd_dstnode,
826 &dsth) == PICL_SUCCESS)) {
827 err = ptree_create_and_add_node(parh, command->refnodecmd_name,
828 command->refnodecmd_class, &nodeh);
829 if (err == PICL_SUCCESS)
830 command->refnodecmd_nodeh = nodeh;
831
832 return (err);
833 }
834
835 return (PICL_SUCCESS);
836 }
837
838 /*
839 * free refprop_cmd_t
840 */
841 static void
842 free_refprop(command_t *command)
843 {
844 free(command->refpropcmd_pname);
845 free(command->refpropcmd_dstnode);
846 }
847
848 /*
849 * Check the REFPROP syntax
850 *
851 * REFPROP <prop> <destnode> -- creates a reference property to <destnode>
852 */
853 static int
854 parse_refprop(char *line, command_t *command)
855 {
856 char *tok;
857 char *pnametok;
858 char *dsttok;
859 char *last;
860
861 /* get the REFPROP directive */
862 tok = strtok_r(line, WHITESPACE, &last);
863 if (tok == NULL)
864 return (EC_INSUFFICIENT_TOKEN);
865
866 /* get the propname */
867 pnametok = strtok_r(last, WHITESPACE, &last);
868 if (pnametok == NULL)
869 return (EC_INSUFFICIENT_TOKEN);
870
871 dsttok = strtok_r(last, WHITESPACE, &last);
872 if (dsttok == NULL)
873 return (EC_INSUFFICIENT_TOKEN);
874
875 /* check if more tokens */
876 tok = strtok_r(last, WHITESPACE, &last);
877 if (tok != NULL)
878 return (EC_SYNTAX_ERR);
879
880 command->refpropcmd_pname = strdup(pnametok);
881 command->refpropcmd_dstnode = strdup(dsttok);
882 command->refpropcmd_proph = NULL;
883 if ((command->refpropcmd_pname == NULL) ||
884 (command->refpropcmd_dstnode == NULL))
885 return (EC_FAILURE);
886
887 return (EC_SYNTAX_OK);
888 }
889
890 /*
891 * Process the REFPROP command
892 */
893 static int
894 process_refprop(cmdbuf_t *cmds, command_t *command, picl_nodehdl_t nodeh)
895 {
896 int err;
897 picl_nodehdl_t dsth;
898 picl_prophdl_t proph;
899 ptree_propinfo_t propinfo;
900
901 /* refprop in discarded row */
902 if (cmds->inside_row_block &&
903 cmds->commands[cmds->current_row].rowcmd_nproph == 0)
904 return (PICL_SUCCESS);
905
906 /* try finding the refprop's dstnode */
907 err = ptree_get_node_by_path(command->refpropcmd_dstnode, &dsth);
908
909 /* dstnode doesn't exist, return */
910 if (err != PICL_SUCCESS)
911 return (err);
912
913 /* dstnode exists, try adding the refprop to nodeh */
914 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
915 PICL_PTYPE_REFERENCE, PICL_READ, sizeof (picl_nodehdl_t),
916 command->refpropcmd_pname, NULL, NULL);
917
918 if (err != PICL_SUCCESS)
919 return (err);
920
921 err = ptree_create_prop(&propinfo, &dsth, &proph);
922
923 if (err != PICL_SUCCESS)
924 return (err);
925
926 command->refpropcmd_proph = proph;
927
928 if (cmds->inside_row_block) {
929 err = add_proph_to_row(&cmds->commands[cmds->current_row],
930 proph);
931 } else {
932 err = ptree_add_prop(nodeh, proph);
933 }
934
935 return (err);
936 }
937
938 /*
939 * free table_cmd_t
940 */
941 static void
942 free_table(command_t *command)
943 {
944 if (command->tablecmd_tname)
945 free(command->tablecmd_tname);
946 }
947
948 /*
949 * Check the TABLE syntax
950 * TABLE <table_prop_name>
951 *
952 */
953 static int
954 parse_table(char *line, command_t *command)
955 {
956 char *tok = NULL;
957 char *tnametok = NULL;
958 char *last = NULL;
959
960 /* get the TABLE directive */
961 tok = strtok_r(line, WHITESPACE, &last);
962 if (tok == NULL)
963 return (EC_INSUFFICIENT_TOKEN);
964
965 /* get the property name */
966 tnametok = strtok_r(last, WHITESPACE, &last);
967 if (tnametok == NULL)
968 return (EC_INSUFFICIENT_TOKEN);
969
970 command->tablecmd_tname = strdup(tnametok);
971 if (command->tablecmd_tname == NULL)
972 return (EC_FAILURE);
973
974 command->tablecmd_newtbl = 0;
975 command->tablecmd_tblh = NULL;
976
977 return (EC_SYNTAX_OK);
978 }
979
980 /*
981 * Process the TABLE command and add the specified property under the given
982 * node handle
983 */
984 static int
985 process_table(command_t *command, picl_nodehdl_t nodeh)
986 {
987 int err;
988 picl_prophdl_t tblh;
989 picl_prophdl_t proph;
990 ptree_propinfo_t propinfo;
991
992 /* find if table already exists */
993 err = ptree_get_prop_by_name(nodeh, command->tablecmd_tname, &tblh);
994 if (err == PICL_SUCCESS) {
995 err = ptree_get_propinfo(tblh, &propinfo);
996 if (err != PICL_SUCCESS)
997 return (err);
998 /* prop with the same name as table? */
999 if (propinfo.piclinfo.type != PICL_PTYPE_TABLE)
1000 return (EC_SYNTAX_ERR);
1001 command->tablecmd_newtbl = 0;
1002 command->tablecmd_tblh = tblh;
1003 return (PICL_SUCCESS);
1004 }
1005
1006 /* init and create a new table */
1007 err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
1008 PICL_PTYPE_TABLE, PICL_READ|PICL_WRITE,
1009 sizeof (picl_prophdl_t), command->tablecmd_tname, NULL, NULL);
1010 if (err != PICL_SUCCESS)
1011 return (err);
1012
1013 err = ptree_create_table(&tblh);
1014 if (err != PICL_SUCCESS)
1015 return (err);
1016
1017 command->tablecmd_newtbl = 1;
1018 command->tablecmd_tblh = tblh;
1019
1020 err = ptree_create_prop(&propinfo, &tblh, &proph);
1021 if (err != PICL_SUCCESS)
1022 return (err);
1023
1024 err = ptree_add_prop(nodeh, proph);
1025
1026 return (err);
1027 }
1028
1029 /*
1030 * Process the ROW command by alloc'ing space to store the prop handles for
1031 * the whole row. The number of props in the row gets known while parsing.
1032 */
1033 static int
1034 process_row(command_t *command)
1035 {
1036 command->rowcmd_index = 0;
1037 command->rowcmd_prophs =
1038 malloc(command->rowcmd_nproph * sizeof (picl_prophdl_t));
1039
1040 if (command->rowcmd_prophs == NULL)
1041 return (PICL_FAILURE);
1042
1043 return (PICL_SUCCESS);
1044 }
1045
1046 /*
1047 * Process the ENDROW command. If a valid row, add the row to the ptree.
1048 */
1049 static int
1050 process_endrow(cmdbuf_t *cmds)
1051 {
1052 int err;
1053 int i;
1054 command_t *curr_row;
1055
1056 curr_row = &cmds->commands[cmds->current_row];
1057
1058 /* if nproph == 0, some row prop had problems, don't add */
1059 if (curr_row->rowcmd_nproph == 0) {
1060 for (i = 0; i < curr_row->rowcmd_index; i++) {
1061 (void) ptree_delete_prop(curr_row->rowcmd_prophs[i]);
1062 (void) ptree_destroy_prop(curr_row->rowcmd_prophs[i]);
1063 }
1064 err = PICL_SUCCESS;
1065 } else
1066 err = ptree_add_row_to_table(
1067 cmds->commands[cmds->current_tbl].tablecmd_tblh,
1068 curr_row->rowcmd_nproph,
1069 curr_row->rowcmd_prophs);
1070
1071 /* let go the space alloc'd in process_row */
1072 free(curr_row->rowcmd_prophs);
1073 curr_row->rowcmd_prophs = NULL;
1074
1075 return (err);
1076 }
1077
1078 /*
1079 * Check the VERBOSE syntax
1080 * VERBOSE <level>
1081 */
1082 static int
1083 parse_verbose(cmdbuf_t *cmds, char *line, command_t *command)
1084 {
1085 char *tok;
1086 char *level;
1087 char *last;
1088 char *endptr;
1089 int verbose_level;
1090
1091 /* get the VERBOSE directive */
1092 tok = strtok_r(line, WHITESPACE, &last);
1093 if (tok == NULL)
1094 return (EC_INSUFFICIENT_TOKEN);
1095
1096 /* get verbose level */
1097 level = strtok_r(last, WHITESPACE, &last);
1098 if (level == NULL)
1099 return (EC_INSUFFICIENT_TOKEN);
1100 verbose_level = strtol(level, &endptr, 0);
1101 if (endptr != (level + strlen(level)))
1102 return (EC_SYNTAX_ERR);
1103
1104 /* check if more tokens */
1105 tok = strtok_r(last, WHITESPACE, &last);
1106 if (tok != NULL)
1107 return (EC_SYNTAX_ERR);
1108
1109 cmds->verbose = verbose_level;
1110 command->verbosecmd_level = verbose_level;
1111
1112 return (EC_SYNTAX_OK);
1113 }
1114
1115 /*
1116 * Process the VERBOSE command to set the verbose level
1117 */
1118 static int
1119 process_verbose(cmdbuf_t *cmds, command_t *command)
1120 {
1121 cmds->verbose = command->verbosecmd_level;
1122 return (PICL_SUCCESS);
1123 }
1124
1125 /*
1126 * parse and tokenize the line
1127 */
1128 static int
1129 parse_and_tokenize_line(cmdbuf_t *cmds, char *buf, command_t *command)
1130 {
1131 char rec[RECORD_SIZE_MAX];
1132 char *tok;
1133 int err;
1134 char *last;
1135 int id;
1136
1137 (void) strcpy(rec, buf);
1138 tok = strtok_r(rec, RECORD_WHITESPACE, &last);
1139 if (tok == NULL)
1140 return (EC_INSUFFICIENT_TOKEN);
1141
1142 id = get_token_id(tok);
1143
1144 (void) strcpy(rec, buf);
1145
1146 switch (id) {
1147 case TOK_VERSION:
1148 err = parse_version(cmds, rec);
1149 break;
1150 case TOK_CLASSPATH:
1151 case TOK_NAMEPATH:
1152 if (cmds->inside_node_block != 0)
1153 return (EC_PATH_ERR);
1154
1155 err = parse_path(rec, command);
1156 if (err != EC_SYNTAX_OK)
1157 return (err);
1158 break;
1159 case TOK_NODE:
1160 /* Check for NODE outside of TABLE, ROW */
1161 if ((cmds->inside_table_block != 0) ||
1162 (cmds->inside_row_block != 0))
1163 return (EC_SYNTAX_ERR);
1164 err = parse_node(rec, command);
1165 if (err != EC_SYNTAX_OK)
1166 return (err);
1167 cmds->inside_node_block++;
1168 break;
1169 case TOK_ENDNODE:
1170 /* Check for ENDNODE outside of TABLE, ROW */
1171 if ((cmds->inside_table_block != 0) ||
1172 (cmds->inside_row_block != 0))
1173 return (EC_SYNTAX_ERR);
1174 cmds->inside_node_block--;
1175 err = EC_SYNTAX_OK;
1176 break;
1177 case TOK_PROP:
1178 /* Check if inside TABLE, but not in ROW */
1179 if ((cmds->inside_table_block != 0) &&
1180 (cmds->inside_row_block == 0))
1181 return (EC_SYNTAX_ERR);
1182 err = parse_prop(rec, command);
1183 if (err != EC_SYNTAX_OK)
1184 return (err);
1185 if (cmds->inside_row_block) {
1186 cmds->commands[cmds->current_row].rowcmd_nproph++;
1187 }
1188 break;
1189 case TOK_REFNODE:
1190 err = parse_refnode(rec, command);
1191 if (err != EC_SYNTAX_OK)
1192 return (err);
1193 break;
1194 case TOK_REFPROP:
1195 /* Check if inside TABLE, but not in ROW */
1196 if ((cmds->inside_table_block != 0) &&
1197 (cmds->inside_row_block == 0))
1198 return (EC_SYNTAX_ERR);
1199 err = parse_refprop(rec, command);
1200 if (err != EC_SYNTAX_OK)
1201 return (err);
1202 if (cmds->inside_row_block) {
1203 cmds->commands[cmds->current_row].rowcmd_nproph++;
1204 }
1205 break;
1206 case TOK_TABLE:
1207 /* Table/Row supported in version 1.1 and above */
1208 if (cmds->version_no < (float)SUPPORTED_VERSION_NUM)
1209 return (EC_UNSUPPORTED);
1210 if (cmds->inside_table_block != 0)
1211 return (EC_SYNTAX_ERR);
1212 err = parse_table(rec, command);
1213 if (err != EC_SYNTAX_OK)
1214 return (err);
1215 cmds->inside_table_block = 1;
1216 break;
1217 case TOK_ENDTABLE:
1218 /* Check for ENDTABLE before TABLE */
1219 if (cmds->inside_table_block == 0)
1220 return (EC_SYNTAX_ERR);
1221
1222 cmds->inside_table_block = 0;
1223
1224 break;
1225 case TOK_ROW:
1226 /* Check for ROW outside of TABLE, ROW inside ROW */
1227 if ((cmds->inside_table_block == 0) ||
1228 (cmds->inside_row_block != 0))
1229 return (EC_SYNTAX_ERR);
1230 cmds->inside_row_block = 1;
1231 break;
1232 case TOK_ENDROW:
1233 /* Check for ENDROW outside of TABLE, ENDROW before ROW */
1234 if ((cmds->inside_table_block == 0) ||
1235 (cmds->inside_row_block == 0))
1236 return (EC_SYNTAX_ERR);
1237 else
1238 err = EC_SYNTAX_OK;
1239
1240 cmds->inside_row_block = 0;
1241
1242 /* error if row is empty */
1243 if (cmds->commands[cmds->current_row].rowcmd_nproph <= 0)
1244 return (EC_ROW_EMPTY);
1245 break;
1246 case TOK_VERBOSE:
1247 err = parse_verbose(cmds, rec, command);
1248 if (err != EC_SYNTAX_OK)
1249 return (err);
1250 break;
1251 default: /* unsupported command */
1252 return (EC_SYNTAX_ERR);
1253 }
1254
1255 command->type = id;
1256 return (EC_SYNTAX_OK);
1257 }
1258
1259 /*
1260 * Check the syntax and save the tokens in the commands buffer
1261 */
1262 static int
1263 check_line_syntax(cmdbuf_t *cmds, char *buf)
1264 {
1265 int err;
1266 command_t command;
1267
1268 (void) memset(&command, 0, sizeof (command_t));
1269 err = parse_and_tokenize_line(cmds, buf, &command);
1270 if (err != EC_SYNTAX_OK)
1271 return (err);
1272
1273 /*
1274 * don't add and count version command in the command buffer
1275 */
1276 if (command.type == TOK_VERSION)
1277 return (EC_SYNTAX_OK);
1278
1279 /*
1280 * check if the commands buffer has been filled
1281 * If it is full, reallocate the buffer.
1282 */
1283 if (cmds->count == cmds->allocated) {
1284 cmds->commands = realloc(cmds->commands,
1285 sizeof (command_t) * (cmds->allocated + PER_ALLOC_COUNT));
1286 if (cmds->commands == NULL)
1287 return (EC_FAILURE);
1288 cmds->allocated += PER_ALLOC_COUNT;
1289 }
1290
1291 cmds->commands[cmds->count] = command; /* copy */
1292
1293 /*
1294 * make a note of the row/endrow command, to keep track of # of props
1295 */
1296 if (command.type == TOK_ROW)
1297 cmds->current_row = cmds->count;
1298
1299 if (command.type == TOK_ENDROW)
1300 cmds->current_row = 0;
1301
1302 cmds->count++;
1303
1304 return (EC_SYNTAX_OK);
1305 }
1306
1307 /*
1308 * get the line control information
1309 * return 1 if it's the line control information, else return 0
1310 */
1311 static int
1312 get_line_control_info(char *buf, uint32_t *linenum, char *filename)
1313 {
1314 char *ptr;
1315 char *last;
1316 uint32_t num;
1317 char *fname;
1318 char *endptr;
1319
1320 /* skip # and get next string */
1321 ptr = strtok_r(buf + 1, WHITESPACE, &last);
1322 if (ptr == NULL) {
1323 return (0);
1324 }
1325
1326 num = strtoul(ptr, &endptr, 0);
1327
1328 /*
1329 * It's not the line control information
1330 */
1331 if (endptr != (ptr + strlen(ptr))) {
1332 return (0);
1333 }
1334
1335 /*
1336 * get the filename
1337 */
1338
1339 /* get the beginning double quote */
1340 last = strchr(last, '"');
1341 if (last == NULL)
1342 return (0);
1343
1344 last++;
1345
1346 /* get the ending double quote */
1347 fname = strtok_r(last, DOUBLE_QUOTE, &last);
1348 if (fname == NULL)
1349 return (0);
1350
1351 *linenum = num;
1352 (void) strlcpy(filename, fname, PATH_MAX);
1353 return (1);
1354 }
1355
1356 /*
1357 * check the syntax of the configuration file
1358 */
1359 static int
1360 check_conffile_syntax(cmdbuf_t *cmds, FILE *fp)
1361 {
1362 char lbuf[RECORD_SIZE_MAX];
1363 char buf[RECORD_SIZE_MAX];
1364 uint32_t linenum;
1365 char cppfile[PATH_MAX] = "";
1366 int err = EC_SYNTAX_OK;
1367
1368 linenum = 0;
1369 while (fgets(buf, sizeof (buf), fp) != NULL) {
1370 /*
1371 * get cpp line control information, if any
1372 */
1373 if (buf[0] == '#') {
1374 if (!get_line_control_info(buf, &linenum, cppfile))
1375 ++linenum;
1376 continue;
1377 }
1378
1379 ++linenum;
1380 /*
1381 * skip line whose first char is a newline char
1382 */
1383 if (buf[0] == '\n') {
1384 continue;
1385 }
1386
1387 if (err == EC_SYNTAX_OK)
1388 (void) strlcpy(lbuf, buf, RECORD_SIZE_MAX);
1389 else if (strlcat(lbuf, buf, RECORD_SIZE_MAX) >=
1390 RECORD_SIZE_MAX) { /* buffer overflow */
1391 err = EC_FAILURE;
1392 break;
1393 }
1394
1395 err = check_line_syntax(cmds, lbuf);
1396 if ((err != EC_INSUFFICIENT_TOKEN) && (err != EC_SYNTAX_OK))
1397 break;
1398 }
1399
1400 if (err != EC_SYNTAX_OK) {
1401 if (cmds->verbose) {
1402 verbose_log(LOG_ERR, err_msg[err],
1403 cmds->fname, cppfile, linenum);
1404 }
1405 return (err);
1406 }
1407
1408 /*
1409 * check if the version has been set
1410 */
1411 if (cmds->version_no > (float)SUPPORTED_VERSION_NUM) {
1412 if (cmds->verbose) {
1413 verbose_log(LOG_ERR, err_msg[EC_UNSUPPORTED],
1414 cmds->fname, cppfile, linenum);
1415 }
1416 return (EC_UNSUPPORTED);
1417 }
1418
1419 /*
1420 * check if node and endnode command mismatch
1421 */
1422 if (cmds->inside_node_block != 0) {
1423 if (cmds->verbose) {
1424 verbose_log(LOG_ERR, err_msg[EC_NODE_MISMATCH],
1425 cmds->fname, cppfile, linenum);
1426 }
1427 return (EC_NODE_MISMATCH);
1428 }
1429
1430 /*
1431 * check if row and endrow command mismatch
1432 */
1433 if (cmds->inside_row_block != 0) {
1434 if (cmds->verbose) {
1435 verbose_log(LOG_ERR, err_msg[EC_ROW_MISMATCH],
1436 cmds->fname, cppfile, linenum);
1437 }
1438 return (EC_ROW_MISMATCH);
1439 }
1440
1441 /*
1442 * check if table and endtable command mismatch
1443 */
1444 if (cmds->inside_table_block != 0) {
1445 if (cmds->verbose) {
1446 verbose_log(LOG_ERR, err_msg[EC_TABLE_MISMATCH],
1447 cmds->fname, cppfile, linenum);
1448 }
1449 return (EC_TABLE_MISMATCH);
1450 }
1451
1452 return (EC_SYNTAX_OK);
1453 }
1454
1455 /*
1456 * If classpath/namepath given is not found in the picl tree,
1457 * skip the whole blocks until next valid classpath or namepath
1458 */
1459 static void
1460 skip_to_next_valid_path(cmdbuf_t *cmds, int starting_index,
1461 picl_nodehdl_t *parent, int *last_processed_index)
1462 {
1463 int err;
1464 int index;
1465
1466 for (index = starting_index; index < cmds->count; ++index) {
1467 switch (cmds->commands[index].type) {
1468 case TOK_CLASSPATH:
1469 case TOK_NAMEPATH:
1470 err = process_path(&cmds->commands[index], parent);
1471 if (err == PICL_SUCCESS) {
1472 *last_processed_index = index;
1473 return;
1474 }
1475 default:
1476 /* skipped this line */
1477 break;
1478 }
1479 }
1480
1481 /* reach last command */
1482 *last_processed_index = cmds->count - 1;
1483 }
1484
1485 /*
1486 * Process the command buffer and return last command index and the new head of
1487 * the handle list
1488 */
1489 static int
1490 process_commands(cmdbuf_t *cmds, int starting_index, picl_nodehdl_t parent,
1491 int *last_processed_index)
1492 {
1493 int err;
1494 int index;
1495 picl_nodehdl_t rooth;
1496 picl_nodehdl_t nodeh;
1497 command_t *commands = cmds->commands;
1498
1499 for (index = starting_index; index < cmds->count; ++index) {
1500 switch (commands[index].type) {
1501 case TOK_CLASSPATH:
1502 case TOK_NAMEPATH:
1503 err = process_path(&commands[index], &rooth);
1504 if (err != PICL_SUCCESS) {
1505 index++;
1506 (void) skip_to_next_valid_path(cmds, index,
1507 &rooth, &index);
1508 }
1509 parent = rooth;
1510 continue;
1511 case TOK_NODE:
1512 err = process_node(&commands[index], parent, &nodeh);
1513 if (err == PICL_SUCCESS) {
1514 index++;
1515 err = process_commands(cmds, index, nodeh,
1516 &index);
1517 }
1518 break;
1519 case TOK_ENDNODE:
1520 *last_processed_index = index;
1521 return (PICL_SUCCESS);
1522 case TOK_PROP:
1523 err = process_prop(cmds, &commands[index], parent);
1524 break;
1525 case TOK_REFPROP:
1526 err = process_refprop(cmds, &commands[index], parent);
1527 /* no reference node */
1528 if (err == PICL_NOTNODE) {
1529 err = PICL_SUCCESS; /* discard prop */
1530 /* discard row by setting nproph = 0 */
1531 if (cmds->inside_row_block)
1532 cmds->commands[cmds->current_row]
1533 .rowcmd_nproph = 0;
1534 }
1535 break;
1536 case TOK_REFNODE:
1537 err = process_refnode(&commands[index], parent);
1538 break;
1539 case TOK_TABLE:
1540 cmds->inside_table_block = 1;
1541 err = process_table(&commands[index], parent);
1542 cmds->current_tbl = index;
1543 break;
1544 case TOK_ENDTABLE:
1545 cmds->inside_table_block = 0;
1546 cmds->current_tbl = 0;
1547 break;
1548 case TOK_ROW:
1549 cmds->inside_row_block = 1;
1550 err = process_row(&commands[index]);
1551 cmds->current_row = index;
1552 break;
1553 case TOK_ENDROW:
1554 err = process_endrow(cmds);
1555 cmds->inside_row_block = 0;
1556 cmds->current_row = 0;
1557 break;
1558 case TOK_VERBOSE:
1559 err = process_verbose(cmds, &commands[index]);
1560 break;
1561 default: /* won't reach here */
1562 err = PICL_FAILURE;
1563 break;
1564 }
1565
1566 if ((err != PICL_SUCCESS) && (err != PICL_PROPEXISTS)) {
1567 *last_processed_index = index;
1568 return (err);
1569 }
1570 }
1571
1572 /* reach last command */
1573 *last_processed_index = cmds->count - 1;
1574 return (PICL_SUCCESS);
1575 }
1576
1577 /*
1578 * clean up the commands buffer
1579 */
1580 static void
1581 clean_up(cmdbuf_t *cmds)
1582 {
1583 int cmd_index;
1584
1585 for (cmd_index = 0; cmd_index < cmds->count; cmd_index++) {
1586 switch (cmds->commands[cmd_index].type) {
1587 case TOK_CLASSPATH:
1588 case TOK_NAMEPATH:
1589 free_path(&cmds->commands[cmd_index]);
1590 break;
1591 case TOK_NODE:
1592 free_node(&cmds->commands[cmd_index]);
1593 break;
1594 case TOK_PROP:
1595 free_prop(&cmds->commands[cmd_index]);
1596 break;
1597 case TOK_REFPROP:
1598 free_refprop(&cmds->commands[cmd_index]);
1599 break;
1600 case TOK_REFNODE:
1601 free_refnode(&cmds->commands[cmd_index]);
1602 break;
1603 case TOK_TABLE:
1604 free_table(&cmds->commands[cmd_index]);
1605 break;
1606 case TOK_ENDTABLE:
1607 case TOK_ROW:
1608 case TOK_ENDROW:
1609 case TOK_ENDNODE:
1610 case TOK_VERBOSE:
1611 default:
1612 break;
1613 }
1614 }
1615 if (cmds->commands)
1616 free(cmds->commands);
1617 }
1618
1619 /*
1620 * Parse the configuration file and create nodes/properties under nh
1621 *
1622 * It checks the syntax first. If there is any syntax error,
1623 * it returns 1 and won't continue processing the file to add nodes or props.
1624 *
1625 * If any error happens during command processing, all nodes
1626 * and properties just created will be deleted, i.e. undo
1627 * commands which have been processed. It returns 1.
1628 *
1629 * If success, return 0.
1630 */
1631 int
1632 picld_pluginutil_parse_config_file(picl_nodehdl_t nh, const char *filename)
1633 {
1634 FILE *ifp;
1635 int last_processed_index;
1636 int err;
1637 cmdbuf_t *cmds;
1638
1639 /* set correct locale for use inside pluginutil */
1640 setlocale(LC_ALL, "C");
1641
1642 /*
1643 * Initialize the command buffer
1644 */
1645
1646 cmds = malloc(sizeof (*cmds));
1647 if (cmds == NULL) {
1648 setlocale(LC_ALL, "");
1649 return (1);
1650 }
1651
1652 memset(cmds, 0, sizeof (cmdbuf_t));
1653
1654 cmds->fname = filename;
1655
1656 ifp = fopen(filename, "r");
1657 if (ifp == NULL) {
1658 setlocale(LC_ALL, "");
1659 free(cmds);
1660 return (1);
1661 }
1662
1663 /*
1664 * check the syntax of the configuration file
1665 */
1666 err = check_conffile_syntax(cmds, ifp);
1667
1668 (void) fclose(ifp);
1669
1670 if (err != EC_SYNTAX_OK) {
1671 clean_up(cmds);
1672 free(cmds);
1673 setlocale(LC_ALL, "");
1674 return (1);
1675 }
1676
1677 /*
1678 * Process the commands
1679 */
1680 err = process_commands(cmds, STARTING_INDEX, nh, &last_processed_index);
1681
1682 /*
1683 * If any PICL error, remove the newly created node/prop
1684 * handles from the PICL tree.
1685 */
1686 if (err != PICL_SUCCESS) {
1687 undo_commands(cmds, last_processed_index);
1688 if (cmds->verbose)
1689 verbose_log(LOG_ERR, err_msg[EC_PICL_ERR], filename,
1690 err);
1691 }
1692
1693 clean_up(cmds);
1694 free(cmds);
1695
1696 /* reset the locale */
1697 setlocale(LC_ALL, "");
1698
1699 return ((err == PICL_SUCCESS) ? 0 : 1);
1700 }
unleashed repo fork