1 %{ 2 /*- 3 * Copyright (c) 2012 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * This software was developed by Edward Tomasz Napierala under sponsorship 7 * from the FreeBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $FreeBSD$ 31 */ 32 33 #include <sys/queue.h> 34 #include <sys/types.h> 35 #include <sys/stat.h> 36 #include <assert.h> 37 #include <stdio.h> 38 #include <stdint.h> 39 #include <stdlib.h> 40 #include <string.h> 41 42 #include "ctld.h" 43 44 extern FILE *yyin; 45 extern char *yytext; 46 extern int lineno; 47 48 static struct conf *conf = NULL; 49 static struct auth_group *auth_group = NULL; 50 static struct portal_group *portal_group = NULL; 51 static struct target *target = NULL; 52 static struct lun *lun = NULL; 53 54 extern void yyerror(const char *); 55 extern int yylex(void); 56 extern void yyrestart(FILE *); 57 58 %} 59 60 %token ALIAS AUTH_GROUP AUTH_TYPE BACKEND BLOCKSIZE CHAP CHAP_MUTUAL 61 %token CLOSING_BRACKET DEBUG DEVICE_ID DISCOVERY_AUTH_GROUP INITIATOR_NAME 62 %token INITIATOR_PORTAL LISTEN LISTEN_ISER LUN MAXPROC NUM OPENING_BRACKET 63 %token OPTION PATH PIDFILE PORTAL_GROUP SERIAL SIZE STR TARGET TIMEOUT 64 65 %union 66 { 67 uint64_t num; 68 char *str; 69 } 70 71 %token <num> NUM 72 %token <str> STR 73 74 %% 75 76 statements: 77 | 78 statements statement 79 ; 80 81 statement: 82 debug 83 | 84 timeout 85 | 86 maxproc 87 | 88 pidfile 89 | 90 auth_group 91 | 92 portal_group 93 | 94 target 95 ; 96 97 debug: DEBUG NUM 98 { 99 conf->conf_debug = $2; 100 } 101 ; 102 103 timeout: TIMEOUT NUM 104 { 105 conf->conf_timeout = $2; 106 } 107 ; 108 109 maxproc: MAXPROC NUM 110 { 111 conf->conf_maxproc = $2; 112 } 113 ; 114 115 pidfile: PIDFILE STR 116 { 117 if (conf->conf_pidfile_path != NULL) { 118 log_warnx("pidfile specified more than once"); 119 free($2); 120 return (1); 121 } 122 conf->conf_pidfile_path = $2; 123 } 124 ; 125 126 auth_group: AUTH_GROUP auth_group_name 127 OPENING_BRACKET auth_group_entries CLOSING_BRACKET 128 { 129 auth_group = NULL; 130 } 131 ; 132 133 auth_group_name: STR 134 { 135 /* 136 * Make it possible to redefine default 137 * auth-group. but only once. 138 */ 139 if (strcmp($1, "default") == 0 && 140 conf->conf_default_ag_defined == false) { 141 auth_group = auth_group_find(conf, $1); 142 conf->conf_default_ag_defined = true; 143 } else { 144 auth_group = auth_group_new(conf, $1); 145 } 146 free($1); 147 if (auth_group == NULL) 148 return (1); 149 } 150 ; 151 152 auth_group_entries: 153 | 154 auth_group_entries auth_group_entry 155 ; 156 157 auth_group_entry: 158 auth_group_auth_type 159 | 160 auth_group_chap 161 | 162 auth_group_chap_mutual 163 | 164 auth_group_initiator_name 165 | 166 auth_group_initiator_portal 167 ; 168 169 auth_group_auth_type: AUTH_TYPE STR 170 { 171 int error; 172 173 error = auth_group_set_type_str(auth_group, $2); 174 free($2); 175 if (error != 0) 176 return (1); 177 } 178 ; 179 180 auth_group_chap: CHAP STR STR 181 { 182 const struct auth *ca; 183 184 ca = auth_new_chap(auth_group, $2, $3); 185 free($2); 186 free($3); 187 if (ca == NULL) 188 return (1); 189 } 190 ; 191 192 auth_group_chap_mutual: CHAP_MUTUAL STR STR STR STR 193 { 194 const struct auth *ca; 195 196 ca = auth_new_chap_mutual(auth_group, $2, $3, $4, $5); 197 free($2); 198 free($3); 199 free($4); 200 free($5); 201 if (ca == NULL) 202 return (1); 203 } 204 ; 205 206 auth_group_initiator_name: INITIATOR_NAME STR 207 { 208 const struct auth_name *an; 209 210 an = auth_name_new(auth_group, $2); 211 free($2); 212 if (an == NULL) 213 return (1); 214 } 215 ; 216 217 auth_group_initiator_portal: INITIATOR_PORTAL STR 218 { 219 const struct auth_portal *ap; 220 221 ap = auth_portal_new(auth_group, $2); 222 free($2); 223 if (ap == NULL) 224 return (1); 225 } 226 ; 227 228 portal_group: PORTAL_GROUP portal_group_name 229 OPENING_BRACKET portal_group_entries CLOSING_BRACKET 230 { 231 portal_group = NULL; 232 } 233 ; 234 235 portal_group_name: STR 236 { 237 /* 238 * Make it possible to redefine default 239 * portal-group. but only once. 240 */ 241 if (strcmp($1, "default") == 0 && 242 conf->conf_default_pg_defined == false) { 243 portal_group = portal_group_find(conf, $1); 244 conf->conf_default_pg_defined = true; 245 } else { 246 portal_group = portal_group_new(conf, $1); 247 } 248 free($1); 249 if (portal_group == NULL) 250 return (1); 251 } 252 ; 253 254 portal_group_entries: 255 | 256 portal_group_entries portal_group_entry 257 ; 258 259 portal_group_entry: 260 portal_group_discovery_auth_group 261 | 262 portal_group_listen 263 | 264 portal_group_listen_iser 265 ; 266 267 portal_group_discovery_auth_group: DISCOVERY_AUTH_GROUP STR 268 { 269 if (portal_group->pg_discovery_auth_group != NULL) { 270 log_warnx("discovery-auth-group for portal-group " 271 "\"%s\" specified more than once", 272 portal_group->pg_name); 273 return (1); 274 } 275 portal_group->pg_discovery_auth_group = 276 auth_group_find(conf, $2); 277 if (portal_group->pg_discovery_auth_group == NULL) { 278 log_warnx("unknown discovery-auth-group \"%s\" " 279 "for portal-group \"%s\"", 280 $2, portal_group->pg_name); 281 return (1); 282 } 283 free($2); 284 } 285 ; 286 287 portal_group_listen: LISTEN STR 288 { 289 int error; 290 291 error = portal_group_add_listen(portal_group, $2, false); 292 free($2); 293 if (error != 0) 294 return (1); 295 } 296 ; 297 298 portal_group_listen_iser: LISTEN_ISER STR 299 { 300 int error; 301 302 error = portal_group_add_listen(portal_group, $2, true); 303 free($2); 304 if (error != 0) 305 return (1); 306 } 307 ; 308 309 target: TARGET target_name 310 OPENING_BRACKET target_entries CLOSING_BRACKET 311 { 312 target = NULL; 313 } 314 ; 315 316 target_name: STR 317 { 318 target = target_new(conf, $1); 319 free($1); 320 if (target == NULL) 321 return (1); 322 } 323 ; 324 325 target_entries: 326 | 327 target_entries target_entry 328 ; 329 330 target_entry: 331 target_alias 332 | 333 target_auth_group 334 | 335 target_auth_type 336 | 337 target_chap 338 | 339 target_chap_mutual 340 | 341 target_initiator_name 342 | 343 target_initiator_portal 344 | 345 target_portal_group 346 | 347 target_lun 348 ; 349 350 target_alias: ALIAS STR 351 { 352 if (target->t_alias != NULL) { 353 log_warnx("alias for target \"%s\" " 354 "specified more than once", target->t_name); 355 return (1); 356 } 357 target->t_alias = $2; 358 } 359 ; 360 361 target_auth_group: AUTH_GROUP STR 362 { 363 if (target->t_auth_group != NULL) { 364 if (target->t_auth_group->ag_name != NULL) 365 log_warnx("auth-group for target \"%s\" " 366 "specified more than once", target->t_name); 367 else 368 log_warnx("cannot use both auth-group and explicit " 369 "authorisations for target \"%s\"", 370 target->t_name); 371 return (1); 372 } 373 target->t_auth_group = auth_group_find(conf, $2); 374 if (target->t_auth_group == NULL) { 375 log_warnx("unknown auth-group \"%s\" for target " 376 "\"%s\"", $2, target->t_name); 377 return (1); 378 } 379 free($2); 380 } 381 ; 382 383 target_auth_type: AUTH_TYPE STR 384 { 385 int error; 386 387 if (target->t_auth_group != NULL) { 388 if (target->t_auth_group->ag_name != NULL) { 389 log_warnx("cannot use both auth-group and " 390 "auth-type for target \"%s\"", 391 target->t_name); 392 return (1); 393 } 394 } else { 395 target->t_auth_group = auth_group_new(conf, NULL); 396 if (target->t_auth_group == NULL) { 397 free($2); 398 return (1); 399 } 400 target->t_auth_group->ag_target = target; 401 } 402 error = auth_group_set_type_str(target->t_auth_group, $2); 403 free($2); 404 if (error != 0) 405 return (1); 406 } 407 ; 408 409 target_chap: CHAP STR STR 410 { 411 const struct auth *ca; 412 413 if (target->t_auth_group != NULL) { 414 if (target->t_auth_group->ag_name != NULL) { 415 log_warnx("cannot use both auth-group and " 416 "chap for target \"%s\"", 417 target->t_name); 418 free($2); 419 free($3); 420 return (1); 421 } 422 } else { 423 target->t_auth_group = auth_group_new(conf, NULL); 424 if (target->t_auth_group == NULL) { 425 free($2); 426 free($3); 427 return (1); 428 } 429 target->t_auth_group->ag_target = target; 430 } 431 ca = auth_new_chap(target->t_auth_group, $2, $3); 432 free($2); 433 free($3); 434 if (ca == NULL) 435 return (1); 436 } 437 ; 438 439 target_chap_mutual: CHAP_MUTUAL STR STR STR STR 440 { 441 const struct auth *ca; 442 443 if (target->t_auth_group != NULL) { 444 if (target->t_auth_group->ag_name != NULL) { 445 log_warnx("cannot use both auth-group and " 446 "chap-mutual for target \"%s\"", 447 target->t_name); 448 free($2); 449 free($3); 450 free($4); 451 free($5); 452 return (1); 453 } 454 } else { 455 target->t_auth_group = auth_group_new(conf, NULL); 456 if (target->t_auth_group == NULL) { 457 free($2); 458 free($3); 459 free($4); 460 free($5); 461 return (1); 462 } 463 target->t_auth_group->ag_target = target; 464 } 465 ca = auth_new_chap_mutual(target->t_auth_group, 466 $2, $3, $4, $5); 467 free($2); 468 free($3); 469 free($4); 470 free($5); 471 if (ca == NULL) 472 return (1); 473 } 474 ; 475 476 target_initiator_name: INITIATOR_NAME STR 477 { 478 const struct auth_name *an; 479 480 if (target->t_auth_group != NULL) { 481 if (target->t_auth_group->ag_name != NULL) { 482 log_warnx("cannot use both auth-group and " 483 "initiator-name for target \"%s\"", 484 target->t_name); 485 free($2); 486 return (1); 487 } 488 } else { 489 target->t_auth_group = auth_group_new(conf, NULL); 490 if (target->t_auth_group == NULL) { 491 free($2); 492 return (1); 493 } 494 target->t_auth_group->ag_target = target; 495 } 496 an = auth_name_new(target->t_auth_group, $2); 497 free($2); 498 if (an == NULL) 499 return (1); 500 } 501 ; 502 503 target_initiator_portal: INITIATOR_PORTAL STR 504 { 505 const struct auth_portal *ap; 506 507 if (target->t_auth_group != NULL) { 508 if (target->t_auth_group->ag_name != NULL) { 509 log_warnx("cannot use both auth-group and " 510 "initiator-portal for target \"%s\"", 511 target->t_name); 512 free($2); 513 return (1); 514 } 515 } else { 516 target->t_auth_group = auth_group_new(conf, NULL); 517 if (target->t_auth_group == NULL) { 518 free($2); 519 return (1); 520 } 521 target->t_auth_group->ag_target = target; 522 } 523 ap = auth_portal_new(target->t_auth_group, $2); 524 free($2); 525 if (ap == NULL) 526 return (1); 527 } 528 ; 529 530 target_portal_group: PORTAL_GROUP STR 531 { 532 if (target->t_portal_group != NULL) { 533 log_warnx("portal-group for target \"%s\" " 534 "specified more than once", target->t_name); 535 free($2); 536 return (1); 537 } 538 target->t_portal_group = portal_group_find(conf, $2); 539 if (target->t_portal_group == NULL) { 540 log_warnx("unknown portal-group \"%s\" for target " 541 "\"%s\"", $2, target->t_name); 542 free($2); 543 return (1); 544 } 545 free($2); 546 } 547 ; 548 549 target_lun: LUN lun_number 550 OPENING_BRACKET lun_entries CLOSING_BRACKET 551 { 552 lun = NULL; 553 } 554 ; 555 556 lun_number: NUM 557 { 558 lun = lun_new(target, $1); 559 if (lun == NULL) 560 return (1); 561 } 562 ; 563 564 lun_entries: 565 | 566 lun_entries lun_entry 567 ; 568 569 lun_entry: 570 lun_backend 571 | 572 lun_blocksize 573 | 574 lun_device_id 575 | 576 lun_option 577 | 578 lun_path 579 | 580 lun_serial 581 | 582 lun_size 583 ; 584 585 lun_backend: BACKEND STR 586 { 587 if (lun->l_backend != NULL) { 588 log_warnx("backend for lun %d, target \"%s\" " 589 "specified more than once", 590 lun->l_lun, target->t_name); 591 free($2); 592 return (1); 593 } 594 lun_set_backend(lun, $2); 595 free($2); 596 } 597 ; 598 599 lun_blocksize: BLOCKSIZE NUM 600 { 601 if (lun->l_blocksize != 0) { 602 log_warnx("blocksize for lun %d, target \"%s\" " 603 "specified more than once", 604 lun->l_lun, target->t_name); 605 return (1); 606 } 607 lun_set_blocksize(lun, $2); 608 } 609 ; 610 611 lun_device_id: DEVICE_ID STR 612 { 613 if (lun->l_device_id != NULL) { 614 log_warnx("device_id for lun %d, target \"%s\" " 615 "specified more than once", 616 lun->l_lun, target->t_name); 617 free($2); 618 return (1); 619 } 620 lun_set_device_id(lun, $2); 621 free($2); 622 } 623 ; 624 625 lun_option: OPTION STR STR 626 { 627 struct lun_option *clo; 628 629 clo = lun_option_new(lun, $2, $3); 630 free($2); 631 free($3); 632 if (clo == NULL) 633 return (1); 634 } 635 ; 636 637 lun_path: PATH STR 638 { 639 if (lun->l_path != NULL) { 640 log_warnx("path for lun %d, target \"%s\" " 641 "specified more than once", 642 lun->l_lun, target->t_name); 643 free($2); 644 return (1); 645 } 646 lun_set_path(lun, $2); 647 free($2); 648 } 649 ; 650 651 lun_serial: SERIAL STR 652 { 653 if (lun->l_serial != NULL) { 654 log_warnx("serial for lun %d, target \"%s\" " 655 "specified more than once", 656 lun->l_lun, target->t_name); 657 free($2); 658 return (1); 659 } 660 lun_set_serial(lun, $2); 661 free($2); 662 } | SERIAL NUM 663 { 664 char *str = NULL; 665 666 if (lun->l_serial != NULL) { 667 log_warnx("serial for lun %d, target \"%s\" " 668 "specified more than once", 669 lun->l_lun, target->t_name); 670 return (1); 671 } 672 asprintf(&str, "%ju", $2); 673 lun_set_serial(lun, str); 674 free(str); 675 } 676 ; 677 678 lun_size: SIZE NUM 679 { 680 if (lun->l_size != 0) { 681 log_warnx("size for lun %d, target \"%s\" " 682 "specified more than once", 683 lun->l_lun, target->t_name); 684 return (1); 685 } 686 lun_set_size(lun, $2); 687 } 688 ; 689 %% 690 691 void 692 yyerror(const char *str) 693 { 694 695 log_warnx("error in configuration file at line %d near '%s': %s", 696 lineno, yytext, str); 697 } 698 699 static void 700 check_perms(const char *path) 701 { 702 struct stat sb; 703 int error; 704 705 error = stat(path, &sb); 706 if (error != 0) { 707 log_warn("stat"); 708 return; 709 } 710 if (sb.st_mode & S_IWOTH) { 711 log_warnx("%s is world-writable", path); 712 } else if (sb.st_mode & S_IROTH) { 713 log_warnx("%s is world-readable", path); 714 } else if (sb.st_mode & S_IXOTH) { 715 /* 716 * Ok, this one doesn't matter, but still do it, 717 * just for consistency. 718 */ 719 log_warnx("%s is world-executable", path); 720 } 721 722 /* 723 * XXX: Should we also check for owner != 0? 724 */ 725 } 726 727 struct conf * 728 conf_new_from_file(const char *path) 729 { 730 struct auth_group *ag; 731 struct portal_group *pg; 732 int error; 733 734 log_debugx("obtaining configuration from %s", path); 735 736 conf = conf_new(); 737 738 ag = auth_group_new(conf, "default"); 739 assert(ag != NULL); 740 741 ag = auth_group_new(conf, "no-authentication"); 742 assert(ag != NULL); 743 ag->ag_type = AG_TYPE_NO_AUTHENTICATION; 744 745 ag = auth_group_new(conf, "no-access"); 746 assert(ag != NULL); 747 ag->ag_type = AG_TYPE_DENY; 748 749 pg = portal_group_new(conf, "default"); 750 assert(pg != NULL); 751 752 yyin = fopen(path, "r"); 753 if (yyin == NULL) { 754 log_warn("unable to open configuration file %s", path); 755 conf_delete(conf); 756 return (NULL); 757 } 758 check_perms(path); 759 lineno = 1; 760 yyrestart(yyin); 761 error = yyparse(); 762 auth_group = NULL; 763 portal_group = NULL; 764 target = NULL; 765 lun = NULL; 766 fclose(yyin); 767 if (error != 0) { 768 conf_delete(conf); 769 return (NULL); 770 } 771 772 if (conf->conf_default_ag_defined == false) { 773 log_debugx("auth-group \"default\" not defined; " 774 "going with defaults"); 775 ag = auth_group_find(conf, "default"); 776 assert(ag != NULL); 777 ag->ag_type = AG_TYPE_DENY; 778 } 779 780 if (conf->conf_default_pg_defined == false) { 781 log_debugx("portal-group \"default\" not defined; " 782 "going with defaults"); 783 pg = portal_group_find(conf, "default"); 784 assert(pg != NULL); 785 portal_group_add_listen(pg, "0.0.0.0:3260", false); 786 portal_group_add_listen(pg, "[::]:3260", false); 787 } 788 789 conf->conf_kernel_port_on = true; 790 791 error = conf_verify(conf); 792 if (error != 0) { 793 conf_delete(conf); 794 return (NULL); 795 } 796 797 return (conf); 798 } 799