usr.sbin/ctld/parse.y

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