1%{ 2/*- 3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 4 * 5 * Copyright (c) 2012 The FreeBSD Foundation 6 * All rights reserved. 7 * 8 * This software was developed by Edward Tomasz Napierala under sponsorship 9 * from the FreeBSD Foundation. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD: stable/11/usr.sbin/ctld/parse.y 330449 2018-03-05 07:26:05Z eadler $ 33 */ 34 35#include <sys/queue.h> 36#include <sys/types.h> 37#include <sys/stat.h> 38#include <assert.h> 39#include <stdio.h> 40#include <stdlib.h> 41#include <string.h> 42 43#include "ctld.h" 44 45extern FILE *yyin; 46extern char *yytext; 47extern int lineno; 48 49static struct conf *conf = NULL; 50static struct auth_group *auth_group = NULL; 51static struct portal_group *portal_group = NULL; 52static struct target *target = NULL; 53static struct lun *lun = NULL; 54 55extern void yyerror(const char *); 56extern int yylex(void); 57extern void yyrestart(FILE *); 58 59%} 60 61%token ALIAS AUTH_GROUP AUTH_TYPE BACKEND BLOCKSIZE CHAP CHAP_MUTUAL 62%token CLOSING_BRACKET CTL_LUN DEBUG DEVICE_ID DEVICE_TYPE 63%token DISCOVERY_AUTH_GROUP DISCOVERY_FILTER FOREIGN 64%token INITIATOR_NAME INITIATOR_PORTAL ISNS_SERVER ISNS_PERIOD ISNS_TIMEOUT 65%token LISTEN LISTEN_ISER LUN MAXPROC OFFLOAD OPENING_BRACKET OPTION 66%token PATH PIDFILE PORT PORTAL_GROUP REDIRECT SEMICOLON SERIAL SIZE STR 67%token TAG TARGET TIMEOUT 68 69%union 70{ 71 char *str; 72} 73 74%token <str> STR 75 76%% 77 78statements: 79 | 80 statements statement 81 | 82 statements statement SEMICOLON 83 ; 84 85statement: 86 debug 87 | 88 timeout 89 | 90 maxproc 91 | 92 pidfile 93 | 94 isns_server 95 | 96 isns_period 97 | 98 isns_timeout 99 | 100 auth_group 101 | 102 portal_group 103 | 104 lun 105 | 106 target 107 ; 108 109debug: DEBUG STR 110 { 111 uint64_t tmp; 112 113 if (expand_number($2, &tmp) != 0) { 114 yyerror("invalid numeric value"); 115 free($2); 116 return (1); 117 } 118 119 conf->conf_debug = tmp; 120 } 121 ; 122 123timeout: TIMEOUT STR 124 { 125 uint64_t tmp; 126 127 if (expand_number($2, &tmp) != 0) { 128 yyerror("invalid numeric value"); 129 free($2); 130 return (1); 131 } 132 133 conf->conf_timeout = tmp; 134 } 135 ; 136 137maxproc: MAXPROC STR 138 { 139 uint64_t tmp; 140 141 if (expand_number($2, &tmp) != 0) { 142 yyerror("invalid numeric value"); 143 free($2); 144 return (1); 145 } 146 147 conf->conf_maxproc = tmp; 148 } 149 ; 150 151pidfile: PIDFILE STR 152 { 153 if (conf->conf_pidfile_path != NULL) { 154 log_warnx("pidfile specified more than once"); 155 free($2); 156 return (1); 157 } 158 conf->conf_pidfile_path = $2; 159 } 160 ; 161 162isns_server: ISNS_SERVER STR 163 { 164 int error; 165 166 error = isns_new(conf, $2); 167 free($2); 168 if (error != 0) 169 return (1); 170 } 171 ; 172 173isns_period: ISNS_PERIOD STR 174 { 175 uint64_t tmp; 176 177 if (expand_number($2, &tmp) != 0) { 178 yyerror("invalid numeric value"); 179 free($2); 180 return (1); 181 } 182 183 conf->conf_isns_period = tmp; 184 } 185 ; 186 187isns_timeout: ISNS_TIMEOUT STR 188 { 189 uint64_t tmp; 190 191 if (expand_number($2, &tmp) != 0) { 192 yyerror("invalid numeric value"); 193 free($2); 194 return (1); 195 } 196 197 conf->conf_isns_timeout = tmp; 198 } 199 ; 200 201auth_group: AUTH_GROUP auth_group_name 202 OPENING_BRACKET auth_group_entries CLOSING_BRACKET 203 { 204 auth_group = NULL; 205 } 206 ; 207 208auth_group_name: STR 209 { 210 /* 211 * Make it possible to redefine default 212 * auth-group. but only once. 213 */ 214 if (strcmp($1, "default") == 0 && 215 conf->conf_default_ag_defined == false) { 216 auth_group = auth_group_find(conf, $1); 217 conf->conf_default_ag_defined = true; 218 } else { 219 auth_group = auth_group_new(conf, $1); 220 } 221 free($1); 222 if (auth_group == NULL) 223 return (1); 224 } 225 ; 226 227auth_group_entries: 228 | 229 auth_group_entries auth_group_entry 230 | 231 auth_group_entries auth_group_entry SEMICOLON 232 ; 233 234auth_group_entry: 235 auth_group_auth_type 236 | 237 auth_group_chap 238 | 239 auth_group_chap_mutual 240 | 241 auth_group_initiator_name 242 | 243 auth_group_initiator_portal 244 ; 245 246auth_group_auth_type: AUTH_TYPE STR 247 { 248 int error; 249 250 error = auth_group_set_type(auth_group, $2); 251 free($2); 252 if (error != 0) 253 return (1); 254 } 255 ; 256 257auth_group_chap: CHAP STR STR 258 { 259 const struct auth *ca; 260 261 ca = auth_new_chap(auth_group, $2, $3); 262 free($2); 263 free($3); 264 if (ca == NULL) 265 return (1); 266 } 267 ; 268 269auth_group_chap_mutual: CHAP_MUTUAL STR STR STR STR 270 { 271 const struct auth *ca; 272 273 ca = auth_new_chap_mutual(auth_group, $2, $3, $4, $5); 274 free($2); 275 free($3); 276 free($4); 277 free($5); 278 if (ca == NULL) 279 return (1); 280 } 281 ; 282 283auth_group_initiator_name: INITIATOR_NAME STR 284 { 285 const struct auth_name *an; 286 287 an = auth_name_new(auth_group, $2); 288 free($2); 289 if (an == NULL) 290 return (1); 291 } 292 ; 293 294auth_group_initiator_portal: INITIATOR_PORTAL STR 295 { 296 const struct auth_portal *ap; 297 298 ap = auth_portal_new(auth_group, $2); 299 free($2); 300 if (ap == NULL) 301 return (1); 302 } 303 ; 304 305portal_group: PORTAL_GROUP portal_group_name 306 OPENING_BRACKET portal_group_entries CLOSING_BRACKET 307 { 308 portal_group = NULL; 309 } 310 ; 311 312portal_group_name: STR 313 { 314 /* 315 * Make it possible to redefine default 316 * portal-group. but only once. 317 */ 318 if (strcmp($1, "default") == 0 && 319 conf->conf_default_pg_defined == false) { 320 portal_group = portal_group_find(conf, $1); 321 conf->conf_default_pg_defined = true; 322 } else { 323 portal_group = portal_group_new(conf, $1); 324 } 325 free($1); 326 if (portal_group == NULL) 327 return (1); 328 } 329 ; 330 331portal_group_entries: 332 | 333 portal_group_entries portal_group_entry 334 | 335 portal_group_entries portal_group_entry SEMICOLON 336 ; 337 338portal_group_entry: 339 portal_group_discovery_auth_group 340 | 341 portal_group_discovery_filter 342 | 343 portal_group_foreign 344 | 345 portal_group_listen 346 | 347 portal_group_listen_iser 348 | 349 portal_group_offload 350 | 351 portal_group_option 352 | 353 portal_group_redirect 354 | 355 portal_group_tag 356 ; 357 358portal_group_discovery_auth_group: DISCOVERY_AUTH_GROUP STR 359 { 360 if (portal_group->pg_discovery_auth_group != NULL) { 361 log_warnx("discovery-auth-group for portal-group " 362 "\"%s\" specified more than once", 363 portal_group->pg_name); 364 return (1); 365 } 366 portal_group->pg_discovery_auth_group = 367 auth_group_find(conf, $2); 368 if (portal_group->pg_discovery_auth_group == NULL) { 369 log_warnx("unknown discovery-auth-group \"%s\" " 370 "for portal-group \"%s\"", 371 $2, portal_group->pg_name); 372 return (1); 373 } 374 free($2); 375 } 376 ; 377 378portal_group_discovery_filter: DISCOVERY_FILTER STR 379 { 380 int error; 381 382 error = portal_group_set_filter(portal_group, $2); 383 free($2); 384 if (error != 0) 385 return (1); 386 } 387 ; 388 389portal_group_foreign: FOREIGN 390 { 391 392 portal_group->pg_foreign = 1; 393 } 394 ; 395 396portal_group_listen: LISTEN STR 397 { 398 int error; 399 400 error = portal_group_add_listen(portal_group, $2, false); 401 free($2); 402 if (error != 0) 403 return (1); 404 } 405 ; 406 407portal_group_listen_iser: LISTEN_ISER STR 408 { 409 int error; 410 411 error = portal_group_add_listen(portal_group, $2, true); 412 free($2); 413 if (error != 0) 414 return (1); 415 } 416 ; 417 418portal_group_offload: OFFLOAD STR 419 { 420 int error; 421 422 error = portal_group_set_offload(portal_group, $2); 423 free($2); 424 if (error != 0) 425 return (1); 426 } 427 ; 428 429portal_group_option: OPTION STR STR 430 { 431 struct option *o; 432 433 o = option_new(&portal_group->pg_options, $2, $3); 434 free($2); 435 free($3); 436 if (o == NULL) 437 return (1); 438 } 439 ; 440 441portal_group_redirect: REDIRECT STR 442 { 443 int error; 444 445 error = portal_group_set_redirection(portal_group, $2); 446 free($2); 447 if (error != 0) 448 return (1); 449 } 450 ; 451 452portal_group_tag: TAG STR 453 { 454 uint64_t tmp; 455 456 if (expand_number($2, &tmp) != 0) { 457 yyerror("invalid numeric value"); 458 free($2); 459 return (1); 460 } 461 462 portal_group->pg_tag = tmp; 463 } 464 ; 465 466lun: LUN lun_name 467 OPENING_BRACKET lun_entries CLOSING_BRACKET 468 { 469 lun = NULL; 470 } 471 ; 472 473lun_name: STR 474 { 475 lun = lun_new(conf, $1); 476 free($1); 477 if (lun == NULL) 478 return (1); 479 } 480 ; 481 482target: TARGET target_name 483 OPENING_BRACKET target_entries CLOSING_BRACKET 484 { 485 target = NULL; 486 } 487 ; 488 489target_name: STR 490 { 491 target = target_new(conf, $1); 492 free($1); 493 if (target == NULL) 494 return (1); 495 } 496 ; 497 498target_entries: 499 | 500 target_entries target_entry 501 | 502 target_entries target_entry SEMICOLON 503 ; 504 505target_entry: 506 target_alias 507 | 508 target_auth_group 509 | 510 target_auth_type 511 | 512 target_chap 513 | 514 target_chap_mutual 515 | 516 target_initiator_name 517 | 518 target_initiator_portal 519 | 520 target_portal_group 521 | 522 target_port 523 | 524 target_redirect 525 | 526 target_lun 527 | 528 target_lun_ref 529 ; 530 531target_alias: ALIAS STR 532 { 533 if (target->t_alias != NULL) { 534 log_warnx("alias for target \"%s\" " 535 "specified more than once", target->t_name); 536 return (1); 537 } 538 target->t_alias = $2; 539 } 540 ; 541 542target_auth_group: AUTH_GROUP STR 543 { 544 if (target->t_auth_group != NULL) { 545 if (target->t_auth_group->ag_name != NULL) 546 log_warnx("auth-group for target \"%s\" " 547 "specified more than once", target->t_name); 548 else 549 log_warnx("cannot use both auth-group and explicit " 550 "authorisations for target \"%s\"", 551 target->t_name); 552 return (1); 553 } 554 target->t_auth_group = auth_group_find(conf, $2); 555 if (target->t_auth_group == NULL) { 556 log_warnx("unknown auth-group \"%s\" for target " 557 "\"%s\"", $2, target->t_name); 558 return (1); 559 } 560 free($2); 561 } 562 ; 563 564target_auth_type: AUTH_TYPE STR 565 { 566 int error; 567 568 if (target->t_auth_group != NULL) { 569 if (target->t_auth_group->ag_name != NULL) { 570 log_warnx("cannot use both auth-group and " 571 "auth-type for target \"%s\"", 572 target->t_name); 573 return (1); 574 } 575 } else { 576 target->t_auth_group = auth_group_new(conf, NULL); 577 if (target->t_auth_group == NULL) { 578 free($2); 579 return (1); 580 } 581 target->t_auth_group->ag_target = target; 582 } 583 error = auth_group_set_type(target->t_auth_group, $2); 584 free($2); 585 if (error != 0) 586 return (1); 587 } 588 ; 589 590target_chap: CHAP STR STR 591 { 592 const struct auth *ca; 593 594 if (target->t_auth_group != NULL) { 595 if (target->t_auth_group->ag_name != NULL) { 596 log_warnx("cannot use both auth-group and " 597 "chap for target \"%s\"", 598 target->t_name); 599 free($2); 600 free($3); 601 return (1); 602 } 603 } else { 604 target->t_auth_group = auth_group_new(conf, NULL); 605 if (target->t_auth_group == NULL) { 606 free($2); 607 free($3); 608 return (1); 609 } 610 target->t_auth_group->ag_target = target; 611 } 612 ca = auth_new_chap(target->t_auth_group, $2, $3); 613 free($2); 614 free($3); 615 if (ca == NULL) 616 return (1); 617 } 618 ; 619 620target_chap_mutual: CHAP_MUTUAL STR STR STR STR 621 { 622 const struct auth *ca; 623 624 if (target->t_auth_group != NULL) { 625 if (target->t_auth_group->ag_name != NULL) { 626 log_warnx("cannot use both auth-group and " 627 "chap-mutual for target \"%s\"", 628 target->t_name); 629 free($2); 630 free($3); 631 free($4); 632 free($5); 633 return (1); 634 } 635 } else { 636 target->t_auth_group = auth_group_new(conf, NULL); 637 if (target->t_auth_group == NULL) { 638 free($2); 639 free($3); 640 free($4); 641 free($5); 642 return (1); 643 } 644 target->t_auth_group->ag_target = target; 645 } 646 ca = auth_new_chap_mutual(target->t_auth_group, 647 $2, $3, $4, $5); 648 free($2); 649 free($3); 650 free($4); 651 free($5); 652 if (ca == NULL) 653 return (1); 654 } 655 ; 656 657target_initiator_name: INITIATOR_NAME STR 658 { 659 const struct auth_name *an; 660 661 if (target->t_auth_group != NULL) { 662 if (target->t_auth_group->ag_name != NULL) { 663 log_warnx("cannot use both auth-group and " 664 "initiator-name for target \"%s\"", 665 target->t_name); 666 free($2); 667 return (1); 668 } 669 } else { 670 target->t_auth_group = auth_group_new(conf, NULL); 671 if (target->t_auth_group == NULL) { 672 free($2); 673 return (1); 674 } 675 target->t_auth_group->ag_target = target; 676 } 677 an = auth_name_new(target->t_auth_group, $2); 678 free($2); 679 if (an == NULL) 680 return (1); 681 } 682 ; 683 684target_initiator_portal: INITIATOR_PORTAL STR 685 { 686 const struct auth_portal *ap; 687 688 if (target->t_auth_group != NULL) { 689 if (target->t_auth_group->ag_name != NULL) { 690 log_warnx("cannot use both auth-group and " 691 "initiator-portal for target \"%s\"", 692 target->t_name); 693 free($2); 694 return (1); 695 } 696 } else { 697 target->t_auth_group = auth_group_new(conf, NULL); 698 if (target->t_auth_group == NULL) { 699 free($2); 700 return (1); 701 } 702 target->t_auth_group->ag_target = target; 703 } 704 ap = auth_portal_new(target->t_auth_group, $2); 705 free($2); 706 if (ap == NULL) 707 return (1); 708 } 709 ; 710 711target_portal_group: PORTAL_GROUP STR STR 712 { 713 struct portal_group *tpg; 714 struct auth_group *tag; 715 struct port *tp; 716 717 tpg = portal_group_find(conf, $2); 718 if (tpg == NULL) { 719 log_warnx("unknown portal-group \"%s\" for target " 720 "\"%s\"", $2, target->t_name); 721 free($2); 722 free($3); 723 return (1); 724 } 725 tag = auth_group_find(conf, $3); 726 if (tag == NULL) { 727 log_warnx("unknown auth-group \"%s\" for target " 728 "\"%s\"", $3, target->t_name); 729 free($2); 730 free($3); 731 return (1); 732 } 733 tp = port_new(conf, target, tpg); 734 if (tp == NULL) { 735 log_warnx("can't link portal-group \"%s\" to target " 736 "\"%s\"", $2, target->t_name); 737 free($2); 738 return (1); 739 } 740 tp->p_auth_group = tag; 741 free($2); 742 free($3); 743 } 744 | PORTAL_GROUP STR 745 { 746 struct portal_group *tpg; 747 struct port *tp; 748 749 tpg = portal_group_find(conf, $2); 750 if (tpg == NULL) { 751 log_warnx("unknown portal-group \"%s\" for target " 752 "\"%s\"", $2, target->t_name); 753 free($2); 754 return (1); 755 } 756 tp = port_new(conf, target, tpg); 757 if (tp == NULL) { 758 log_warnx("can't link portal-group \"%s\" to target " 759 "\"%s\"", $2, target->t_name); 760 free($2); 761 return (1); 762 } 763 free($2); 764 } 765 ; 766 767target_port: PORT STR 768 { 769 struct pport *pp; 770 struct port *tp; 771 772 pp = pport_find(conf, $2); 773 if (pp == NULL) { 774 log_warnx("unknown port \"%s\" for target \"%s\"", 775 $2, target->t_name); 776 free($2); 777 return (1); 778 } 779 if (!TAILQ_EMPTY(&pp->pp_ports)) { 780 log_warnx("can't link port \"%s\" to target \"%s\", " 781 "port already linked to some target", 782 $2, target->t_name); 783 free($2); 784 return (1); 785 } 786 tp = port_new_pp(conf, target, pp); 787 if (tp == NULL) { 788 log_warnx("can't link port \"%s\" to target \"%s\"", 789 $2, target->t_name); 790 free($2); 791 return (1); 792 } 793 free($2); 794 } 795 ; 796 797target_redirect: REDIRECT STR 798 { 799 int error; 800 801 error = target_set_redirection(target, $2); 802 free($2); 803 if (error != 0) 804 return (1); 805 } 806 ; 807 808target_lun: LUN lun_number 809 OPENING_BRACKET lun_entries CLOSING_BRACKET 810 { 811 lun = NULL; 812 } 813 ; 814 815lun_number: STR 816 { 817 uint64_t tmp; 818 int ret; 819 char *name; 820 821 if (expand_number($1, &tmp) != 0) { 822 yyerror("invalid numeric value"); 823 free($1); 824 return (1); 825 } 826 if (tmp >= MAX_LUNS) { 827 yyerror("LU number is too big"); 828 free($1); 829 return (1); 830 } 831 832 ret = asprintf(&name, "%s,lun,%ju", target->t_name, tmp); 833 if (ret <= 0) 834 log_err(1, "asprintf"); 835 lun = lun_new(conf, name); 836 if (lun == NULL) 837 return (1); 838 839 lun_set_scsiname(lun, name); 840 target->t_luns[tmp] = lun; 841 } 842 ; 843 844target_lun_ref: LUN STR STR 845 { 846 uint64_t tmp; 847 848 if (expand_number($2, &tmp) != 0) { 849 yyerror("invalid numeric value"); 850 free($2); 851 free($3); 852 return (1); 853 } 854 free($2); 855 if (tmp >= MAX_LUNS) { 856 yyerror("LU number is too big"); 857 free($3); 858 return (1); 859 } 860 861 lun = lun_find(conf, $3); 862 free($3); 863 if (lun == NULL) 864 return (1); 865 866 target->t_luns[tmp] = lun; 867 } 868 ; 869 870lun_entries: 871 | 872 lun_entries lun_entry 873 | 874 lun_entries lun_entry SEMICOLON 875 ; 876 877lun_entry: 878 lun_backend 879 | 880 lun_blocksize 881 | 882 lun_device_id 883 | 884 lun_device_type 885 | 886 lun_ctl_lun 887 | 888 lun_option 889 | 890 lun_path 891 | 892 lun_serial 893 | 894 lun_size 895 ; 896 897lun_backend: BACKEND STR 898 { 899 if (lun->l_backend != NULL) { 900 log_warnx("backend for lun \"%s\" " 901 "specified more than once", 902 lun->l_name); 903 free($2); 904 return (1); 905 } 906 lun_set_backend(lun, $2); 907 free($2); 908 } 909 ; 910 911lun_blocksize: BLOCKSIZE STR 912 { 913 uint64_t tmp; 914 915 if (expand_number($2, &tmp) != 0) { 916 yyerror("invalid numeric value"); 917 free($2); 918 return (1); 919 } 920 921 if (lun->l_blocksize != 0) { 922 log_warnx("blocksize for lun \"%s\" " 923 "specified more than once", 924 lun->l_name); 925 return (1); 926 } 927 lun_set_blocksize(lun, tmp); 928 } 929 ; 930 931lun_device_id: DEVICE_ID STR 932 { 933 if (lun->l_device_id != NULL) { 934 log_warnx("device_id for lun \"%s\" " 935 "specified more than once", 936 lun->l_name); 937 free($2); 938 return (1); 939 } 940 lun_set_device_id(lun, $2); 941 free($2); 942 } 943 ; 944 945lun_device_type: DEVICE_TYPE STR 946 { 947 uint64_t tmp; 948 949 if (strcasecmp($2, "disk") == 0 || 950 strcasecmp($2, "direct") == 0) 951 tmp = 0; 952 else if (strcasecmp($2, "processor") == 0) 953 tmp = 3; 954 else if (strcasecmp($2, "cd") == 0 || 955 strcasecmp($2, "cdrom") == 0 || 956 strcasecmp($2, "dvd") == 0 || 957 strcasecmp($2, "dvdrom") == 0) 958 tmp = 5; 959 else if (expand_number($2, &tmp) != 0 || 960 tmp > 15) { 961 yyerror("invalid numeric value"); 962 free($2); 963 return (1); 964 } 965 966 lun_set_device_type(lun, tmp); 967 } 968 ; 969 970lun_ctl_lun: CTL_LUN STR 971 { 972 uint64_t tmp; 973 974 if (expand_number($2, &tmp) != 0) { 975 yyerror("invalid numeric value"); 976 free($2); 977 return (1); 978 } 979 980 if (lun->l_ctl_lun >= 0) { 981 log_warnx("ctl_lun for lun \"%s\" " 982 "specified more than once", 983 lun->l_name); 984 return (1); 985 } 986 lun_set_ctl_lun(lun, tmp); 987 } 988 ; 989 990lun_option: OPTION STR STR 991 { 992 struct option *o; 993 994 o = option_new(&lun->l_options, $2, $3); 995 free($2); 996 free($3); 997 if (o == NULL) 998 return (1); 999 } 1000 ; 1001 1002lun_path: PATH STR 1003 { 1004 if (lun->l_path != NULL) { 1005 log_warnx("path for lun \"%s\" " 1006 "specified more than once", 1007 lun->l_name); 1008 free($2); 1009 return (1); 1010 } 1011 lun_set_path(lun, $2); 1012 free($2); 1013 } 1014 ; 1015 1016lun_serial: SERIAL STR 1017 { 1018 if (lun->l_serial != NULL) { 1019 log_warnx("serial for lun \"%s\" " 1020 "specified more than once", 1021 lun->l_name); 1022 free($2); 1023 return (1); 1024 } 1025 lun_set_serial(lun, $2); 1026 free($2); 1027 } 1028 ; 1029 1030lun_size: SIZE STR 1031 { 1032 uint64_t tmp; 1033 1034 if (expand_number($2, &tmp) != 0) { 1035 yyerror("invalid numeric value"); 1036 free($2); 1037 return (1); 1038 } 1039 1040 if (lun->l_size != 0) { 1041 log_warnx("size for lun \"%s\" " 1042 "specified more than once", 1043 lun->l_name); 1044 return (1); 1045 } 1046 lun_set_size(lun, tmp); 1047 } 1048 ; 1049%% 1050 1051void 1052yyerror(const char *str) 1053{ 1054 1055 log_warnx("error in configuration file at line %d near '%s': %s", 1056 lineno, yytext, str); 1057} 1058 1059int 1060parse_conf(struct conf *newconf, const char *path) 1061{ 1062 int error; 1063 1064 conf = newconf; 1065 yyin = fopen(path, "r"); 1066 if (yyin == NULL) { 1067 log_warn("unable to open configuration file %s", path); 1068 return (1); 1069 } 1070 1071 lineno = 1; 1072 yyrestart(yyin); 1073 error = yyparse(); 1074 auth_group = NULL; 1075 portal_group = NULL; 1076 target = NULL; 1077 lun = NULL; 1078 fclose(yyin); 1079 1080 return (error); 1081} 1082