xref: /illumos-gate/usr/src/cmd/zonecfg/zonecfg_lex.l (revision d2a70789)
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 #include <assert.h>
28 #include <string.h>
29 #include <libintl.h>
30 #include "zonecfg.h"
31 #include "zonecfg_grammar.tab.h"
32 
33 /*
34  * This constant defines the number of entries added to unclaimed_tokens[]
35  * when it runs out of space.
36  */
37 #define	UNCLAIMED_TOKENS_BUFFER_GROWTH	4
38 
39 /*
40  * Invariants:
41  *
42  *	unclaimed_tokens == NULL IFF unclaimed_tokens_size == 0
43  *	unclaimed_tokens_size == 0 IFF num_unclaimed_tokens == 0
44  */
45 static char **unclaimed_tokens;		/* TOKENs produced by Lex (see below) */
46 					/* but not claimed by YACC reduction */
47 					/* rules */
48 static unsigned int unclaimed_tokens_size;	/* size of unclaimed_tokens */
49 static unsigned int num_unclaimed_tokens;	/* number of unclaimed TOKENs */
50 
51 int lex_lineno = 1;	/* line number for error reporting */
52 static int state = INITIAL;
53 extern boolean_t cmd_file_mode;
54 extern boolean_t saw_error;
55 extern void yyerror(char *s);
56 
57 static char *create_token(char *s);
58 %}
59 
60 %a 7000
61 %p 5000
62 %e 2000
63 %n 1000
64 
65 %{
66 /*
67  * The three states below are for tokens, lists and complex property values.
68  * Note that simple property values are a subset of tokens.
69  */
70 %}
71 %s TSTATE
72 %s LSTATE
73 %s CSTATE
74 %%
75 
76 <INITIAL>"#"[^\n]*	{ }
77 
78 <INITIAL>add	{
79 			BEGIN TSTATE;
80 			state = TSTATE;
81 			return ADD;
82 		}
83 
84 <INITIAL>cancel	{
85 			BEGIN TSTATE;
86 			state = TSTATE;
87 			return CANCEL;
88 		}
89 
90 <INITIAL>commit	{
91 			BEGIN TSTATE;
92 			state = TSTATE;
93 			return COMMIT;
94 		}
95 
96 <INITIAL>create	{
97 			BEGIN TSTATE;
98 			state = TSTATE;
99 			return CREATE;
100 		}
101 
102 <INITIAL>delete {
103 			BEGIN TSTATE;
104 			state = TSTATE;
105 			return DELETE;
106 		}
107 
108 <INITIAL>end	{
109 			BEGIN TSTATE;
110 			state = TSTATE;
111 			return END;
112 		}
113 
114 <INITIAL>exit	{
115 			BEGIN TSTATE;
116 			state = TSTATE;
117 			return EXIT;
118 		}
119 
120 <INITIAL>export	{
121 			BEGIN TSTATE;
122 			state = TSTATE;
123 			return EXPORT;
124 		}
125 
126 <INITIAL>"?"|help {
127 			BEGIN TSTATE;
128 			state = TSTATE;
129 			return HELP;
130 		}
131 
132 <INITIAL>info	{
133 			BEGIN TSTATE;
134 			state = TSTATE;
135 			return INFO;
136 		}
137 
138 <INITIAL>remove	{
139 			BEGIN TSTATE;
140 			state = TSTATE;
141 			return REMOVE;
142 		}
143 
144 <INITIAL>revert	{
145 			BEGIN TSTATE;
146 			state = TSTATE;
147 			return REVERT;
148 		}
149 
150 <INITIAL>select {
151 			BEGIN TSTATE;
152 			state = TSTATE;
153 			return SELECT;
154 		}
155 
156 <INITIAL>set {
157 			BEGIN TSTATE;
158 			state = TSTATE;
159 			return SET;
160 		}
161 
162 <INITIAL>clear {
163 			BEGIN TSTATE;
164 			state = TSTATE;
165 			return CLEAR;
166 		}
167 
168 <INITIAL>verify	{
169 			BEGIN TSTATE;
170 			state = TSTATE;
171 			return VERIFY;
172 		}
173 
174 <TSTATE>net	{ return NET; }
175 
176 <TSTATE>fs	{ return FS; }
177 
178 <TSTATE>device	{ return DEVICE; }
179 
180 <TSTATE>rctl	{ return RCTL; }
181 
182 <TSTATE>attr	{ return ATTR; }
183 
184 <TSTATE>admin	{ return ADMIN; }
185 
186 <TSTATE>security-flags { return SECFLAGS; }
187 
188 <TSTATE>zonename	{ return ZONENAME; }
189 <CSTATE>zonename	{ return ZONENAME; }
190 
191 <TSTATE>dataset	{ return DATASET; }
192 
193 <TSTATE>dedicated-cpu	{ return PSET; }
194 
195 <TSTATE>capped-cpu	{ return PCAP; }
196 
197 <TSTATE>capped-memory	{ return MCAP; }
198 
199 <TSTATE>zonepath	{ return ZONEPATH; }
200 <CSTATE>zonepath	{ return ZONEPATH; }
201 
202 <TSTATE>brand	{ return BRAND; }
203 <CSTATE>brand	{ return BRAND; }
204 
205 <TSTATE>autoboot	{ return AUTOBOOT; }
206 <CSTATE>autoboot	{ return AUTOBOOT; }
207 
208 <TSTATE>ip-type		{ return IPTYPE; }
209 <CSTATE>ip-type		{ return IPTYPE; }
210 
211 <TSTATE>pool	{ return POOL; }
212 <CSTATE>pool	{ return POOL; }
213 
214 <TSTATE>limitpriv	{ return LIMITPRIV; }
215 <CSTATE>limitpriv	{ return LIMITPRIV; }
216 
217 <TSTATE>bootargs	{ return BOOTARGS; }
218 <CSTATE>bootargs	{ return BOOTARGS; }
219 
220 <TSTATE>type	{ return TYPE; }
221 <CSTATE>type	{ return TYPE; }
222 
223 <TSTATE>value	{ return VALUE; }
224 <CSTATE>value	{ return VALUE; }
225 
226 <TSTATE>options	{ return OPTIONS; }
227 <CSTATE>options	{ return OPTIONS; }
228 
229 <TSTATE>allowed-address { return ALLOWED_ADDRESS; }
230 <CSTATE>allowed-address { return ALLOWED_ADDRESS; }
231 
232 <TSTATE>address	{ return ADDRESS; }
233 <CSTATE>address	{ return ADDRESS; }
234 
235 <TSTATE>physical	{ return PHYSICAL; }
236 <CSTATE>physical	{ return PHYSICAL; }
237 
238 <TSTATE>defrouter	{ return DEFROUTER; }
239 <CSTATE>defrouter	{ return DEFROUTER; }
240 
241 <TSTATE>dir	{ return DIR; }
242 <CSTATE>dir	{ return DIR; }
243 
244 <TSTATE>special	{ return SPECIAL; }
245 <CSTATE>special	{ return SPECIAL; }
246 
247 <TSTATE>raw	{ return RAW; }
248 <CSTATE>raw	{ return RAW; }
249 
250 <TSTATE>name	{ return NAME; }
251 <CSTATE>name	{ return NAME; }
252 
253 <TSTATE>match	{ return MATCH; }
254 <CSTATE>match	{ return MATCH; }
255 
256 <TSTATE>priv	{ return PRIV; }
257 <CSTATE>priv	{ return PRIV; }
258 
259 <TSTATE>limit	{ return LIMIT; }
260 <CSTATE>limit	{ return LIMIT; }
261 
262 <TSTATE>action	{ return ACTION; }
263 <CSTATE>action	{ return ACTION; }
264 
265 <TSTATE>ncpus	{ return NCPUS; }
266 <CSTATE>ncpus	{ return NCPUS; }
267 
268 <TSTATE>locked	{ return LOCKED; }
269 <CSTATE>locked	{ return LOCKED; }
270 
271 <TSTATE>swap	{ return SWAP; }
272 <CSTATE>swap	{ return SWAP; }
273 
274 <TSTATE>importance	{ return IMPORTANCE; }
275 <CSTATE>importance	{ return IMPORTANCE; }
276 
277 <TSTATE>cpu-shares	{ return SHARES; }
278 <CSTATE>cpu-shares	{ return SHARES; }
279 
280 <TSTATE>max-lwps	{ return MAXLWPS; }
281 <CSTATE>max-lwps	{ return MAXLWPS; }
282 
283 <TSTATE>max-processes	{ return MAXPROCS; }
284 <CSTATE>max-processes	{ return MAXPROCS; }
285 
286 <TSTATE>max-shm-memory	{ return MAXSHMMEM; }
287 <CSTATE>max-shm-memory	{ return MAXSHMMEM; }
288 
289 <TSTATE>max-shm-ids	{ return MAXSHMIDS; }
290 <CSTATE>max-shm-ids	{ return MAXSHMIDS; }
291 
292 <TSTATE>max-msg-ids	{ return MAXMSGIDS; }
293 <CSTATE>max-msg-ids	{ return MAXMSGIDS; }
294 
295 <TSTATE>max-sem-ids	{ return MAXSEMIDS; }
296 <CSTATE>max-sem-ids	{ return MAXSEMIDS; }
297 
298 <TSTATE>scheduling-class	{ return SCHED; }
299 <CSTATE>scheduling-class	{ return SCHED; }
300 
301 <TSTATE>hostid		{ return HOSTID; }
302 <CSTATE>hostid		{ return HOSTID; }
303 
304 <TSTATE>user	{ return USER; }
305 <CSTATE>user	{ return USER; }
306 
307 <TSTATE>auths	{ return AUTHS; }
308 <CSTATE>auths	{ return AUTHS; }
309 
310 <TSTATE>fs-allowed	{ return FS_ALLOWED; }
311 <CSTATE>fs-allowed	{ return FS_ALLOWED; }
312 
313 <TSTATE>default { return DEFAULT; }
314 <CSTATE>default { return DEFAULT; }
315 
316 <TSTATE>lower { return LOWER; }
317 <CSTATE>lower { return LOWER; }
318 
319 <TSTATE>upper { return UPPER; }
320 <CSTATE>upper { return UPPER; }
321 
322 <TSTATE>=	{ return EQUAL; }
323 <LSTATE>=	{ return EQUAL; }
324 <CSTATE>=	{ return EQUAL; }
325 
326 <TSTATE>"["	{
327 			BEGIN LSTATE;
328 			state = LSTATE;
329 			return OPEN_SQ_BRACKET;
330 		}
331 
332 <LSTATE>"]"	{
333 			BEGIN TSTATE;
334 			state = TSTATE;
335 			return CLOSE_SQ_BRACKET;
336 		}
337 
338 <TSTATE>"("	{
339 			BEGIN CSTATE;
340 			return OPEN_PAREN;
341 		}
342 
343 <LSTATE>"("	{
344 			BEGIN CSTATE;
345 			return OPEN_PAREN;
346 		}
347 
348 <CSTATE>")"	{
349 			BEGIN state;
350 			return CLOSE_PAREN;
351 		}
352 
353 <LSTATE>","	{ return COMMA; }
354 <CSTATE>","	{ return COMMA; }
355 
356 <TSTATE>[^ \t\n\";=\[\]\(\)]+	{
357 			yylval.strval = create_token(yytext);
358 			return TOKEN;
359 		}
360 
361 <LSTATE>[^ \t\n\",;=\[\]\(\)]+	{
362 			yylval.strval = create_token(yytext);
363 			return TOKEN;
364 		}
365 
366 <CSTATE>[^ \t\n\",;=\(\)]+	{
367 			yylval.strval = create_token(yytext);
368 			return TOKEN;
369 		}
370 
371 <TSTATE>\"[^\"\n]*[\"\n] {
372 			yylval.strval = create_token(yytext + 1);
373 			if (yylval.strval[yyleng - 2] == '"')
374 				yylval.strval[yyleng - 2] = 0;
375 			return TOKEN;
376 		}
377 
378 <LSTATE>\"[^\"\n]*[\"\n] {
379 			yylval.strval = create_token(yytext + 1);
380 			if (yylval.strval[yyleng - 2] == '"')
381 				yylval.strval[yyleng - 2] = 0;
382 			return TOKEN;
383 		}
384 
385 ";"		{
386 			BEGIN INITIAL;
387 			return (yytext[0]);
388 		}
389 
390 \n		{
391 			lex_lineno++;
392 			BEGIN INITIAL;
393 			return (yytext[0]);
394 		}
395 
396 [ \t]		;	/* Ignore whitespace */
397 
398 .		{
399 			return (yytext[0]);
400 		}
401 
402 %%
403 
404 /*
405  * Assert that there are no unclaimed tokens.  This function enforces the
406  * invariants mentioned at the top of this file.
407  */
408 void
409 assert_no_unclaimed_tokens(void)
410 {
411 	assert(num_unclaimed_tokens == 0);
412 	assert(unclaimed_tokens == NULL);
413 	assert(unclaimed_tokens_size == 0);
414 }
415 
416 /*
417  * Claim the specified unclaimed TOKEN.  YACC reduction rules that
418  * use TOKENs should invoke this function immediately before freeing the TOKENs
419  * or adding them to data structures that will be cleaned up when the YACC
420  * parser finishes or encounters errors.  Reduction rules should only claim the
421  * TOKENs that they use.
422  *
423  * This function returns its argument but does not free its memory.
424  */
425 char *
426 claim_token(char *token)
427 {
428 	unsigned int index;
429 
430 	/*
431 	 * Find the token in the list of unclaimed tokens.
432 	 */
433 	assert(num_unclaimed_tokens > 0);
434 	for (index = 0; index < num_unclaimed_tokens; index++) {
435 		if (unclaimed_tokens[index] == token)
436 			break;
437 	}
438 
439 	/*
440 	 * Abort if we didn't find the token.
441 	 */
442 	assert(index != num_unclaimed_tokens);
443 
444 	/*
445 	 * Replace the token with the last unclaimed token.
446 	 */
447 	num_unclaimed_tokens--;
448 	unclaimed_tokens[index] = unclaimed_tokens[num_unclaimed_tokens];
449 
450 	/*
451 	 * Delete the list of unclaimed tokens if it's empty.
452 	 */
453 	if (num_unclaimed_tokens == 0) {
454 		free(unclaimed_tokens);
455 		unclaimed_tokens = NULL;
456 		unclaimed_tokens_size = 0;
457 	}
458 
459 	return (token);
460 }
461 
462 /*
463  * Free all unclaimed TOKENs.  This should only be invoked when the YACC
464  * parser encounters errors.
465  */
466 static void
467 free_tokens(void)
468 {
469 	if (unclaimed_tokens != NULL) {
470 		while (num_unclaimed_tokens > 0)
471 			free(unclaimed_tokens[--num_unclaimed_tokens]);
472 		free(unclaimed_tokens);
473 		unclaimed_tokens = NULL;
474 		unclaimed_tokens_size = 0;
475 	}
476 	assert_no_unclaimed_tokens();
477 }
478 
479 /*
480  * Create a TOKEN from the specified string.  The TOKEN is merely a duplicate
481  * of the specified string.  TOKENs must be claimed by the YACC reduction rules
482  * that use them; see claim_token() above.
483  */
484 char *
485 create_token(char *s)
486 {
487 	char *result;
488 
489 	if ((result = strdup(s)) == NULL) {
490 		yyerror("Out of memory");
491 		exit(Z_ERR);
492 	}
493 
494 	/*
495 	 * Add the new TOKEN to the list of unclaimed TOKENs.  The list might
496 	 * have to be resized.
497 	 *
498 	 * Reduction rules should claim TOKENs via claim_token() (see above).
499 	 */
500 	if (num_unclaimed_tokens == unclaimed_tokens_size) {
501 		char **new_unclaimed_tokens;
502 
503 		unclaimed_tokens_size += UNCLAIMED_TOKENS_BUFFER_GROWTH;
504 		new_unclaimed_tokens = (char **)realloc(unclaimed_tokens,
505 		    unclaimed_tokens_size * sizeof (char *));
506 		if (new_unclaimed_tokens == NULL) {
507 			yyerror("Out of memory");
508 			free(result);
509 			exit(Z_ERR);
510 		}
511 		unclaimed_tokens = new_unclaimed_tokens;
512 	}
513 	unclaimed_tokens[num_unclaimed_tokens] = result;
514 	num_unclaimed_tokens++;
515 	return (result);
516 }
517 
518 void
519 yyerror(char *s)
520 {
521 	/*
522 	 * Ensure that we won't leak unclaimed tokens.
523 	 */
524 	free_tokens();
525 
526 	/* feof(yyin) is not an error; anything else is, so we set saw_error */
527 	if (yytext[0] == '\0') {
528 		if (!feof(yyin)) {
529 			saw_error = B_TRUE;
530 			(void) fprintf(stderr, gettext("%s, token expected\n"),
531 			    s);
532 		}
533 		return;
534 	}
535 
536 	saw_error = B_TRUE;
537 	if (cmd_file_mode)
538 		(void) fprintf(stderr, gettext("%s on line %d at '%s'\n"), s,
539 		    lex_lineno, (yytext[0] == '\n') ? "\\n" : yytext);
540 	else
541 		(void) fprintf(stderr, gettext("%s at '%s'\n"), s,
542 		    (yytext[0] == '\n') ? "\\n" : yytext);
543 	usage(B_FALSE, HELP_SUBCMDS);
544 }
545