1 %{
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
25 */
26
27 /*
28 * This file defines zonecfg(1M)'s grammar.
29 *
30 * Reduction rules that consume TOKENs must invoke claim_token() immediately
31 * before freeing the TOKENs or adding them to data structures (e.g., cmd) that
32 * will be cleaned up when the parser finishes or encounters errors.
33 */
34
35 #include <stdio.h>
36 #include <strings.h>
37
38 #include "zonecfg.h"
39
40 static cmd_t *cmd = NULL; /* Command being processed */
41 static complex_property_ptr_t complex = NULL;
42 static list_property_ptr_t new_list = NULL, tmp_list, last,
43 list[MAX_EQ_PROP_PAIRS];
44 static property_value_t property[MAX_EQ_PROP_PAIRS];
45
46 extern boolean_t newline_terminated;
47 extern int num_prop_vals; /* # of property values */
48
49 /* yacc externals */
50 extern int yydebug;
51 extern void yyerror(char *s);
52
53 /*
54 * This function is used by the simple_prop_val reduction rules to set up
55 * a list_property_ptr_t and adjust the above global variables appropriately.
56 * Note that this function duplicates the specified string and makes
57 * the new list's lp_simple field point to the duplicate. This function does
58 * not free the original string.
59 *
60 * This function returns a pointer to the duplicated string or NULL if an error
61 * occurred. The simple_prop_val reduction rules that invoke this function
62 * should set $$ to the returned pointer.
63 */
64 static char *
65 simple_prop_val_func(const char *str)
66 {
67 char *retstr;
68
69 if ((new_list = alloc_list()) == NULL)
70 return (NULL);
71 if ((retstr = strdup(str)) == NULL) {
72 free_list(new_list);
73 return (NULL);
74 }
75 new_list->lp_simple = retstr;
76 new_list->lp_complex = NULL;
77 new_list->lp_next = NULL;
78 if (list[num_prop_vals] == NULL) {
79 list[num_prop_vals] = new_list;
80 } else {
81 for (tmp_list = list[num_prop_vals]; tmp_list != NULL;
82 tmp_list = tmp_list->lp_next)
83 last = tmp_list;
84 last->lp_next = new_list;
85 }
86 return (retstr);
87 }
88
89 /*
90 * This function is used by the complex_piece reduction rules to set up a
91 * complex_property_prt_t and adjust the above global variables appropriately.
92 * Note that this function duplicates the specified string and makes the new
93 * complex_property_ptr_t's cp_value field point to the duplicate. It also sets
94 * the complex_property_ptr_t's cp_type field to cp_type and its cp_next field
95 * to cp_next. This function does not free the original string.
96 *
97 * This function returns a pointer to the complex_property_t created for the
98 * complex_piece or NULL if an error occurred. The complex_piece reduction
99 * rules that invoke this function should set $$ to the returned pointer.
100 */
101 static complex_property_ptr_t
102 complex_piece_func(int cp_type, const char *str, complex_property_ptr_t cp_next)
103 {
104 complex_property_ptr_t retval;
105
106 if ((retval = alloc_complex()) == NULL)
107 return (NULL);
108 if ((retval->cp_value = strdup(str)) == NULL) {
109 free_complex(retval);
110 return (NULL);
111 }
112 retval->cp_type = cp_type;
113 retval->cp_next = cp_next;
114 complex = retval;
115 return (retval);
116 }
117
118
119 %}
120
121 %union {
122 int ival;
123 char *strval;
124 cmd_t *cmd;
125 complex_property_ptr_t complex;
126 list_property_ptr_t list;
127 }
128
129 %start commands
130
131 %token HELP CREATE EXPORT ADD DELETE REMOVE SELECT SET INFO CANCEL END VERIFY
132 %token COMMIT REVERT EXIT SEMICOLON TOKEN ZONENAME ZONEPATH AUTOBOOT POOL NET
133 %token FS ATTR DEVICE RCTL SPECIAL RAW DIR OPTIONS TYPE ADDRESS PHYSICAL
134 %token IPTYPE HOSTID FS_ALLOWED ALLOWED_ADDRESS
135 %token NAME MATCH PRIV LIMIT ACTION VALUE EQUAL OPEN_SQ_BRACKET CLOSE_SQ_BRACKET
136 %token OPEN_PAREN CLOSE_PAREN COMMA DATASET LIMITPRIV BOOTARGS BRAND PSET PCAP
137 %token MCAP NCPUS IMPORTANCE SHARES MAXLWPS MAXSHMMEM MAXSHMIDS MAXMSGIDS
138 %token MAXSEMIDS LOCKED SWAP SCHED CLEAR DEFROUTER ADMIN USER AUTHS MAXPROCS
139
140 %type <strval> TOKEN EQUAL OPEN_SQ_BRACKET CLOSE_SQ_BRACKET
141 property_value OPEN_PAREN CLOSE_PAREN COMMA simple_prop_val
142 %type <complex> complex_piece complex_prop_val
143 %type <ival> resource_type NET FS DEVICE RCTL ATTR DATASET PSET PCAP MCAP
144 ADMIN
145 %type <ival> property_name SPECIAL RAW DIR OPTIONS TYPE ADDRESS PHYSICAL NAME
146 MATCH ZONENAME ZONEPATH AUTOBOOT POOL LIMITPRIV BOOTARGS VALUE PRIV LIMIT
147 ACTION BRAND SCHED IPTYPE DEFROUTER HOSTID USER AUTHS FS_ALLOWED
148 ALLOWED_ADDRESS
149 %type <cmd> command
150 %type <cmd> add_command ADD
151 %type <cmd> cancel_command CANCEL
152 %type <cmd> commit_command COMMIT
153 %type <cmd> create_command CREATE
154 %type <cmd> delete_command DELETE
155 %type <cmd> end_command END
156 %type <cmd> exit_command EXIT
157 %type <cmd> export_command EXPORT
158 %type <cmd> help_command HELP
159 %type <cmd> info_command INFO
160 %type <cmd> remove_command REMOVE
161 %type <cmd> revert_command REVERT
162 %type <cmd> select_command SELECT
163 %type <cmd> set_command SET
164 %type <cmd> clear_command CLEAR
165 %type <cmd> verify_command VERIFY
166 %type <cmd> terminator
167
168 %%
169
170 /*
171 * NOTE: Each commands reduction rule must invoke assert_no_unclaimed_tokens()
172 * before it completes if it isn't processing an error. This ensures that
173 * reduction rules properly consume TOKENs.
174 */
175 commands: command terminator
176 {
177 if ($1 != NULL) {
178 if ($1->cmd_handler != NULL)
179 $1->cmd_handler($1);
180 free_cmd($1);
181 bzero(list, sizeof (list_property_t));
182 num_prop_vals = 0;
183 }
184 assert_no_unclaimed_tokens();
185 return (0);
186 }
187 | command error terminator
188 {
189 if ($1 != NULL) {
190 free_cmd($1);
191 bzero(list, sizeof (list_property_t));
192 num_prop_vals = 0;
193 }
194 if (YYRECOVERING())
195 YYABORT;
196 yyclearin;
197 yyerrok;
198 }
199 | error terminator
200 {
201 if (YYRECOVERING())
202 YYABORT;
203 yyclearin;
204 yyerrok;
205 }
206 | terminator
207 {
208 assert_no_unclaimed_tokens();
209 return (0);
210 }
211
212 command: add_command
213 | cancel_command
214 | clear_command
215 | create_command
216 | commit_command
217 | delete_command
218 | end_command
219 | exit_command
220 | export_command
221 | help_command
222 | info_command
223 | remove_command
224 | revert_command
225 | select_command
226 | set_command
227 | verify_command
228
229 terminator: '\n' { newline_terminated = B_TRUE; }
230 | ';' { newline_terminated = B_FALSE; }
231
232 add_command: ADD
233 {
234 short_usage(CMD_ADD);
235 (void) fputs("\n", stderr);
236 usage(B_FALSE, HELP_RES_PROPS);
237 YYERROR;
238 }
239 | ADD TOKEN
240 {
241 if (($$ = alloc_cmd()) == NULL)
242 YYERROR;
243 cmd = $$;
244 $$->cmd_handler = &add_func;
245 $$->cmd_argc = 1;
246 $$->cmd_argv[0] = claim_token($2);
247 $$->cmd_argv[1] = NULL;
248 }
249 | ADD resource_type
250 {
251 if (($$ = alloc_cmd()) == NULL)
252 YYERROR;
253 cmd = $$;
254 $$->cmd_handler = &add_func;
255 $$->cmd_argc = 0;
256 $$->cmd_res_type = $2;
257 $$->cmd_prop_nv_pairs = 0;
258 }
259 | ADD property_name property_value
260 {
261 if (($$ = alloc_cmd()) == NULL)
262 YYERROR;
263 cmd = $$;
264 $$->cmd_handler = &add_func;
265 $$->cmd_argc = 0;
266 $$->cmd_prop_nv_pairs = 1;
267 $$->cmd_prop_name[0] = $2;
268 $$->cmd_property_ptr[0] = &property[0];
269 }
270
271 cancel_command: CANCEL
272 {
273 if (($$ = alloc_cmd()) == NULL)
274 YYERROR;
275 cmd = $$;
276 $$->cmd_handler = &cancel_func;
277 $$->cmd_argc = 0;
278 $$->cmd_argv[0] = NULL;
279 }
280 | CANCEL TOKEN
281 {
282 if (($$ = alloc_cmd()) == NULL)
283 YYERROR;
284 cmd = $$;
285 $$->cmd_handler = &cancel_func;
286 $$->cmd_argc = 1;
287 $$->cmd_argv[0] = claim_token($2);
288 $$->cmd_argv[1] = NULL;
289 }
290
291 create_command: CREATE
292 {
293 if (($$ = alloc_cmd()) == NULL)
294 YYERROR;
295 cmd = $$;
296 $$->cmd_handler = &create_func;
297 $$->cmd_argc = 0;
298 $$->cmd_argv[0] = NULL;
299 }
300 | CREATE TOKEN
301 {
302 if (($$ = alloc_cmd()) == NULL)
303 YYERROR;
304 cmd = $$;
305 $$->cmd_handler = &create_func;
306 $$->cmd_argc = 1;
307 $$->cmd_argv[0] = claim_token($2);
308 $$->cmd_argv[1] = NULL;
309 }
310 | CREATE TOKEN TOKEN
311 {
312 if (($$ = alloc_cmd()) == NULL)
313 YYERROR;
314 cmd = $$;
315 $$->cmd_handler = &create_func;
316 $$->cmd_argc = 2;
317 $$->cmd_argv[0] = claim_token($2);
318 $$->cmd_argv[1] = claim_token($3);
319 $$->cmd_argv[2] = NULL;
320 }
321 | CREATE TOKEN TOKEN TOKEN
322 {
323 if (($$ = alloc_cmd()) == NULL)
324 YYERROR;
325 cmd = $$;
326 $$->cmd_handler = &create_func;
327 $$->cmd_argc = 3;
328 $$->cmd_argv[0] = claim_token($2);
329 $$->cmd_argv[1] = claim_token($3);
330 $$->cmd_argv[2] = claim_token($4);
331 $$->cmd_argv[3] = NULL;
332 }
333
334 commit_command: COMMIT
335 {
336 if (($$ = alloc_cmd()) == NULL)
337 YYERROR;
338 cmd = $$;
339 $$->cmd_handler = &commit_func;
340 $$->cmd_argc = 0;
341 $$->cmd_argv[0] = NULL;
342 }
343 | COMMIT TOKEN
344 {
345 if (($$ = alloc_cmd()) == NULL)
346 YYERROR;
347 cmd = $$;
348 $$->cmd_handler = &commit_func;
349 $$->cmd_argc = 1;
350 $$->cmd_argv[0] = claim_token($2);
351 $$->cmd_argv[1] = NULL;
352 }
353
354 delete_command: DELETE
355 {
356 if (($$ = alloc_cmd()) == NULL)
357 YYERROR;
358 cmd = $$;
359 $$->cmd_handler = &delete_func;
360 $$->cmd_argc = 0;
361 $$->cmd_argv[0] = NULL;
362 }
363 | DELETE TOKEN
364 {
365 if (($$ = alloc_cmd()) == NULL)
366 YYERROR;
367 cmd = $$;
368 $$->cmd_handler = &delete_func;
369 $$->cmd_argc = 1;
370 $$->cmd_argv[0] = claim_token($2);
371 $$->cmd_argv[1] = NULL;
372 }
373
374 end_command: END
375 {
376 if (($$ = alloc_cmd()) == NULL)
377 YYERROR;
378 cmd = $$;
379 $$->cmd_handler = &end_func;
380 $$->cmd_argc = 0;
381 $$->cmd_argv[0] = NULL;
382 }
383 | END TOKEN
384 {
385 if (($$ = alloc_cmd()) == NULL)
386 YYERROR;
387 cmd = $$;
388 $$->cmd_handler = &end_func;
389 $$->cmd_argc = 1;
390 $$->cmd_argv[0] = claim_token($2);
391 $$->cmd_argv[1] = NULL;
392 }
393
394 exit_command: EXIT
395 {
396 if (($$ = alloc_cmd()) == NULL)
397 YYERROR;
398 cmd = $$;
399 $$->cmd_handler = &exit_func;
400 $$->cmd_argc = 0;
401 $$->cmd_argv[0] = NULL;
402 }
403 | EXIT TOKEN
404 {
405 if (($$ = alloc_cmd()) == NULL)
406 YYERROR;
407 cmd = $$;
408 $$->cmd_handler = &exit_func;
409 $$->cmd_argc = 1;
410 $$->cmd_argv[0] = claim_token($2);
411 $$->cmd_argv[1] = NULL;
412 }
413
414 export_command: EXPORT
415 {
416 if (($$ = alloc_cmd()) == NULL)
417 YYERROR;
418 cmd = $$;
419 $$->cmd_handler = &export_func;
420 $$->cmd_argc = 0;
421 $$->cmd_argv[0] = NULL;
422 }
423 | EXPORT TOKEN
424 {
425 if (($$ = alloc_cmd()) == NULL)
426 YYERROR;
427 cmd = $$;
428 $$->cmd_handler = &export_func;
429 $$->cmd_argc = 1;
430 $$->cmd_argv[0] = claim_token($2);
431 $$->cmd_argv[1] = NULL;
432 }
433 | EXPORT TOKEN TOKEN
434 {
435 if (($$ = alloc_cmd()) == NULL)
436 YYERROR;
437 cmd = $$;
438 $$->cmd_handler = &export_func;
439 $$->cmd_argc = 2;
440 $$->cmd_argv[0] = claim_token($2);
441 $$->cmd_argv[1] = claim_token($3);
442 $$->cmd_argv[2] = NULL;
443 }
444
445 help_command: HELP
446 {
447 if (($$ = alloc_cmd()) == NULL)
448 YYERROR;
449 cmd = $$;
450 $$->cmd_handler = &help_func;
451 $$->cmd_argc = 0;
452 $$->cmd_argv[0] = NULL;
453 }
454 | HELP TOKEN
455 {
456 if (($$ = alloc_cmd()) == NULL)
457 YYERROR;
458 cmd = $$;
459 $$->cmd_handler = &help_func;
460 $$->cmd_argc = 1;
461 $$->cmd_argv[0] = claim_token($2);
462 $$->cmd_argv[1] = NULL;
463 }
464
465 info_command: INFO
466 {
467 if (($$ = alloc_cmd()) == NULL)
468 YYERROR;
469 cmd = $$;
470 $$->cmd_handler = &info_func;
471 $$->cmd_res_type = RT_UNKNOWN;
472 $$->cmd_prop_nv_pairs = 0;
473 }
474 | INFO TOKEN
475 {
476 short_usage(CMD_INFO);
477 (void) fputs("\n", stderr);
478 usage(B_FALSE, HELP_RES_PROPS);
479 free(claim_token($2));
480 YYERROR;
481 }
482 | INFO resource_type
483 {
484 if (($$ = alloc_cmd()) == NULL)
485 YYERROR;
486 cmd = $$;
487 $$->cmd_handler = &info_func;
488 $$->cmd_res_type = $2;
489 $$->cmd_prop_nv_pairs = 0;
490 }
491 | INFO ZONENAME
492 {
493 if (($$ = alloc_cmd()) == NULL)
494 YYERROR;
495 cmd = $$;
496 $$->cmd_handler = &info_func;
497 $$->cmd_res_type = RT_ZONENAME;
498 $$->cmd_prop_nv_pairs = 0;
499 }
500 | INFO ZONEPATH
501 {
502 if (($$ = alloc_cmd()) == NULL)
503 YYERROR;
504 cmd = $$;
505 $$->cmd_handler = &info_func;
506 $$->cmd_res_type = RT_ZONEPATH;
507 $$->cmd_prop_nv_pairs = 0;
508 }
509 | INFO BRAND
510 {
511 if (($$ = alloc_cmd()) == NULL)
512 YYERROR;
513 cmd = $$;
514 $$->cmd_handler = &info_func;
515 $$->cmd_res_type = RT_BRAND;
516 $$->cmd_prop_nv_pairs = 0;
517 }
518 | INFO AUTOBOOT
519 {
520 if (($$ = alloc_cmd()) == NULL)
521 YYERROR;
522 cmd = $$;
523 $$->cmd_handler = &info_func;
524 $$->cmd_res_type = RT_AUTOBOOT;
525 $$->cmd_prop_nv_pairs = 0;
526 }
527 | INFO IPTYPE
528 {
529 if (($$ = alloc_cmd()) == NULL)
530 YYERROR;
531 cmd = $$;
532 $$->cmd_handler = &info_func;
533 $$->cmd_res_type = RT_IPTYPE;
534 $$->cmd_prop_nv_pairs = 0;
535 }
536 | INFO POOL
537 {
538 if (($$ = alloc_cmd()) == NULL)
539 YYERROR;
540 cmd = $$;
541 $$->cmd_handler = &info_func;
542 $$->cmd_res_type = RT_POOL;
543 $$->cmd_prop_nv_pairs = 0;
544 }
545 | INFO LIMITPRIV
546 {
547 if (($$ = alloc_cmd()) == NULL)
548 YYERROR;
549 cmd = $$;
550 $$->cmd_handler = &info_func;
551 $$->cmd_res_type = RT_LIMITPRIV;
552 $$->cmd_prop_nv_pairs = 0;
553 }
554 | INFO BOOTARGS
555 {
556 if (($$ = alloc_cmd()) == NULL)
557 YYERROR;
558 cmd = $$;
559 $$->cmd_handler = &info_func;
560 $$->cmd_res_type = RT_BOOTARGS;
561 $$->cmd_prop_nv_pairs = 0;
562 }
563 | INFO SCHED
564 {
565 if (($$ = alloc_cmd()) == NULL)
566 YYERROR;
567 cmd = $$;
568 $$->cmd_handler = &info_func;
569 $$->cmd_res_type = RT_SCHED;
570 $$->cmd_prop_nv_pairs = 0;
571 }
572 | INFO SHARES
573 {
574 if (($$ = alloc_cmd()) == NULL)
575 YYERROR;
576 cmd = $$;
577 $$->cmd_handler = &info_func;
578 $$->cmd_res_type = RT_SHARES;
579 $$->cmd_prop_nv_pairs = 0;
580 }
581 | INFO MAXLWPS
582 {
583 if (($$ = alloc_cmd()) == NULL)
584 YYERROR;
585 cmd = $$;
586 $$->cmd_handler = &info_func;
587 $$->cmd_res_type = RT_MAXLWPS;
588 $$->cmd_prop_nv_pairs = 0;
589 }
590 | INFO MAXPROCS
591 {
592 if (($$ = alloc_cmd()) == NULL)
593 YYERROR;
594 cmd = $$;
595 $$->cmd_handler = &info_func;
596 $$->cmd_res_type = RT_MAXPROCS;
597 $$->cmd_prop_nv_pairs = 0;
598 }
599 | INFO MAXSHMMEM
600 {
601 if (($$ = alloc_cmd()) == NULL)
602 YYERROR;
603 cmd = $$;
604 $$->cmd_handler = &info_func;
605 $$->cmd_res_type = RT_MAXSHMMEM;
606 $$->cmd_prop_nv_pairs = 0;
607 }
608 | INFO MAXSHMIDS
609 {
610 if (($$ = alloc_cmd()) == NULL)
611 YYERROR;
612 cmd = $$;
613 $$->cmd_handler = &info_func;
614 $$->cmd_res_type = RT_MAXSHMIDS;
615 $$->cmd_prop_nv_pairs = 0;
616 }
617 | INFO MAXMSGIDS
618 {
619 if (($$ = alloc_cmd()) == NULL)
620 YYERROR;
621 cmd = $$;
622 $$->cmd_handler = &info_func;
623 $$->cmd_res_type = RT_MAXMSGIDS;
624 $$->cmd_prop_nv_pairs = 0;
625 }
626 | INFO MAXSEMIDS
627 {
628 if (($$ = alloc_cmd()) == NULL)
629 YYERROR;
630 cmd = $$;
631 $$->cmd_handler = &info_func;
632 $$->cmd_res_type = RT_MAXSEMIDS;
633 $$->cmd_prop_nv_pairs = 0;
634 }
635 | INFO HOSTID
636 {
637 if (($$ = alloc_cmd()) == NULL)
638 YYERROR;
639 cmd = $$;
640 $$->cmd_handler = &info_func;
641 $$->cmd_res_type = RT_HOSTID;
642 $$->cmd_prop_nv_pairs = 0;
643 }
644 | INFO FS_ALLOWED
645 {
646 if (($$ = alloc_cmd()) == NULL)
647 YYERROR;
648 cmd = $$;
649 $$->cmd_handler = &info_func;
650 $$->cmd_res_type = RT_FS_ALLOWED;
651 $$->cmd_prop_nv_pairs = 0;
652 }
653 | INFO resource_type property_name EQUAL property_value
654 {
655 if (($$ = alloc_cmd()) == NULL)
656 YYERROR;
657 cmd = $$;
658 $$->cmd_handler = &info_func;
659 $$->cmd_res_type = $2;
660 $$->cmd_prop_nv_pairs = 1;
661 $$->cmd_prop_name[0] = $3;
662 $$->cmd_property_ptr[0] = &property[0];
663 }
664 | INFO resource_type property_name EQUAL property_value property_name EQUAL property_value
665 {
666 if (($$ = alloc_cmd()) == NULL)
667 YYERROR;
668 cmd = $$;
669 $$->cmd_handler = &info_func;
670 $$->cmd_res_type = $2;
671 $$->cmd_prop_nv_pairs = 2;
672 $$->cmd_prop_name[0] = $3;
673 $$->cmd_property_ptr[0] = &property[0];
674 $$->cmd_prop_name[1] = $6;
675 $$->cmd_property_ptr[1] = &property[1];
676 }
677 | INFO resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value
678 {
679 if (($$ = alloc_cmd()) == NULL)
680 YYERROR;
681 cmd = $$;
682 $$->cmd_handler = &info_func;
683 $$->cmd_res_type = $2;
684 $$->cmd_prop_nv_pairs = 3;
685 $$->cmd_prop_name[0] = $3;
686 $$->cmd_property_ptr[0] = &property[0];
687 $$->cmd_prop_name[1] = $6;
688 $$->cmd_property_ptr[1] = &property[1];
689 $$->cmd_prop_name[2] = $9;
690 $$->cmd_property_ptr[2] = &property[2];
691 }
692
693 remove_command: REMOVE
694 {
695 short_usage(CMD_REMOVE);
696 (void) fputs("\n", stderr);
697 usage(B_FALSE, HELP_RES_PROPS);
698 YYERROR;
699 }
700 | REMOVE TOKEN
701 {
702 short_usage(CMD_REMOVE);
703 (void) fputs("\n", stderr);
704 usage(B_FALSE, HELP_RES_PROPS);
705 free(claim_token($2));
706 YYERROR;
707 }
708 | REMOVE resource_type
709 {
710 if (($$ = alloc_cmd()) == NULL)
711 YYERROR;
712 cmd = $$;
713 $$->cmd_handler = &remove_func;
714 $$->cmd_res_type = $2;
715 }
716 | REMOVE TOKEN resource_type
717 {
718 if (($$ = alloc_cmd()) == NULL)
719 YYERROR;
720 cmd = $$;
721 $$->cmd_handler = &remove_func;
722 $$->cmd_res_type = $3;
723 $$->cmd_argc = 1;
724 $$->cmd_argv[0] = claim_token($2);
725 $$->cmd_argv[1] = NULL;
726 }
727 | REMOVE property_name property_value
728 {
729 if (($$ = alloc_cmd()) == NULL)
730 YYERROR;
731 cmd = $$;
732 $$->cmd_handler = &remove_func;
733 $$->cmd_prop_nv_pairs = 1;
734 $$->cmd_prop_name[0] = $2;
735 $$->cmd_property_ptr[0] = &property[0];
736 }
737 | REMOVE resource_type property_name EQUAL property_value
738 {
739 if (($$ = alloc_cmd()) == NULL)
740 YYERROR;
741 cmd = $$;
742 $$->cmd_handler = &remove_func;
743 $$->cmd_res_type = $2;
744 $$->cmd_prop_nv_pairs = 1;
745 $$->cmd_prop_name[0] = $3;
746 $$->cmd_property_ptr[0] = &property[0];
747 }
748 | REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value
749 {
750 if (($$ = alloc_cmd()) == NULL)
751 YYERROR;
752 cmd = $$;
753 $$->cmd_handler = &remove_func;
754 $$->cmd_res_type = $2;
755 $$->cmd_prop_nv_pairs = 2;
756 $$->cmd_prop_name[0] = $3;
757 $$->cmd_property_ptr[0] = &property[0];
758 $$->cmd_prop_name[1] = $6;
759 $$->cmd_property_ptr[1] = &property[1];
760 }
761 | REMOVE resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value
762 {
763 if (($$ = alloc_cmd()) == NULL)
764 YYERROR;
765 cmd = $$;
766 $$->cmd_handler = &remove_func;
767 $$->cmd_res_type = $2;
768 $$->cmd_prop_nv_pairs = 3;
769 $$->cmd_prop_name[0] = $3;
770 $$->cmd_property_ptr[0] = &property[0];
771 $$->cmd_prop_name[1] = $6;
772 $$->cmd_property_ptr[1] = &property[1];
773 $$->cmd_prop_name[2] = $9;
774 $$->cmd_property_ptr[2] = &property[2];
775 }
776
777 revert_command: REVERT
778 {
779 if (($$ = alloc_cmd()) == NULL)
780 YYERROR;
781 cmd = $$;
782 $$->cmd_handler = &revert_func;
783 $$->cmd_argc = 0;
784 $$->cmd_argv[0] = NULL;
785 }
786 | REVERT TOKEN
787 {
788 if (($$ = alloc_cmd()) == NULL)
789 YYERROR;
790 cmd = $$;
791 $$->cmd_handler = &revert_func;
792 $$->cmd_argc = 1;
793 $$->cmd_argv[0] = claim_token($2);
794 $$->cmd_argv[1] = NULL;
795 }
796
797 select_command: SELECT
798 {
799 short_usage(CMD_SELECT);
800 (void) fputs("\n", stderr);
801 usage(B_FALSE, HELP_RES_PROPS);
802 YYERROR;
803 }
804 | SELECT PSET
805 {
806 if (($$ = alloc_cmd()) == NULL)
807 YYERROR;
808 cmd = $$;
809 $$->cmd_handler = &select_func;
810 $$->cmd_res_type = RT_DCPU;
811 }
812 | SELECT PCAP
813 {
814 if (($$ = alloc_cmd()) == NULL)
815 YYERROR;
816 cmd = $$;
817 $$->cmd_handler = &select_func;
818 $$->cmd_res_type = RT_PCAP;
819 }
820 | SELECT MCAP
821 {
822 if (($$ = alloc_cmd()) == NULL)
823 YYERROR;
824 cmd = $$;
825 $$->cmd_handler = &select_func;
826 $$->cmd_res_type = RT_MCAP;
827 }
828 | SELECT resource_type
829 {
830 short_usage(CMD_SELECT);
831 YYERROR;
832 }
833 | SELECT resource_type property_name EQUAL property_value
834 {
835 if (($$ = alloc_cmd()) == NULL)
836 YYERROR;
837 cmd = $$;
838 $$->cmd_handler = &select_func;
839 $$->cmd_res_type = $2;
840 $$->cmd_prop_nv_pairs = 1;
841 $$->cmd_prop_name[0] = $3;
842 $$->cmd_property_ptr[0] = &property[0];
843 }
844 | SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value
845 {
846 if (($$ = alloc_cmd()) == NULL)
847 YYERROR;
848 cmd = $$;
849 $$->cmd_handler = &select_func;
850 $$->cmd_res_type = $2;
851 $$->cmd_prop_nv_pairs = 2;
852 $$->cmd_prop_name[0] = $3;
853 $$->cmd_property_ptr[0] = &property[0];
854 $$->cmd_prop_name[1] = $6;
855 $$->cmd_property_ptr[1] = &property[1];
856 }
857 | SELECT resource_type property_name EQUAL property_value property_name EQUAL property_value property_name EQUAL property_value
858 {
859 if (($$ = alloc_cmd()) == NULL)
860 YYERROR;
861 cmd = $$;
862 $$->cmd_handler = &select_func;
863 $$->cmd_res_type = $2;
864 $$->cmd_prop_nv_pairs = 3;
865 $$->cmd_prop_name[0] = $3;
866 $$->cmd_property_ptr[0] = &property[0];
867 $$->cmd_prop_name[1] = $6;
868 $$->cmd_property_ptr[1] = &property[1];
869 $$->cmd_prop_name[2] = $9;
870 $$->cmd_property_ptr[2] = &property[2];
871 }
872
873 set_command: SET
874 {
875 short_usage(CMD_SET);
876 (void) fputs("\n", stderr);
877 usage(B_FALSE, HELP_PROPS);
878 YYERROR;
879 }
880 | SET property_name EQUAL OPEN_SQ_BRACKET CLOSE_SQ_BRACKET
881 {
882 if (($$ = alloc_cmd()) == NULL)
883 YYERROR;
884 cmd = $$;
885 $$->cmd_handler = &set_func;
886 $$->cmd_prop_nv_pairs = 0;
887 $$->cmd_prop_name[0] = $2;
888 property[0].pv_type = PROP_VAL_LIST;
889 property[0].pv_list = NULL;
890 $$->cmd_property_ptr[0] = &property[0];
891 }
892 | SET property_name EQUAL property_value
893 {
894 if (($$ = alloc_cmd()) == NULL)
895 YYERROR;
896 cmd = $$;
897 $$->cmd_handler = &set_func;
898 $$->cmd_prop_nv_pairs = 1;
899 $$->cmd_prop_name[0] = $2;
900 $$->cmd_property_ptr[0] = &property[0];
901 }
902 | SET TOKEN ZONEPATH EQUAL property_value
903 {
904 if (($$ = alloc_cmd()) == NULL)
905 YYERROR;
906 cmd = $$;
907 $$->cmd_argc = 1;
908 $$->cmd_argv[0] = claim_token($2);
909 $$->cmd_argv[1] = NULL;
910 $$->cmd_handler = &set_func;
911 $$->cmd_prop_nv_pairs = 1;
912 $$->cmd_prop_name[0] = PT_ZONEPATH;
913 $$->cmd_property_ptr[0] = &property[0];
914 }
915
916 clear_command: CLEAR
917 {
918 short_usage(CMD_CLEAR);
919 (void) fputs("\n", stderr);
920 usage(B_FALSE, HELP_PROPS);
921 YYERROR;
922 }
923 | CLEAR property_name
924 {
925 if (($$ = alloc_cmd()) == NULL)
926 YYERROR;
927 cmd = $$;
928 $$->cmd_handler = &clear_func;
929 $$->cmd_res_type = $2;
930 }
931
932 verify_command: VERIFY
933 {
934 if (($$ = alloc_cmd()) == NULL)
935 YYERROR;
936 cmd = $$;
937 $$->cmd_handler = &verify_func;
938 $$->cmd_argc = 0;
939 $$->cmd_argv[0] = NULL;
940 }
941 | VERIFY TOKEN
942 {
943 if (($$ = alloc_cmd()) == NULL)
944 YYERROR;
945 cmd = $$;
946 $$->cmd_handler = &verify_func;
947 $$->cmd_argc = 1;
948 $$->cmd_argv[0] = claim_token($2);
949 $$->cmd_argv[1] = NULL;
950 }
951
952 resource_type: NET { $$ = RT_NET; }
953 | FS { $$ = RT_FS; }
954 | DEVICE { $$ = RT_DEVICE; }
955 | RCTL { $$ = RT_RCTL; }
956 | ATTR { $$ = RT_ATTR; }
957 | DATASET { $$ = RT_DATASET; }
958 | PSET { $$ = RT_DCPU; }
959 | PCAP { $$ = RT_PCAP; }
960 | MCAP { $$ = RT_MCAP; }
961 | ADMIN { $$ = RT_ADMIN; }
962
963 property_name: SPECIAL { $$ = PT_SPECIAL; }
964 | RAW { $$ = PT_RAW; }
965 | DIR { $$ = PT_DIR; }
966 | TYPE { $$ = PT_TYPE; }
967 | OPTIONS { $$ = PT_OPTIONS; }
968 | ZONENAME { $$ = PT_ZONENAME; }
969 | ZONEPATH { $$ = PT_ZONEPATH; }
970 | AUTOBOOT { $$ = PT_AUTOBOOT; }
971 | IPTYPE { $$ = PT_IPTYPE; }
972 | POOL { $$ = PT_POOL; }
973 | LIMITPRIV { $$ = PT_LIMITPRIV; }
974 | BOOTARGS { $$ = PT_BOOTARGS; }
975 | ADDRESS { $$ = PT_ADDRESS; }
976 | ALLOWED_ADDRESS { $$ = PT_ALLOWED_ADDRESS; }
977 | PHYSICAL { $$ = PT_PHYSICAL; }
978 | DEFROUTER { $$ = PT_DEFROUTER; }
979 | NAME { $$ = PT_NAME; }
980 | VALUE { $$ = PT_VALUE; }
981 | MATCH { $$ = PT_MATCH; }
982 | PRIV { $$ = PT_PRIV; }
983 | LIMIT { $$ = PT_LIMIT; }
984 | ACTION { $$ = PT_ACTION; }
985 | BRAND { $$ = PT_BRAND; }
986 | NCPUS { $$ = PT_NCPUS; }
987 | LOCKED { $$ = PT_LOCKED; }
988 | SWAP { $$ = PT_SWAP; }
989 | IMPORTANCE { $$ = PT_IMPORTANCE; }
990 | SHARES { $$ = PT_SHARES; }
991 | MAXLWPS { $$ = PT_MAXLWPS; }
992 | MAXPROCS { $$ = PT_MAXPROCS; }
993 | MAXSHMMEM { $$ = PT_MAXSHMMEM; }
994 | MAXSHMIDS { $$ = PT_MAXSHMIDS; }
995 | MAXMSGIDS { $$ = PT_MAXMSGIDS; }
996 | MAXSEMIDS { $$ = PT_MAXSEMIDS; }
997 | SCHED { $$ = PT_SCHED; }
998 | HOSTID { $$ = PT_HOSTID; }
999 | USER { $$ = PT_USER; }
1000 | AUTHS { $$ = PT_AUTHS; }
1001 | FS_ALLOWED { $$ = PT_FS_ALLOWED; }
1002
1003 /*
1004 * The grammar builds data structures from the bottom up. Thus various
1005 * strings are lexed into TOKENs or commands or resource or property values.
1006 * Below is where the resource and property values are built up into more
1007 * complex data structures.
1008 *
1009 * There are three kinds of properties: simple (single valued), complex
1010 * (one or more name=value pairs) and list (concatenation of one or more
1011 * simple or complex properties).
1012 *
1013 * So the property structure has a type which is one of these, and the
1014 * corresponding _simple, _complex or _list is set to the corresponding
1015 * lower-level data structure.
1016 */
1017
1018 property_value: simple_prop_val
1019 {
1020 property[num_prop_vals].pv_type = PROP_VAL_SIMPLE;
1021 property[num_prop_vals].pv_simple = $1;
1022 if (list[num_prop_vals] != NULL) {
1023 free_outer_list(list[num_prop_vals]);
1024 list[num_prop_vals] = NULL;
1025 }
1026 num_prop_vals++;
1027 }
1028 | complex_prop_val
1029 {
1030 property[num_prop_vals].pv_type = PROP_VAL_COMPLEX;
1031 property[num_prop_vals].pv_complex = complex;
1032 if (list[num_prop_vals] != NULL) {
1033 free_outer_list(list[num_prop_vals]);
1034 list[num_prop_vals] = NULL;
1035 }
1036 num_prop_vals++;
1037 }
1038 | list_prop_val
1039 {
1040 property[num_prop_vals].pv_type = PROP_VAL_LIST;
1041 property[num_prop_vals].pv_list = list[num_prop_vals];
1042 num_prop_vals++;
1043 }
1044
1045 /*
1046 * One level lower, lists are made up of simple or complex values, so
1047 * simple_prop_val and complex_prop_val fill in a list structure and
1048 * insert it into the linked list which is built up. And because
1049 * complex properties can have multiple name=value pairs, we keep
1050 * track of them in another linked list.
1051 *
1052 * The complex and list structures for the linked lists are allocated
1053 * below, and freed by recursive functions which are ultimately called
1054 * by free_cmd(), which is called from the top-most "commands" part of
1055 * the grammar.
1056 *
1057 * NOTE: simple_prop_val and complex_piece need reduction rules for
1058 * property_name and resource_type so that the parser will accept property names
1059 * and resource type names as property values.
1060 */
1061
1062 simple_prop_val: TOKEN
1063 {
1064 $$ = simple_prop_val_func($1);
1065 free(claim_token($1));
1066 if ($$ == NULL)
1067 YYERROR;
1068 }
1069 | resource_type
1070 {
1071 if (($$ = simple_prop_val_func(res_types[$1])) == NULL)
1072 YYERROR;
1073 }
1074 | property_name
1075 {
1076 if (($$ = simple_prop_val_func(prop_types[$1])) == NULL)
1077 YYERROR;
1078 }
1079
1080 complex_prop_val: OPEN_PAREN complex_piece CLOSE_PAREN
1081 {
1082 if ((new_list = alloc_list()) == NULL)
1083 YYERROR;
1084 new_list->lp_simple = NULL;
1085 new_list->lp_complex = complex;
1086 new_list->lp_next = NULL;
1087 if (list[num_prop_vals] == NULL) {
1088 list[num_prop_vals] = new_list;
1089 } else {
1090 for (tmp_list = list[num_prop_vals]; tmp_list != NULL;
1091 tmp_list = tmp_list->lp_next)
1092 last = tmp_list;
1093 last->lp_next = new_list;
1094 }
1095 }
1096
1097 complex_piece: property_name EQUAL TOKEN
1098 {
1099 $$ = complex_piece_func($1, $3, NULL);
1100 free(claim_token($3));
1101 if ($$ == NULL)
1102 YYERROR;
1103 }
1104 | property_name EQUAL resource_type
1105 {
1106 if (($$ = complex_piece_func($1, res_types[$3], NULL)) == NULL)
1107 YYERROR;
1108 }
1109 | property_name EQUAL property_name
1110 {
1111 if (($$ = complex_piece_func($1, prop_types[$3], NULL)) == NULL)
1112 YYERROR;
1113 }
1114 | property_name EQUAL TOKEN COMMA complex_piece
1115 {
1116 $$ = complex_piece_func($1, $3, complex);
1117 free(claim_token($3));
1118 if ($$ == NULL)
1119 YYERROR;
1120 }
1121 | property_name EQUAL resource_type COMMA complex_piece
1122 {
1123 if (($$ = complex_piece_func($1, res_types[$3], complex)) ==
1124 NULL)
1125 YYERROR;
1126 }
1127 | property_name EQUAL property_name COMMA complex_piece
1128 {
1129 if (($$ = complex_piece_func($1, prop_types[$3], complex)) ==
1130 NULL)
1131 YYERROR;
1132 }
1133
1134 list_piece: simple_prop_val
1135 | complex_prop_val
1136 | simple_prop_val COMMA list_piece
1137 | complex_prop_val COMMA list_piece
1138
1139 list_prop_val: OPEN_SQ_BRACKET list_piece CLOSE_SQ_BRACKET
1140 %%