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 int yyerror(const 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 (void) 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 (void) 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 int 519 yyerror(const 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 (0); 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 return (0); 545 } 546