sbin/hastd/parse.y

   1 %{
   2 /*-
   3  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   4  *
   5  * Copyright (c) 2009-2010 The FreeBSD Foundation
   6  * Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>
   7  * All rights reserved.
   8  *
   9  * This software was developed by Pawel Jakub Dawidek under sponsorship from
  10  * the FreeBSD Foundation.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * $FreeBSD$
  34  */
  35
  36 #include <sys/param.h>  /* MAXHOSTNAMELEN */
  37 #include <sys/queue.h>
  38 #include <sys/socket.h>
  39 #include <sys/sysctl.h>
  40
  41 #include <arpa/inet.h>
  42
  43 #include <err.h>
  44 #include <errno.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <sysexits.h>
  48 #include <unistd.h>
  49
  50 #include <pjdlog.h>
  51
  52 #include "hast.h"
  53
  54 extern int depth;
  55 extern int lineno;
  56
  57 extern FILE *yyin;
  58 extern char *yytext;
  59
  60 static struct hastd_config *lconfig;
  61 static struct hast_resource *curres;
  62 static bool mynode, hadmynode;
  63
  64 static char depth0_control[HAST_ADDRSIZE];
  65 static char depth0_pidfile[PATH_MAX];
  66 static char depth0_listen_tcp4[HAST_ADDRSIZE];
  67 static char depth0_listen_tcp6[HAST_ADDRSIZE];
  68 static TAILQ_HEAD(, hastd_listen) depth0_listen;
  69 static int depth0_replication;
  70 static int depth0_checksum;
  71 static int depth0_compression;
  72 static int depth0_timeout;
  73 static char depth0_exec[PATH_MAX];
  74 static int depth0_metaflush;
  75
  76 static char depth1_provname[PATH_MAX];
  77 static char depth1_localpath[PATH_MAX];
  78 static int depth1_metaflush;
  79
  80 extern void yyerror(const char *);
  81 extern int yylex(void);
  82 extern void yyrestart(FILE *);
  83
  84 static int isitme(const char *name);
  85 static bool family_supported(int family);
  86 static int node_names(char **namesp);
  87 %}
  88
  89 %token CONTROL PIDFILE LISTEN REPLICATION CHECKSUM COMPRESSION METAFLUSH
  90 %token TIMEOUT EXEC RESOURCE NAME LOCAL REMOTE SOURCE ON OFF
  91 %token FULLSYNC MEMSYNC ASYNC NONE CRC32 SHA256 HOLE LZF
  92 %token NUM STR OB CB
  93
  94 %type <str> remote_str
  95 %type <num> replication_type
  96 %type <num> checksum_type
  97 %type <num> compression_type
  98 %type <num> boolean
  99
 100 %union
 101 {
 102         int num;
 103         char *str;
 104 }
 105
 106 %token <num> NUM
 107 %token <str> STR
 108
 109 %%
 110
 111 statements:
 112         |
 113         statements statement
 114         ;
 115
 116 statement:
 117         control_statement
 118         |
 119         pidfile_statement
 120         |
 121         listen_statement
 122         |
 123         replication_statement
 124         |
 125         checksum_statement
 126         |
 127         compression_statement
 128         |
 129         timeout_statement
 130         |
 131         exec_statement
 132         |
 133         metaflush_statement
 134         |
 135         node_statement
 136         |
 137         resource_statement
 138         ;
 139
 140 control_statement:      CONTROL STR
 141         {
 142                 switch (depth) {
 143                 case 0:
 144                         if (strlcpy(depth0_control, $2,
 145                             sizeof(depth0_control)) >=
 146                             sizeof(depth0_control)) {
 147                                 pjdlog_error("control argument is too long.");
 148                                 free($2);
 149                                 return (1);
 150                         }
 151                         break;
 152                 case 1:
 153                         if (!mynode)
 154                                 break;
 155                         if (strlcpy(lconfig->hc_controladdr, $2,
 156                             sizeof(lconfig->hc_controladdr)) >=
 157                             sizeof(lconfig->hc_controladdr)) {
 158                                 pjdlog_error("control argument is too long.");
 159                                 free($2);
 160                                 return (1);
 161                         }
 162                         break;
 163                 default:
 164                         PJDLOG_ABORT("control at wrong depth level");
 165                 }
 166                 free($2);
 167         }
 168         ;
 169
 170 pidfile_statement:      PIDFILE STR
 171         {
 172                 switch (depth) {
 173                 case 0:
 174                         if (strlcpy(depth0_pidfile, $2,
 175                             sizeof(depth0_pidfile)) >=
 176                             sizeof(depth0_pidfile)) {
 177                                 pjdlog_error("pidfile argument is too long.");
 178                                 free($2);
 179                                 return (1);
 180                         }
 181                         break;
 182                 case 1:
 183                         if (!mynode)
 184                                 break;
 185                         if (strlcpy(lconfig->hc_pidfile, $2,
 186                             sizeof(lconfig->hc_pidfile)) >=
 187                             sizeof(lconfig->hc_pidfile)) {
 188                                 pjdlog_error("pidfile argument is too long.");
 189                                 free($2);
 190                                 return (1);
 191                         }
 192                         break;
 193                 default:
 194                         PJDLOG_ABORT("pidfile at wrong depth level");
 195                 }
 196                 free($2);
 197         }
 198         ;
 199
 200 listen_statement:       LISTEN STR
 201         {
 202                 struct hastd_listen *lst;
 203
 204                 lst = calloc(1, sizeof(*lst));
 205                 if (lst == NULL) {
 206                         pjdlog_error("Unable to allocate memory for listen address.");
 207                         free($2);
 208                         return (1);
 209                 }
 210                 if (strlcpy(lst->hl_addr, $2, sizeof(lst->hl_addr)) >=
 211                     sizeof(lst->hl_addr)) {
 212                         pjdlog_error("listen argument is too long.");
 213                         free($2);
 214                         free(lst);
 215                         return (1);
 216                 }
 217                 switch (depth) {
 218                 case 0:
 219                         TAILQ_INSERT_TAIL(&depth0_listen, lst, hl_next);
 220                         break;
 221                 case 1:
 222                         if (mynode)
 223                                 TAILQ_INSERT_TAIL(&depth0_listen, lst, hl_next);
 224                         else
 225                                 free(lst);
 226                         break;
 227                 default:
 228                         PJDLOG_ABORT("listen at wrong depth level");
 229                 }
 230                 free($2);
 231         }
 232         ;
 233
 234 replication_statement:  REPLICATION replication_type
 235         {
 236                 switch (depth) {
 237                 case 0:
 238                         depth0_replication = $2;
 239                         break;
 240                 case 1:
 241                         PJDLOG_ASSERT(curres != NULL);
 242                         curres->hr_replication = $2;
 243                         curres->hr_original_replication = $2;
 244                         break;
 245                 default:
 246                         PJDLOG_ABORT("replication at wrong depth level");
 247                 }
 248         }
 249         ;
 250
 251 replication_type:
 252         FULLSYNC        { $$ = HAST_REPLICATION_FULLSYNC; }
 253         |
 254         MEMSYNC         { $$ = HAST_REPLICATION_MEMSYNC; }
 255         |
 256         ASYNC           { $$ = HAST_REPLICATION_ASYNC; }
 257         ;
 258
 259 checksum_statement:     CHECKSUM checksum_type
 260         {
 261                 switch (depth) {
 262                 case 0:
 263                         depth0_checksum = $2;
 264                         break;
 265                 case 1:
 266                         PJDLOG_ASSERT(curres != NULL);
 267                         curres->hr_checksum = $2;
 268                         break;
 269                 default:
 270                         PJDLOG_ABORT("checksum at wrong depth level");
 271                 }
 272         }
 273         ;
 274
 275 checksum_type:
 276         NONE            { $$ = HAST_CHECKSUM_NONE; }
 277         |
 278         CRC32           { $$ = HAST_CHECKSUM_CRC32; }
 279         |
 280         SHA256          { $$ = HAST_CHECKSUM_SHA256; }
 281         ;
 282
 283 compression_statement:  COMPRESSION compression_type
 284         {
 285                 switch (depth) {
 286                 case 0:
 287                         depth0_compression = $2;
 288                         break;
 289                 case 1:
 290                         PJDLOG_ASSERT(curres != NULL);
 291                         curres->hr_compression = $2;
 292                         break;
 293                 default:
 294                         PJDLOG_ABORT("compression at wrong depth level");
 295                 }
 296         }
 297         ;
 298
 299 compression_type:
 300         NONE            { $$ = HAST_COMPRESSION_NONE; }
 301         |
 302         HOLE            { $$ = HAST_COMPRESSION_HOLE; }
 303         |
 304         LZF             { $$ = HAST_COMPRESSION_LZF; }
 305         ;
 306
 307 timeout_statement:      TIMEOUT NUM
 308         {
 309                 if ($2 <= 0) {
 310                         pjdlog_error("Negative or zero timeout.");
 311                         return (1);
 312                 }
 313                 switch (depth) {
 314                 case 0:
 315                         depth0_timeout = $2;
 316                         break;
 317                 case 1:
 318                         PJDLOG_ASSERT(curres != NULL);
 319                         curres->hr_timeout = $2;
 320                         break;
 321                 default:
 322                         PJDLOG_ABORT("timeout at wrong depth level");
 323                 }
 324         }
 325         ;
 326
 327 exec_statement:         EXEC STR
 328         {
 329                 switch (depth) {
 330                 case 0:
 331                         if (strlcpy(depth0_exec, $2, sizeof(depth0_exec)) >=
 332                             sizeof(depth0_exec)) {
 333                                 pjdlog_error("Exec path is too long.");
 334                                 free($2);
 335                                 return (1);
 336                         }
 337                         break;
 338                 case 1:
 339                         PJDLOG_ASSERT(curres != NULL);
 340                         if (strlcpy(curres->hr_exec, $2,
 341                             sizeof(curres->hr_exec)) >=
 342                             sizeof(curres->hr_exec)) {
 343                                 pjdlog_error("Exec path is too long.");
 344                                 free($2);
 345                                 return (1);
 346                         }
 347                         break;
 348                 default:
 349                         PJDLOG_ABORT("exec at wrong depth level");
 350                 }
 351                 free($2);
 352         }
 353         ;
 354
 355 metaflush_statement:    METAFLUSH boolean
 356         {
 357                 switch (depth) {
 358                 case 0:
 359                         depth0_metaflush = $2;
 360                         break;
 361                 case 1:
 362                         PJDLOG_ASSERT(curres != NULL);
 363                         depth1_metaflush = $2;
 364                         break;
 365                 case 2:
 366                         if (!mynode)
 367                                 break;
 368                         PJDLOG_ASSERT(curres != NULL);
 369                         curres->hr_metaflush = $2;
 370                         break;
 371                 default:
 372                         PJDLOG_ABORT("metaflush at wrong depth level");
 373                 }
 374         }
 375         ;
 376
 377 boolean:
 378         ON              { $$ = 1; }
 379         |
 380         OFF             { $$ = 0; }
 381         ;
 382
 383 node_statement:         ON node_start OB node_entries CB
 384         {
 385                 mynode = false;
 386         }
 387         ;
 388
 389 node_start:     STR
 390         {
 391                 switch (isitme($1)) {
 392                 case -1:
 393                         free($1);
 394                         return (1);
 395                 case 0:
 396                         break;
 397                 case 1:
 398                         mynode = true;
 399                         break;
 400                 default:
 401                         PJDLOG_ABORT("invalid isitme() return value");
 402                 }
 403                 free($1);
 404         }
 405         ;
 406
 407 node_entries:
 408         |
 409         node_entries node_entry
 410         ;
 411
 412 node_entry:
 413         control_statement
 414         |
 415         pidfile_statement
 416         |
 417         listen_statement
 418         ;
 419
 420 resource_statement:     RESOURCE resource_start OB resource_entries CB
 421         {
 422                 if (curres != NULL) {
 423                         /*
 424                          * There must be section for this node, at least with
 425                          * remote address configuration.
 426                          */
 427                         if (!hadmynode) {
 428                                 char *names;
 429
 430                                 if (node_names(&names) != 0)
 431                                         return (1);
 432                                 pjdlog_error("No resource %s configuration for this node (acceptable node names: %s).",
 433                                     curres->hr_name, names);
 434                                 return (1);
 435                         }
 436
 437                         /*
 438                          * Let's see if there are some resource-level settings
 439                          * that we can use for node-level settings.
 440                          */
 441                         if (curres->hr_provname[0] == '\0' &&
 442                             depth1_provname[0] != '\0') {
 443                                 /*
 444                                  * Provider name is not set at node-level,
 445                                  * but is set at resource-level, use it.
 446                                  */
 447                                 strlcpy(curres->hr_provname, depth1_provname,
 448                                     sizeof(curres->hr_provname));
 449                         }
 450                         if (curres->hr_localpath[0] == '\0' &&
 451                             depth1_localpath[0] != '\0') {
 452                                 /*
 453                                  * Path to local provider is not set at
 454                                  * node-level, but is set at resource-level,
 455                                  * use it.
 456                                  */
 457                                 strlcpy(curres->hr_localpath, depth1_localpath,
 458                                     sizeof(curres->hr_localpath));
 459                         }
 460                         if (curres->hr_metaflush == -1 && depth1_metaflush != -1) {
 461                                 /*
 462                                  * Metaflush is not set at node-level,
 463                                  * but is set at resource-level, use it.
 464                                  */
 465                                 curres->hr_metaflush = depth1_metaflush;
 466                         }
 467
 468                         /*
 469                          * If provider name is not given, use resource name
 470                          * as provider name.
 471                          */
 472                         if (curres->hr_provname[0] == '\0') {
 473                                 strlcpy(curres->hr_provname, curres->hr_name,
 474                                     sizeof(curres->hr_provname));
 475                         }
 476
 477                         /*
 478                          * Remote address has to be configured at this point.
 479                          */
 480                         if (curres->hr_remoteaddr[0] == '\0') {
 481                                 pjdlog_error("Remote address not configured for resource %s.",
 482                                     curres->hr_name);
 483                                 return (1);
 484                         }
 485                         /*
 486                          * Path to local provider has to be configured at this
 487                          * point.
 488                          */
 489                         if (curres->hr_localpath[0] == '\0') {
 490                                 pjdlog_error("Path to local component not configured for resource %s.",
 491                                     curres->hr_name);
 492                                 return (1);
 493                         }
 494
 495                         /* Put it onto resource list. */
 496                         TAILQ_INSERT_TAIL(&lconfig->hc_resources, curres, hr_next);
 497                         curres = NULL;
 498                 }
 499         }
 500         ;
 501
 502 resource_start: STR
 503         {
 504                 /* Check if there is no duplicate entry. */
 505                 TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) {
 506                         if (strcmp(curres->hr_name, $1) == 0) {
 507                                 pjdlog_error("Resource %s configured more than once.",
 508                                     curres->hr_name);
 509                                 free($1);
 510                                 return (1);
 511                         }
 512                 }
 513
 514                 /*
 515                  * Clear those, so we can tell if they were set at
 516                  * resource-level or not.
 517                  */
 518                 depth1_provname[0] = '\0';
 519                 depth1_localpath[0] = '\0';
 520                 depth1_metaflush = -1;
 521                 hadmynode = false;
 522
 523                 curres = calloc(1, sizeof(*curres));
 524                 if (curres == NULL) {
 525                         pjdlog_error("Unable to allocate memory for resource.");
 526                         free($1);
 527                         return (1);
 528                 }
 529                 if (strlcpy(curres->hr_name, $1,
 530                     sizeof(curres->hr_name)) >=
 531                     sizeof(curres->hr_name)) {
 532                         pjdlog_error("Resource name is too long.");
 533                         free(curres);
 534                         free($1);
 535                         return (1);
 536                 }
 537                 free($1);
 538                 curres->hr_role = HAST_ROLE_INIT;
 539                 curres->hr_previous_role = HAST_ROLE_INIT;
 540                 curres->hr_replication = -1;
 541                 curres->hr_original_replication = -1;
 542                 curres->hr_checksum = -1;
 543                 curres->hr_compression = -1;
 544                 curres->hr_version = 1;
 545                 curres->hr_timeout = -1;
 546                 curres->hr_exec[0] = '\0';
 547                 curres->hr_provname[0] = '\0';
 548                 curres->hr_localpath[0] = '\0';
 549                 curres->hr_localfd = -1;
 550                 curres->hr_localflush = true;
 551                 curres->hr_metaflush = -1;
 552                 curres->hr_remoteaddr[0] = '\0';
 553                 curres->hr_sourceaddr[0] = '\0';
 554                 curres->hr_ggateunit = -1;
 555         }
 556         ;
 557
 558 resource_entries:
 559         |
 560         resource_entries resource_entry
 561         ;
 562
 563 resource_entry:
 564         replication_statement
 565         |
 566         checksum_statement
 567         |
 568         compression_statement
 569         |
 570         timeout_statement
 571         |
 572         exec_statement
 573         |
 574         metaflush_statement
 575         |
 576         name_statement
 577         |
 578         local_statement
 579         |
 580         resource_node_statement
 581         ;
 582
 583 name_statement:         NAME STR
 584         {
 585                 switch (depth) {
 586                 case 1:
 587                         if (strlcpy(depth1_provname, $2,
 588                             sizeof(depth1_provname)) >=
 589                             sizeof(depth1_provname)) {
 590                                 pjdlog_error("name argument is too long.");
 591                                 free($2);
 592                                 return (1);
 593                         }
 594                         break;
 595                 case 2:
 596                         if (!mynode)
 597                                 break;
 598                         PJDLOG_ASSERT(curres != NULL);
 599                         if (strlcpy(curres->hr_provname, $2,
 600                             sizeof(curres->hr_provname)) >=
 601                             sizeof(curres->hr_provname)) {
 602                                 pjdlog_error("name argument is too long.");
 603                                 free($2);
 604                                 return (1);
 605                         }
 606                         break;
 607                 default:
 608                         PJDLOG_ABORT("name at wrong depth level");
 609                 }
 610                 free($2);
 611         }
 612         ;
 613
 614 local_statement:        LOCAL STR
 615         {
 616                 switch (depth) {
 617                 case 1:
 618                         if (strlcpy(depth1_localpath, $2,
 619                             sizeof(depth1_localpath)) >=
 620                             sizeof(depth1_localpath)) {
 621                                 pjdlog_error("local argument is too long.");
 622                                 free($2);
 623                                 return (1);
 624                         }
 625                         break;
 626                 case 2:
 627                         if (!mynode)
 628                                 break;
 629                         PJDLOG_ASSERT(curres != NULL);
 630                         if (strlcpy(curres->hr_localpath, $2,
 631                             sizeof(curres->hr_localpath)) >=
 632                             sizeof(curres->hr_localpath)) {
 633                                 pjdlog_error("local argument is too long.");
 634                                 free($2);
 635                                 return (1);
 636                         }
 637                         break;
 638                 default:
 639                         PJDLOG_ABORT("local at wrong depth level");
 640                 }
 641                 free($2);
 642         }
 643         ;
 644
 645 resource_node_statement:ON resource_node_start OB resource_node_entries CB
 646         {
 647                 mynode = false;
 648         }
 649         ;
 650
 651 resource_node_start:    STR
 652         {
 653                 if (curres != NULL) {
 654                         switch (isitme($1)) {
 655                         case -1:
 656                                 free($1);
 657                                 return (1);
 658                         case 0:
 659                                 break;
 660                         case 1:
 661                                 mynode = hadmynode = true;
 662                                 break;
 663                         default:
 664                                 PJDLOG_ABORT("invalid isitme() return value");
 665                         }
 666                 }
 667                 free($1);
 668         }
 669         ;
 670
 671 resource_node_entries:
 672         |
 673         resource_node_entries resource_node_entry
 674         ;
 675
 676 resource_node_entry:
 677         name_statement
 678         |
 679         local_statement
 680         |
 681         remote_statement
 682         |
 683         source_statement
 684         |
 685         metaflush_statement
 686         ;
 687
 688 remote_statement:       REMOTE remote_str
 689         {
 690                 PJDLOG_ASSERT(depth == 2);
 691                 if (mynode) {
 692                         PJDLOG_ASSERT(curres != NULL);
 693                         if (strlcpy(curres->hr_remoteaddr, $2,
 694                             sizeof(curres->hr_remoteaddr)) >=
 695                             sizeof(curres->hr_remoteaddr)) {
 696                                 pjdlog_error("remote argument is too long.");
 697                                 free($2);
 698                                 return (1);
 699                         }
 700                 }
 701                 free($2);
 702         }
 703         ;
 704
 705 remote_str:
 706         NONE            { $$ = strdup("none"); }
 707         |
 708         STR             { }
 709         ;
 710
 711 source_statement:       SOURCE STR
 712         {
 713                 PJDLOG_ASSERT(depth == 2);
 714                 if (mynode) {
 715                         PJDLOG_ASSERT(curres != NULL);
 716                         if (strlcpy(curres->hr_sourceaddr, $2,
 717                             sizeof(curres->hr_sourceaddr)) >=
 718                             sizeof(curres->hr_sourceaddr)) {
 719                                 pjdlog_error("source argument is too long.");
 720                                 free($2);
 721                                 return (1);
 722                         }
 723                 }
 724                 free($2);
 725         }
 726         ;
 727
 728 %%
 729
 730 static int
 731 isitme(const char *name)
 732 {
 733         char buf[MAXHOSTNAMELEN];
 734         unsigned long hostid;
 735         char *pos;
 736         size_t bufsize;
 737
 738         /*
 739          * First check if the given name matches our full hostname.
 740          */
 741         if (gethostname(buf, sizeof(buf)) < 0) {
 742                 pjdlog_errno(LOG_ERR, "gethostname() failed");
 743                 return (-1);
 744         }
 745         if (strcmp(buf, name) == 0)
 746                 return (1);
 747
 748         /*
 749          * Check if it matches first part of the host name.
 750          */
 751         pos = strchr(buf, '.');
 752         if (pos != NULL && (size_t)(pos - buf) == strlen(name) &&
 753             strncmp(buf, name, pos - buf) == 0) {
 754                 return (1);
 755         }
 756
 757         /*
 758          * Check if it matches host UUID.
 759          */
 760         bufsize = sizeof(buf);
 761         if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
 762                 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
 763                 return (-1);
 764         }
 765         if (strcasecmp(buf, name) == 0)
 766                 return (1);
 767
 768         /*
 769          * Check if it matches hostid.
 770          */
 771         bufsize = sizeof(hostid);
 772         if (sysctlbyname("kern.hostid", &hostid, &bufsize, NULL, 0) < 0) {
 773                 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostid) failed");
 774                 return (-1);
 775         }
 776         (void)snprintf(buf, sizeof(buf), "hostid%lu", hostid);
 777         if (strcmp(buf, name) == 0)
 778                 return (1);
 779
 780         /*
 781          * Looks like this isn't about us.
 782          */
 783         return (0);
 784 }
 785
 786 static bool
 787 family_supported(int family)
 788 {
 789         int sock;
 790
 791         sock = socket(family, SOCK_STREAM, 0);
 792         if (sock == -1 && errno == EPROTONOSUPPORT)
 793                 return (false);
 794         if (sock >= 0)
 795                 (void)close(sock);
 796         return (true);
 797 }
 798
 799 static int
 800 node_names(char **namesp)
 801 {
 802         static char names[MAXHOSTNAMELEN * 3];
 803         char buf[MAXHOSTNAMELEN];
 804         unsigned long hostid;
 805         char *pos;
 806         size_t bufsize;
 807
 808         if (gethostname(buf, sizeof(buf)) < 0) {
 809                 pjdlog_errno(LOG_ERR, "gethostname() failed");
 810                 return (-1);
 811         }
 812
 813         /* First component of the host name. */
 814         pos = strchr(buf, '.');
 815         if (pos != NULL && pos != buf) {
 816                 (void)strlcpy(names, buf, MIN((size_t)(pos - buf + 1),
 817                     sizeof(names)));
 818                 (void)strlcat(names, ", ", sizeof(names));
 819         }
 820
 821         /* Full host name. */
 822         (void)strlcat(names, buf, sizeof(names));
 823         (void)strlcat(names, ", ", sizeof(names));
 824
 825         /* Host UUID. */
 826         bufsize = sizeof(buf);
 827         if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
 828                 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
 829                 return (-1);
 830         }
 831         (void)strlcat(names, buf, sizeof(names));
 832         (void)strlcat(names, ", ", sizeof(names));
 833
 834         /* Host ID. */
 835         bufsize = sizeof(hostid);
 836         if (sysctlbyname("kern.hostid", &hostid, &bufsize, NULL, 0) < 0) {
 837                 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostid) failed");
 838                 return (-1);
 839         }
 840         (void)snprintf(buf, sizeof(buf), "hostid%lu", hostid);
 841         (void)strlcat(names, buf, sizeof(names));
 842
 843         *namesp = names;
 844
 845         return (0);
 846 }
 847
 848 void
 849 yyerror(const char *str)
 850 {
 851
 852         pjdlog_error("Unable to parse configuration file at line %d near '%s': %s",
 853             lineno, yytext, str);
 854 }
 855
 856 struct hastd_config *
 857 yy_config_parse(const char *config, bool exitonerror)
 858 {
 859         int ret;
 860
 861         curres = NULL;
 862         mynode = false;
 863         depth = 0;
 864         lineno = 0;
 865
 866         depth0_timeout = HAST_TIMEOUT;
 867         depth0_replication = HAST_REPLICATION_MEMSYNC;
 868         depth0_checksum = HAST_CHECKSUM_NONE;
 869         depth0_compression = HAST_COMPRESSION_HOLE;
 870         strlcpy(depth0_control, HAST_CONTROL, sizeof(depth0_control));
 871         strlcpy(depth0_pidfile, HASTD_PIDFILE, sizeof(depth0_pidfile));
 872         TAILQ_INIT(&depth0_listen);
 873         strlcpy(depth0_listen_tcp4, HASTD_LISTEN_TCP4,
 874             sizeof(depth0_listen_tcp4));
 875         strlcpy(depth0_listen_tcp6, HASTD_LISTEN_TCP6,
 876             sizeof(depth0_listen_tcp6));
 877         depth0_exec[0] = '\0';
 878         depth0_metaflush = 1;
 879
 880         lconfig = calloc(1, sizeof(*lconfig));
 881         if (lconfig == NULL) {
 882                 pjdlog_error("Unable to allocate memory for configuration.");
 883                 if (exitonerror)
 884                         exit(EX_TEMPFAIL);
 885                 return (NULL);
 886         }
 887
 888         TAILQ_INIT(&lconfig->hc_listen);
 889         TAILQ_INIT(&lconfig->hc_resources);
 890
 891         yyin = fopen(config, "r");
 892         if (yyin == NULL) {
 893                 pjdlog_errno(LOG_ERR, "Unable to open configuration file %s",
 894                     config);
 895                 yy_config_free(lconfig);
 896                 if (exitonerror)
 897                         exit(EX_OSFILE);
 898                 return (NULL);
 899         }
 900         yyrestart(yyin);
 901         ret = yyparse();
 902         fclose(yyin);
 903         if (ret != 0) {
 904                 yy_config_free(lconfig);
 905                 if (exitonerror)
 906                         exit(EX_CONFIG);
 907                 return (NULL);
 908         }
 909
 910         /*
 911          * Let's see if everything is set up.
 912          */
 913         if (lconfig->hc_controladdr[0] == '\0') {
 914                 strlcpy(lconfig->hc_controladdr, depth0_control,
 915                     sizeof(lconfig->hc_controladdr));
 916         }
 917         if (lconfig->hc_pidfile[0] == '\0') {
 918                 strlcpy(lconfig->hc_pidfile, depth0_pidfile,
 919                     sizeof(lconfig->hc_pidfile));
 920         }
 921         if (!TAILQ_EMPTY(&depth0_listen))
 922                 TAILQ_CONCAT(&lconfig->hc_listen, &depth0_listen, hl_next);
 923         if (TAILQ_EMPTY(&lconfig->hc_listen)) {
 924                 struct hastd_listen *lst;
 925
 926                 if (family_supported(AF_INET)) {
 927                         lst = calloc(1, sizeof(*lst));
 928                         if (lst == NULL) {
 929                                 pjdlog_error("Unable to allocate memory for listen address.");
 930                                 yy_config_free(lconfig);
 931                                 if (exitonerror)
 932                                         exit(EX_TEMPFAIL);
 933                                 return (NULL);
 934                         }
 935                         (void)strlcpy(lst->hl_addr, depth0_listen_tcp4,
 936                             sizeof(lst->hl_addr));
 937                         TAILQ_INSERT_TAIL(&lconfig->hc_listen, lst, hl_next);
 938                 } else {
 939                         pjdlog_debug(1,
 940                             "No IPv4 support in the kernel, not listening on IPv4 address.");
 941                 }
 942                 if (family_supported(AF_INET6)) {
 943                         lst = calloc(1, sizeof(*lst));
 944                         if (lst == NULL) {
 945                                 pjdlog_error("Unable to allocate memory for listen address.");
 946                                 yy_config_free(lconfig);
 947                                 if (exitonerror)
 948                                         exit(EX_TEMPFAIL);
 949                                 return (NULL);
 950                         }
 951                         (void)strlcpy(lst->hl_addr, depth0_listen_tcp6,
 952                             sizeof(lst->hl_addr));
 953                         TAILQ_INSERT_TAIL(&lconfig->hc_listen, lst, hl_next);
 954                 } else {
 955                         pjdlog_debug(1,
 956                             "No IPv6 support in the kernel, not listening on IPv6 address.");
 957                 }
 958                 if (TAILQ_EMPTY(&lconfig->hc_listen)) {
 959                         pjdlog_error("No address to listen on.");
 960                         yy_config_free(lconfig);
 961                         if (exitonerror)
 962                                 exit(EX_TEMPFAIL);
 963                         return (NULL);
 964                 }
 965         }
 966         TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) {
 967                 PJDLOG_ASSERT(curres->hr_provname[0] != '\0');
 968                 PJDLOG_ASSERT(curres->hr_localpath[0] != '\0');
 969                 PJDLOG_ASSERT(curres->hr_remoteaddr[0] != '\0');
 970
 971                 if (curres->hr_replication == -1) {
 972                         /*
 973                          * Replication is not set at resource-level.
 974                          * Use global or default setting.
 975                          */
 976                         curres->hr_replication = depth0_replication;
 977                         curres->hr_original_replication = depth0_replication;
 978                 }
 979                 if (curres->hr_checksum == -1) {
 980                         /*
 981                          * Checksum is not set at resource-level.
 982                          * Use global or default setting.
 983                          */
 984                         curres->hr_checksum = depth0_checksum;
 985                 }
 986                 if (curres->hr_compression == -1) {
 987                         /*
 988                          * Compression is not set at resource-level.
 989                          * Use global or default setting.
 990                          */
 991                         curres->hr_compression = depth0_compression;
 992                 }
 993                 if (curres->hr_timeout == -1) {
 994                         /*
 995                          * Timeout is not set at resource-level.
 996                          * Use global or default setting.
 997                          */
 998                         curres->hr_timeout = depth0_timeout;
 999                 }
1000                 if (curres->hr_exec[0] == '\0') {
1001                         /*
1002                          * Exec is not set at resource-level.
1003                          * Use global or default setting.
1004                          */
1005                         strlcpy(curres->hr_exec, depth0_exec,
1006                             sizeof(curres->hr_exec));
1007                 }
1008                 if (curres->hr_metaflush == -1) {
1009                         /*
1010                          * Metaflush is not set at resource-level.
1011                          * Use global or default setting.
1012                          */
1013                         curres->hr_metaflush = depth0_metaflush;
1014                 }
1015         }
1016
1017         return (lconfig);
1018 }
1019
1020 void
1021 yy_config_free(struct hastd_config *config)
1022 {
1023         struct hastd_listen *lst;
1024         struct hast_resource *res;
1025
1026         while ((lst = TAILQ_FIRST(&depth0_listen)) != NULL) {
1027                 TAILQ_REMOVE(&depth0_listen, lst, hl_next);
1028                 free(lst);
1029         }
1030         while ((lst = TAILQ_FIRST(&config->hc_listen)) != NULL) {
1031                 TAILQ_REMOVE(&config->hc_listen, lst, hl_next);
1032                 free(lst);
1033         }
1034         while ((res = TAILQ_FIRST(&config->hc_resources)) != NULL) {
1035                 TAILQ_REMOVE(&config->hc_resources, res, hr_next);
1036                 free(res);
1037         }
1038         free(config);
1039 }