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 2009 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 29 #include <libintl.h> 30 31 #include "svccfg.h" 32 33 uu_list_pool_t *string_pool; 34 35 %} 36 37 %union { 38 int tok; 39 char *str; 40 uu_list_t *uul; 41 } 42 43 %start commands 44 45 %token SCC_VALIDATE SCC_IMPORT SCC_EXPORT SCC_ARCHIVE SCC_APPLY SCC_EXTRACT 46 %token SCC_REPOSITORY SCC_INVENTORY SCC_SET SCC_END SCC_HELP SCC_RESTORE 47 %token SCC_LIST SCC_ADD SCC_DELETE SCC_SELECT SCC_UNSELECT 48 %token SCC_LISTPG SCC_ADDPG SCC_DELPG SCC_DELHASH 49 %token SCC_LISTPROP SCC_SETPROP SCC_DELPROP SCC_EDITPROP 50 %token SCC_DESCRIBE 51 %token SCC_ADDPROPVALUE SCC_DELPROPVALUE SCC_SETENV SCC_UNSETENV 52 %token SCC_LISTSNAP SCC_SELECTSNAP SCC_REVERT SCC_REFRESH 53 %token SCS_REDIRECT SCS_NEWLINE SCS_EQUALS SCS_LPAREN SCS_RPAREN 54 %token SCV_WORD SCV_STRING 55 56 %type <tok> command_token 57 %type <str> SCV_WORD SCV_STRING 58 %type <str> string opt_word 59 %type <uul> string_list multiline_string_list 60 61 %% 62 63 /* 64 * We could hoist the command terminator for all the rules up here, but then 65 * the parser would reduce before shifting the terminator, which would require 66 * an additional error rule (per command) to catch extra arguments. 67 * This way requires all input to be terminated, which is done by input() in 68 * svccfg.l. 69 */ 70 71 commands : command 72 | commands command 73 74 command : terminator 75 | validate_cmd 76 | import_cmd 77 | export_cmd 78 | archive_cmd 79 | restore_cmd 80 | apply_cmd 81 | extract_cmd 82 | repository_cmd 83 | inventory_cmd 84 | set_cmd 85 | end_cmd 86 | help_cmd 87 | list_cmd 88 | add_cmd 89 | delete_cmd 90 | select_cmd 91 | unselect_cmd 92 | listpg_cmd 93 | addpg_cmd 94 | delpg_cmd 95 | delhash_cmd 96 | listprop_cmd 97 | setprop_cmd 98 | delprop_cmd 99 | editprop_cmd 100 | describe_cmd 101 | addpropvalue_cmd 102 | delpropvalue_cmd 103 | setenv_cmd 104 | unsetenv_cmd 105 | listsnap_cmd 106 | selectsnap_cmd 107 | revert_cmd 108 | refresh_cmd 109 | unknown_cmd 110 | error terminator { semerr(gettext("Syntax error.\n")); } 111 112 unknown_cmd : SCV_WORD terminator 113 { 114 semerr(gettext("Unknown command \"%s\".\n"), $1); 115 free($1); 116 } 117 | SCV_WORD string_list terminator 118 { 119 string_list_t *slp; 120 void *cookie = NULL; 121 122 semerr(gettext("Unknown command \"%s\".\n"), $1); 123 124 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 125 free(slp->str); 126 free(slp); 127 } 128 129 uu_list_destroy($2); 130 free($1); 131 } 132 133 validate_cmd : SCC_VALIDATE SCV_WORD terminator 134 { 135 lscf_validate($2); 136 free($2); 137 } 138 | SCC_VALIDATE terminator { lscf_validate_fmri(NULL); } 139 | SCC_VALIDATE error terminator { synerr(SCC_VALIDATE); return(0); } 140 141 import_cmd : SCC_IMPORT string_list terminator 142 { 143 string_list_t *slp; 144 void *cookie = NULL; 145 146 if (engine_import($2) == -2) { 147 synerr(SCC_IMPORT); 148 return(0); 149 } 150 151 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 152 free(slp->str); 153 free(slp); 154 } 155 156 uu_list_destroy($2); 157 } 158 | SCC_IMPORT error terminator { synerr(SCC_IMPORT); return(0); } 159 160 export_cmd : SCC_EXPORT SCV_WORD terminator 161 { 162 lscf_service_export($2, NULL, 0); 163 free($2); 164 } 165 | SCC_EXPORT SCV_WORD SCS_REDIRECT SCV_WORD terminator 166 { 167 lscf_service_export($2, $4, 0); 168 free($2); 169 free($4); 170 } 171 | SCC_EXPORT SCV_WORD SCV_WORD terminator 172 { 173 if (strcmp($2, "-a") == 0) { 174 lscf_service_export($3, NULL, SCE_ALL_VALUES); 175 free($2); 176 free($3); 177 } else { 178 synerr(SCC_EXPORT); 179 free($2); 180 free($3); 181 return (0); 182 } 183 } 184 | SCC_EXPORT SCV_WORD SCV_WORD SCS_REDIRECT SCV_WORD terminator 185 { 186 if (strcmp($2, "-a") == 0) { 187 lscf_service_export($3, $5, SCE_ALL_VALUES); 188 free($2); 189 free($3); 190 free($5); 191 } else { 192 synerr(SCC_EXPORT); 193 free($2); 194 free($3); 195 free($5); 196 return (0); 197 } 198 } 199 | SCC_EXPORT error terminator { synerr(SCC_EXPORT); return(0); } 200 201 archive_cmd : SCC_ARCHIVE terminator 202 { 203 lscf_archive(NULL, 0); 204 } 205 | SCC_ARCHIVE SCV_WORD terminator 206 { 207 if (strcmp($2, "-a") == 0) { 208 lscf_archive(NULL, SCE_ALL_VALUES); 209 free($2); 210 } else { 211 synerr(SCC_ARCHIVE); 212 free($2); 213 return (0); 214 } 215 } 216 | SCC_ARCHIVE SCS_REDIRECT SCV_WORD terminator 217 { 218 lscf_archive($3, 0); 219 free($3); 220 } 221 | SCC_ARCHIVE SCV_WORD SCS_REDIRECT SCV_WORD terminator 222 { 223 if (strcmp($2, "-a") == 0) { 224 lscf_archive($4, SCE_ALL_VALUES); 225 free($2); 226 free($4); 227 } else { 228 synerr(SCC_ARCHIVE); 229 free($2); 230 free($4); 231 return (0); 232 } 233 } 234 | SCC_ARCHIVE error terminator { synerr(SCC_ARCHIVE); return(0); } 235 236 restore_cmd : SCC_RESTORE SCV_WORD terminator 237 { 238 (void) engine_restore($2); 239 free($2); 240 } 241 | SCC_RESTORE error terminator { synerr(SCC_RESTORE); return(0); } 242 243 apply_cmd : SCC_APPLY SCV_WORD terminator 244 { 245 (void) engine_apply($2, 1); 246 free($2); 247 } 248 | SCC_APPLY SCV_WORD SCV_WORD terminator 249 { 250 if (strcmp($2, "-n") == 0) { 251 (void) engine_apply($3, 0); 252 free($2); 253 free($3); 254 } else { 255 synerr(SCC_APPLY); 256 free($2); 257 free($3); 258 return (0); 259 } 260 } 261 | SCC_APPLY error terminator { synerr(SCC_APPLY); return(0); } 262 263 extract_cmd: SCC_EXTRACT terminator { lscf_profile_extract(NULL); } 264 | SCC_EXTRACT SCS_REDIRECT SCV_WORD terminator 265 { 266 lscf_profile_extract($3); 267 free($3); 268 } 269 | SCC_EXTRACT error terminator { synerr(SCC_EXTRACT); return(0); } 270 271 repository_cmd: SCC_REPOSITORY SCV_WORD terminator 272 { 273 if (strcmp($2, "-f") == 0) { 274 synerr(SCC_REPOSITORY); 275 return(0); 276 } 277 lscf_set_repository($2, 0); 278 free($2); 279 } 280 | SCC_REPOSITORY SCV_WORD SCV_WORD terminator 281 { 282 if (strcmp($2, "-f") == 0) { 283 lscf_set_repository($3, 1); 284 free($2); 285 free($3); 286 } else { 287 synerr(SCC_REPOSITORY); 288 return(0); 289 } 290 } 291 | SCC_REPOSITORY error terminator { synerr(SCC_REPOSITORY); return(0); } 292 293 inventory_cmd : SCC_INVENTORY SCV_WORD terminator 294 { lxml_inventory($2); free($2); } 295 | SCC_INVENTORY error terminator { synerr(SCC_INVENTORY); return(0); } 296 297 set_cmd : SCC_SET string_list terminator 298 { 299 string_list_t *slp; 300 void *cookie = NULL; 301 302 (void) engine_set($2); 303 304 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 305 free(slp->str); 306 free(slp); 307 } 308 309 uu_list_destroy($2); 310 } 311 | SCC_SET error terminator { synerr(SCC_SET); return(0); } 312 313 end_cmd : SCC_END terminator { exit(0); } 314 | SCC_END error terminator { synerr (SCC_END); return(0); } 315 316 help_cmd : SCC_HELP terminator { help(0); } 317 | SCC_HELP command_token terminator { help($2); } 318 | SCC_HELP error terminator { synerr(SCC_HELP); return(0); } 319 320 list_cmd : SCC_LIST opt_word terminator { lscf_list($2); free($2); } 321 | SCC_LIST error terminator { synerr(SCC_LIST); return(0); } 322 323 add_cmd : SCC_ADD SCV_WORD terminator { lscf_add($2); free($2); } 324 | SCC_ADD error terminator { synerr(SCC_ADD); return(0); } 325 326 delete_cmd : SCC_DELETE SCV_WORD terminator 327 { lscf_delete($2, 0); free($2); } 328 | SCC_DELETE SCV_WORD SCV_WORD terminator 329 { 330 if (strcmp($2, "-f") == 0) { 331 lscf_delete($3, 1); 332 free($2); 333 free($3); 334 } else { 335 synerr(SCC_DELETE); 336 free($2); 337 free($3); 338 return(0); 339 } 340 } 341 | SCC_DELETE error terminator { synerr(SCC_DELETE); return(0); } 342 343 select_cmd : SCC_SELECT SCV_WORD terminator { lscf_select($2); free($2); } 344 | SCC_SELECT error terminator { synerr(SCC_SELECT); return(0) ;} 345 346 unselect_cmd : SCC_UNSELECT terminator { lscf_unselect(); } 347 | SCC_UNSELECT error terminator { synerr(SCC_UNSELECT); return(0); } 348 349 listpg_cmd : SCC_LISTPG opt_word terminator 350 { lscf_listpg($2); free($2); } 351 | SCC_LISTPG error terminator { synerr(SCC_LISTPG); return(0); } 352 353 addpg_cmd : SCC_ADDPG SCV_WORD SCV_WORD opt_word terminator 354 { 355 (void) lscf_addpg($2, $3, $4); 356 free($2); 357 free($3); 358 free($4); 359 } 360 | SCC_ADDPG error terminator { synerr(SCC_ADDPG); return(0); } 361 362 delpg_cmd : SCC_DELPG SCV_WORD terminator 363 { lscf_delpg($2); free($2); } 364 | SCC_DELPG error terminator { synerr(SCC_DELPG); return(0); } 365 366 delhash_cmd : SCC_DELHASH SCV_WORD terminator 367 { 368 lscf_delhash($2, 0); free($2); 369 } 370 | SCC_DELHASH SCV_WORD SCV_WORD terminator 371 { 372 if (strcmp($2, "-d") == 0) { 373 lscf_delhash($3, 1); 374 free($2); 375 free($3); 376 } else { 377 synerr(SCC_DELHASH); 378 free($2); 379 free($3); 380 return(0); 381 } 382 } 383 | SCC_DELHASH error terminator { synerr(SCC_DELHASH); return(0); } 384 385 listprop_cmd : SCC_LISTPROP opt_word terminator 386 { lscf_listprop($2); free($2); } 387 | SCC_LISTPROP error terminator { synerr(SCC_LISTPROP); return(0); } 388 389 setprop_cmd : SCC_SETPROP SCV_WORD SCS_EQUALS string terminator 390 { 391 lscf_setprop($2, NULL, $4, NULL); 392 free($2); 393 free($4); 394 } 395 | SCC_SETPROP SCV_WORD SCS_EQUALS SCV_WORD string terminator 396 { 397 (void) lscf_setprop($2, $4, $5, NULL); 398 free($2); 399 free($4); 400 free($5); 401 } 402 | SCC_SETPROP SCV_WORD SCS_EQUALS opt_word SCS_LPAREN 403 multiline_string_list SCS_RPAREN terminator 404 { 405 string_list_t *slp; 406 void *cookie = NULL; 407 408 (void) lscf_setprop($2, $4, NULL, $6); 409 410 free($2); 411 free($4); 412 413 while ((slp = uu_list_teardown($6, &cookie)) != NULL) { 414 free(slp->str); 415 free(slp); 416 } 417 418 uu_list_destroy($6); 419 } 420 | SCC_SETPROP error terminator { synerr(SCC_SETPROP); return(0); } 421 | SCC_SETPROP error { synerr(SCC_SETPROP); return(0); } 422 423 delprop_cmd : SCC_DELPROP SCV_WORD terminator 424 { lscf_delprop($2); free($2); } 425 | SCC_DELPROP error terminator { synerr(SCC_DELPROP); return(0); } 426 427 editprop_cmd : SCC_EDITPROP terminator { lscf_editprop(); } 428 | SCC_EDITPROP error terminator { synerr(SCC_EDITPROP); return(0); } 429 430 describe_cmd : SCC_DESCRIBE string_list terminator 431 { 432 string_list_t *slp; 433 void *cookie = NULL; 434 435 if (lscf_describe($2, 1) == -2) { 436 synerr(SCC_DESCRIBE); 437 return(0); 438 } 439 440 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 441 free(slp->str); 442 free(slp); 443 } 444 445 uu_list_destroy($2); 446 } 447 | SCC_DESCRIBE terminator { lscf_describe(NULL, 0); } 448 | SCC_DESCRIBE error terminator { synerr(SCC_DESCRIBE); return(0); } 449 450 addpropvalue_cmd : SCC_ADDPROPVALUE SCV_WORD string terminator 451 { 452 lscf_addpropvalue($2, NULL, $3); 453 free($2); 454 free($3); 455 } 456 | SCC_ADDPROPVALUE SCV_WORD string string terminator 457 { 458 (void) lscf_addpropvalue($2, $3, $4); 459 free($2); 460 free($3); 461 free($4); 462 } 463 | SCC_ADDPROPVALUE error terminator { synerr(SCC_ADDPROPVALUE); return(0); } 464 465 delpropvalue_cmd : SCC_DELPROPVALUE SCV_WORD string terminator 466 { 467 lscf_delpropvalue($2, $3, 0); 468 free($2); 469 free($3); 470 } 471 | SCC_DELPROPVALUE error terminator { synerr(SCC_DELPROPVALUE); return(0); } 472 473 setenv_cmd : SCC_SETENV string_list terminator 474 { 475 string_list_t *slp; 476 void *cookie = NULL; 477 478 if (lscf_setenv($2, 0) == -2) { 479 synerr(SCC_SETENV); 480 return(0); 481 } 482 483 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 484 free(slp->str); 485 free(slp); 486 } 487 488 uu_list_destroy($2); 489 } 490 | SCC_SETENV error terminator { synerr(SCC_SETENV); return(0); } 491 492 unsetenv_cmd : SCC_UNSETENV string_list terminator 493 { 494 string_list_t *slp; 495 void *cookie = NULL; 496 497 if (lscf_setenv($2, 1) == -2) { 498 synerr(SCC_UNSETENV); 499 return(0); 500 } 501 502 while ((slp = uu_list_teardown($2, &cookie)) != NULL) { 503 free(slp->str); 504 free(slp); 505 } 506 507 uu_list_destroy($2); 508 } 509 | SCC_UNSETENV error terminator { synerr(SCC_UNSETENV); return(0); } 510 511 listsnap_cmd : SCC_LISTSNAP terminator { lscf_listsnap(); } 512 | SCC_LISTSNAP error terminator { synerr(SCC_LISTSNAP); return(0); } 513 514 selectsnap_cmd : SCC_SELECTSNAP opt_word terminator 515 { lscf_selectsnap($2); free($2); } 516 | SCC_SELECTSNAP error terminator 517 { synerr(SCC_SELECTSNAP); return(0); } 518 519 revert_cmd: SCC_REVERT opt_word terminator { lscf_revert($2); free ($2); } 520 | SCC_REVERT error terminator { synerr(SCC_REVERT); return(0); } 521 522 refresh_cmd: SCC_REFRESH terminator { lscf_refresh(); } 523 | SCC_REFRESH error terminator { synerr(SCC_REFRESH); return(0); } 524 525 terminator : SCS_NEWLINE 526 527 string_list : 528 { 529 $$ = uu_list_create(string_pool, NULL, 0); 530 if ($$ == NULL) 531 uu_die(gettext("Out of memory\n")); 532 } 533 | string_list string 534 { 535 string_list_t *slp; 536 537 slp = safe_malloc(sizeof (*slp)); 538 539 slp->str = $2; 540 uu_list_node_init(slp, &slp->node, string_pool); 541 uu_list_append($1, slp); 542 $$ = $1; 543 } 544 545 multiline_string_list : string_list 546 { 547 $$ = $1; 548 } 549 | multiline_string_list SCS_NEWLINE string_list 550 { 551 void *cookie = NULL; 552 string_list_t *slp; 553 554 /* Append $3 to $1. */ 555 while ((slp = uu_list_teardown($3, &cookie)) != NULL) 556 uu_list_append($1, slp); 557 558 uu_list_destroy($3); 559 } 560 561 string : SCV_WORD { $$ = $1; } 562 | SCV_STRING { $$ = $1; } 563 564 opt_word : { $$ = NULL; } 565 | SCV_WORD { $$ = $1; } 566 567 command_token : SCC_VALIDATE { $$ = SCC_VALIDATE; } 568 | SCC_IMPORT { $$ = SCC_IMPORT; } 569 | SCC_EXPORT { $$ = SCC_EXPORT; } 570 | SCC_APPLY { $$ = SCC_APPLY; } 571 | SCC_EXTRACT { $$ = SCC_EXTRACT; } 572 | SCC_REPOSITORY { $$ = SCC_REPOSITORY; } 573 | SCC_ARCHIVE { $$ = SCC_ARCHIVE; } 574 | SCC_INVENTORY { $$ = SCC_INVENTORY; } 575 | SCC_SET { $$ = SCC_SET; } 576 | SCC_END { $$ = SCC_END; } 577 | SCC_HELP { $$ = SCC_HELP; } 578 | SCC_LIST { $$ = SCC_LIST; } 579 | SCC_ADD { $$ = SCC_ADD; } 580 | SCC_DELETE { $$ = SCC_DELETE; } 581 | SCC_SELECT { $$ = SCC_SELECT; } 582 | SCC_UNSELECT { $$ = SCC_UNSELECT; } 583 | SCC_LISTPG { $$ = SCC_LISTPG; } 584 | SCC_ADDPG { $$ = SCC_ADDPG; } 585 | SCC_DELPG { $$ = SCC_DELPG; } 586 | SCC_DELHASH { $$ = SCC_DELHASH; } 587 | SCC_LISTPROP { $$ = SCC_LISTPROP; } 588 | SCC_SETPROP { $$ = SCC_SETPROP; } 589 | SCC_DELPROP { $$ = SCC_DELPROP; } 590 | SCC_EDITPROP { $$ = SCC_EDITPROP; } 591 | SCC_ADDPROPVALUE { $$ = SCC_ADDPROPVALUE; } 592 | SCC_DELPROPVALUE { $$ = SCC_DELPROPVALUE; } 593 | SCC_SETENV { $$ = SCC_SETENV; } 594 | SCC_UNSETENV { $$ = SCC_UNSETENV; } 595 | SCC_LISTSNAP { $$ = SCC_LISTSNAP; } 596 | SCC_SELECTSNAP { $$ = SCC_SELECTSNAP; } 597 | SCC_REVERT { $$ = SCC_REVERT; } 598 | SCC_REFRESH { $$ = SCC_REFRESH; } 599 | SCC_DESCRIBE { $$ = SCC_DESCRIBE; } 600