sbin/hastd/parse.y

   1 %{
   2 /*-
   3  * Copyright (c) 2009-2010 The FreeBSD Foundation
   4  * All rights reserved.
   5  *
   6  * This software was developed by Pawel Jakub Dawidek under sponsorship from
   7  * 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 AUTHORS 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 AUTHORS 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/param.h>  /* MAXHOSTNAMELEN */
  34 #include <sys/queue.h>
  35 #include <sys/sysctl.h>
  36
  37 #include <arpa/inet.h>
  38
  39 #include <assert.h>
  40 #include <err.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <sysexits.h>
  44 #include <unistd.h>
  45
  46 #include <pjdlog.h>
  47
  48 #include "hast.h"
  49
  50 extern int depth;
  51 extern int lineno;
  52
  53 extern FILE *yyin;
  54 extern char *yytext;
  55
  56 static struct hastd_config *lconfig;
  57 static struct hast_resource *curres;
  58 static bool mynode;
  59
  60 static char depth0_control[HAST_ADDRSIZE];
  61 static char depth0_listen[HAST_ADDRSIZE];
  62 static int depth0_replication;
  63 static int depth0_timeout;
  64 static char depth0_exec[PATH_MAX];
  65
  66 static char depth1_provname[PATH_MAX];
  67 static char depth1_localpath[PATH_MAX];
  68
  69 extern void yyrestart(FILE *);
  70
  71 static int
  72 isitme(const char *name)
  73 {
  74         char buf[MAXHOSTNAMELEN];
  75         char *pos;
  76         size_t bufsize;
  77
  78         /*
  79          * First check if the give name matches our full hostname.
  80          */
  81         if (gethostname(buf, sizeof(buf)) < 0) {
  82                 pjdlog_errno(LOG_ERR, "gethostname() failed");
  83                 return (-1);
  84         }
  85         if (strcmp(buf, name) == 0)
  86                 return (1);
  87
  88         /*
  89          * Now check if it matches first part of the host name.
  90          */
  91         pos = strchr(buf, '.');
  92         if (pos != NULL && pos != buf && strncmp(buf, name, pos - buf) == 0)
  93                 return (1);
  94
  95         /*
  96          * At the end check if name is equal to our host's UUID.
  97          */
  98         bufsize = sizeof(buf);
  99         if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
 100                 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
 101                 return (-1);
 102         }
 103         if (strcasecmp(buf, name) == 0)
 104                 return (1);
 105
 106         /*
 107          * Looks like this isn't about us.
 108          */
 109         return (0);
 110 }
 111
 112 void
 113 yyerror(const char *str)
 114 {
 115
 116         pjdlog_error("Unable to parse configuration file at line %d near '%s': %s",
 117             lineno, yytext, str);
 118 }
 119
 120 struct hastd_config *
 121 yy_config_parse(const char *config, bool exitonerror)
 122 {
 123         int ret;
 124
 125         curres = NULL;
 126         mynode = false;
 127         depth = 0;
 128         lineno = 0;
 129
 130         depth0_timeout = HAST_TIMEOUT;
 131         depth0_replication = HAST_REPLICATION_MEMSYNC;
 132         strlcpy(depth0_control, HAST_CONTROL, sizeof(depth0_control));
 133         strlcpy(depth0_listen, HASTD_LISTEN, sizeof(depth0_listen));
 134         depth0_exec[0] = '\0';
 135
 136         lconfig = calloc(1, sizeof(*lconfig));
 137         if (lconfig == NULL) {
 138                 pjdlog_error("Unable to allocate memory for configuration.");
 139                 if (exitonerror)
 140                         exit(EX_TEMPFAIL);
 141                 return (NULL);
 142         }
 143
 144         TAILQ_INIT(&lconfig->hc_resources);
 145
 146         yyin = fopen(config, "r");
 147         if (yyin == NULL) {
 148                 pjdlog_errno(LOG_ERR, "Unable to open configuration file %s",
 149                     config);
 150                 yy_config_free(lconfig);
 151                 if (exitonerror)
 152                         exit(EX_OSFILE);
 153                 return (NULL);
 154         }
 155         yyrestart(yyin);
 156         ret = yyparse();
 157         fclose(yyin);
 158         if (ret != 0) {
 159                 yy_config_free(lconfig);
 160                 if (exitonerror)
 161                         exit(EX_CONFIG);
 162                 return (NULL);
 163         }
 164
 165         /*
 166          * Let's see if everything is set up.
 167          */
 168         if (lconfig->hc_controladdr[0] == '\0') {
 169                 strlcpy(lconfig->hc_controladdr, depth0_control,
 170                     sizeof(lconfig->hc_controladdr));
 171         }
 172         if (lconfig->hc_listenaddr[0] == '\0') {
 173                 strlcpy(lconfig->hc_listenaddr, depth0_listen,
 174                     sizeof(lconfig->hc_listenaddr));
 175         }
 176         TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) {
 177                 assert(curres->hr_provname[0] != '\0');
 178                 assert(curres->hr_localpath[0] != '\0');
 179                 assert(curres->hr_remoteaddr[0] != '\0');
 180
 181                 if (curres->hr_replication == -1) {
 182                         /*
 183                          * Replication is not set at resource-level.
 184                          * Use global or default setting.
 185                          */
 186                         curres->hr_replication = depth0_replication;
 187                 }
 188                 if (curres->hr_timeout == -1) {
 189                         /*
 190                          * Timeout is not set at resource-level.
 191                          * Use global or default setting.
 192                          */
 193                         curres->hr_timeout = depth0_timeout;
 194                 }
 195                 if (curres->hr_exec[0] == '\0') {
 196                         /*
 197                          * Exec is not set at resource-level.
 198                          * Use global or default setting.
 199                          */
 200                         strlcpy(curres->hr_exec, depth0_exec,
 201                             sizeof(curres->hr_exec));
 202                 }
 203         }
 204
 205         return (lconfig);
 206 }
 207
 208 void
 209 yy_config_free(struct hastd_config *config)
 210 {
 211         struct hast_resource *res;
 212
 213         while ((res = TAILQ_FIRST(&config->hc_resources)) != NULL) {
 214                 TAILQ_REMOVE(&config->hc_resources, res, hr_next);
 215                 free(res);
 216         }
 217         free(config);
 218 }
 219 %}
 220
 221 %token CONTROL LISTEN PORT REPLICATION TIMEOUT EXEC EXTENTSIZE RESOURCE NAME LOCAL REMOTE ON
 222 %token FULLSYNC MEMSYNC ASYNC
 223 %token NUM STR OB CB
 224
 225 %type <num> replication_type
 226
 227 %union
 228 {
 229         int num;
 230         char *str;
 231 }
 232
 233 %token <num> NUM
 234 %token <str> STR
 235
 236 %%
 237
 238 statements:
 239         |
 240         statements statement
 241         ;
 242
 243 statement:
 244         control_statement
 245         |
 246         listen_statement
 247         |
 248         replication_statement
 249         |
 250         timeout_statement
 251         |
 252         exec_statement
 253         |
 254         node_statement
 255         |
 256         resource_statement
 257         ;
 258
 259 control_statement:      CONTROL STR
 260         {
 261                 switch (depth) {
 262                 case 0:
 263                         if (strlcpy(depth0_control, $2,
 264                             sizeof(depth0_control)) >=
 265                             sizeof(depth0_control)) {
 266                                 pjdlog_error("control argument is too long.");
 267                                 return (1);
 268                         }
 269                         break;
 270                 case 1:
 271                         if (!mynode)
 272                                 break;
 273                         if (strlcpy(lconfig->hc_controladdr, $2,
 274                             sizeof(lconfig->hc_controladdr)) >=
 275                             sizeof(lconfig->hc_controladdr)) {
 276                                 pjdlog_error("control argument is too long.");
 277                                 return (1);
 278                         }
 279                         break;
 280                 default:
 281                         assert(!"control at wrong depth level");
 282                 }
 283         }
 284         ;
 285
 286 listen_statement:       LISTEN STR
 287         {
 288                 switch (depth) {
 289                 case 0:
 290                         if (strlcpy(depth0_listen, $2,
 291                             sizeof(depth0_listen)) >=
 292                             sizeof(depth0_listen)) {
 293                                 pjdlog_error("listen argument is too long.");
 294                                 return (1);
 295                         }
 296                         break;
 297                 case 1:
 298                         if (!mynode)
 299                                 break;
 300                         if (strlcpy(lconfig->hc_listenaddr, $2,
 301                             sizeof(lconfig->hc_listenaddr)) >=
 302                             sizeof(lconfig->hc_listenaddr)) {
 303                                 pjdlog_error("listen argument is too long.");
 304                                 return (1);
 305                         }
 306                         break;
 307                 default:
 308                         assert(!"listen at wrong depth level");
 309                 }
 310         }
 311         ;
 312
 313 replication_statement:  REPLICATION replication_type
 314         {
 315                 switch (depth) {
 316                 case 0:
 317                         depth0_replication = $2;
 318                         break;
 319                 case 1:
 320                         if (curres != NULL)
 321                                 curres->hr_replication = $2;
 322                         break;
 323                 default:
 324                         assert(!"replication at wrong depth level");
 325                 }
 326         }
 327         ;
 328
 329 replication_type:
 330         FULLSYNC        { $$ = HAST_REPLICATION_FULLSYNC; }
 331         |
 332         MEMSYNC         { $$ = HAST_REPLICATION_MEMSYNC; }
 333         |
 334         ASYNC           { $$ = HAST_REPLICATION_ASYNC; }
 335         ;
 336
 337 timeout_statement:      TIMEOUT NUM
 338         {
 339                 switch (depth) {
 340                 case 0:
 341                         depth0_timeout = $2;
 342                         break;
 343                 case 1:
 344                         if (curres != NULL)
 345                                 curres->hr_timeout = $2;
 346                         break;
 347                 default:
 348                         assert(!"timeout at wrong depth level");
 349                 }
 350         }
 351         ;
 352
 353 exec_statement:         EXEC STR
 354         {
 355                 switch (depth) {
 356                 case 0:
 357                         if (strlcpy(depth0_exec, $2, sizeof(depth0_exec)) >=
 358                             sizeof(depth0_exec)) {
 359                                 pjdlog_error("Exec path is too long.");
 360                                 return (1);
 361                         }
 362                         break;
 363                 case 1:
 364                         if (curres == NULL)
 365                                 break;
 366                         if (strlcpy(curres->hr_exec, $2,
 367                             sizeof(curres->hr_exec)) >=
 368                             sizeof(curres->hr_exec)) {
 369                                 pjdlog_error("Exec path is too long.");
 370                                 return (1);
 371                         }
 372                         break;
 373                 default:
 374                         assert(!"exec at wrong depth level");
 375                 }
 376         }
 377         ;
 378
 379 node_statement:         ON node_start OB node_entries CB
 380         {
 381                 mynode = false;
 382         }
 383         ;
 384
 385 node_start:     STR
 386         {
 387                 switch (isitme($1)) {
 388                 case -1:
 389                         return (1);
 390                 case 0:
 391                         break;
 392                 case 1:
 393                         mynode = true;
 394                         break;
 395                 default:
 396                         assert(!"invalid isitme() return value");
 397                 }
 398         }
 399         ;
 400
 401 node_entries:
 402         |
 403         node_entries node_entry
 404         ;
 405
 406 node_entry:
 407         control_statement
 408         |
 409         listen_statement
 410         ;
 411
 412 resource_statement:     RESOURCE resource_start OB resource_entries CB
 413         {
 414                 if (curres != NULL) {
 415                         /*
 416                          * Let's see there are some resource-level settings
 417                          * that we can use for node-level settings.
 418                          */
 419                         if (curres->hr_provname[0] == '\0' &&
 420                             depth1_provname[0] != '\0') {
 421                                 /*
 422                                  * Provider name is not set at node-level,
 423                                  * but is set at resource-level, use it.
 424                                  */
 425                                 strlcpy(curres->hr_provname, depth1_provname,
 426                                     sizeof(curres->hr_provname));
 427                         }
 428                         if (curres->hr_localpath[0] == '\0' &&
 429                             depth1_localpath[0] != '\0') {
 430                                 /*
 431                                  * Path to local provider is not set at
 432                                  * node-level, but is set at resource-level,
 433                                  * use it.
 434                                  */
 435                                 strlcpy(curres->hr_localpath, depth1_localpath,
 436                                     sizeof(curres->hr_localpath));
 437                         }
 438
 439                         /*
 440                          * If provider name is not given, use resource name
 441                          * as provider name.
 442                          */
 443                         if (curres->hr_provname[0] == '\0') {
 444                                 strlcpy(curres->hr_provname, curres->hr_name,
 445                                     sizeof(curres->hr_provname));
 446                         }
 447
 448                         /*
 449                          * Remote address has to be configured at this point.
 450                          */
 451                         if (curres->hr_remoteaddr[0] == '\0') {
 452                                 pjdlog_error("Remote address not configured for resource %s.",
 453                                     curres->hr_name);
 454                                 return (1);
 455                         }
 456                         /*
 457                          * Path to local provider has to be configured at this
 458                          * point.
 459                          */
 460                         if (curres->hr_localpath[0] == '\0') {
 461                                 pjdlog_error("Path to local component not configured for resource %s.",
 462                                     curres->hr_name);
 463                                 return (1);
 464                         }
 465
 466                         /* Put it onto resource list. */
 467                         TAILQ_INSERT_TAIL(&lconfig->hc_resources, curres, hr_next);
 468                         curres = NULL;
 469                 }
 470         }
 471         ;
 472
 473 resource_start: STR
 474         {
 475                 /*
 476                  * Clear those, so we can tell if they were set at
 477                  * resource-level or not.
 478                  */
 479                 depth1_provname[0] = '\0';
 480                 depth1_localpath[0] = '\0';
 481
 482                 curres = calloc(1, sizeof(*curres));
 483                 if (curres == NULL) {
 484                         pjdlog_error("Unable to allocate memory for resource.");
 485                         return (1);
 486                 }
 487                 if (strlcpy(curres->hr_name, $1,
 488                     sizeof(curres->hr_name)) >=
 489                     sizeof(curres->hr_name)) {
 490                         pjdlog_error("Resource name is too long.");
 491                         return (1);
 492                 }
 493                 curres->hr_role = HAST_ROLE_INIT;
 494                 curres->hr_previous_role = HAST_ROLE_INIT;
 495                 curres->hr_replication = -1;
 496                 curres->hr_timeout = -1;
 497                 curres->hr_exec[0] = '\0';
 498                 curres->hr_provname[0] = '\0';
 499                 curres->hr_localpath[0] = '\0';
 500                 curres->hr_localfd = -1;
 501                 curres->hr_remoteaddr[0] = '\0';
 502                 curres->hr_ggateunit = -1;
 503         }
 504         ;
 505
 506 resource_entries:
 507         |
 508         resource_entries resource_entry
 509         ;
 510
 511 resource_entry:
 512         replication_statement
 513         |
 514         timeout_statement
 515         |
 516         exec_statement
 517         |
 518         name_statement
 519         |
 520         local_statement
 521         |
 522         resource_node_statement
 523         ;
 524
 525 name_statement:         NAME STR
 526         {
 527                 switch (depth) {
 528                 case 1:
 529                         if (strlcpy(depth1_provname, $2,
 530                             sizeof(depth1_provname)) >=
 531                             sizeof(depth1_provname)) {
 532                                 pjdlog_error("name argument is too long.");
 533                                 return (1);
 534                         }
 535                         break;
 536                 case 2:
 537                         if (!mynode)
 538                                 break;
 539                         assert(curres != NULL);
 540                         if (strlcpy(curres->hr_provname, $2,
 541                             sizeof(curres->hr_provname)) >=
 542                             sizeof(curres->hr_provname)) {
 543                                 pjdlog_error("name argument is too long.");
 544                                 return (1);
 545                         }
 546                         break;
 547                 default:
 548                         assert(!"name at wrong depth level");
 549                 }
 550         }
 551         ;
 552
 553 local_statement:        LOCAL STR
 554         {
 555                 switch (depth) {
 556                 case 1:
 557                         if (strlcpy(depth1_localpath, $2,
 558                             sizeof(depth1_localpath)) >=
 559                             sizeof(depth1_localpath)) {
 560                                 pjdlog_error("local argument is too long.");
 561                                 return (1);
 562                         }
 563                         break;
 564                 case 2:
 565                         if (!mynode)
 566                                 break;
 567                         assert(curres != NULL);
 568                         if (strlcpy(curres->hr_localpath, $2,
 569                             sizeof(curres->hr_localpath)) >=
 570                             sizeof(curres->hr_localpath)) {
 571                                 pjdlog_error("local argument is too long.");
 572                                 return (1);
 573                         }
 574                         break;
 575                 default:
 576                         assert(!"local at wrong depth level");
 577                 }
 578         }
 579         ;
 580
 581 resource_node_statement:ON resource_node_start OB resource_node_entries CB
 582         {
 583                 mynode = false;
 584         }
 585         ;
 586
 587 resource_node_start:    STR
 588         {
 589                 if (curres != NULL) {
 590                         switch (isitme($1)) {
 591                         case -1:
 592                                 return (1);
 593                         case 0:
 594                                 break;
 595                         case 1:
 596                                 mynode = true;
 597                                 break;
 598                         default:
 599                                 assert(!"invalid isitme() return value");
 600                         }
 601                 }
 602         }
 603         ;
 604
 605 resource_node_entries:
 606         |
 607         resource_node_entries resource_node_entry
 608         ;
 609
 610 resource_node_entry:
 611         name_statement
 612         |
 613         local_statement
 614         |
 615         remote_statement
 616         ;
 617
 618 remote_statement:       REMOTE STR
 619         {
 620                 assert(depth == 2);
 621                 if (mynode) {
 622                         assert(curres != NULL);
 623                         if (strlcpy(curres->hr_remoteaddr, $2,
 624                             sizeof(curres->hr_remoteaddr)) >=
 625                             sizeof(curres->hr_remoteaddr)) {
 626                                 pjdlog_error("remote argument is too long.");
 627                                 return (1);
 628                         }
 629                 }
 630         }
 631         ;