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