usr.sbin/ctld/parse.y

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