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/sysctl.h> 37 38 #include <arpa/inet.h> 39 40 #include <assert.h> 41 #include <err.h> 42 #include <stdio.h> 43 #include <string.h> 44 #include <sysexits.h> 45 #include <unistd.h> 46 47 #include <pjdlog.h> 48 49 #include "hast.h" 50 51 extern int depth; 52 extern int lineno; 53 54 extern FILE *yyin; 55 extern char *yytext; 56 57 static struct hastd_config *lconfig; 58 static struct hast_resource *curres; 59 static bool mynode, hadmynode; 60 61 static char depth0_control[HAST_ADDRSIZE]; 62 static char depth0_listen[HAST_ADDRSIZE]; 63 static int depth0_replication; 64 static int depth0_checksum; 65 static int depth0_compression; 66 static int depth0_timeout; 67 static char depth0_exec[PATH_MAX]; 68 69 static char depth1_provname[PATH_MAX]; 70 static char depth1_localpath[PATH_MAX]; 71 72 extern void yyrestart(FILE *); 73 74 static int 75 isitme(const char *name) 76 { 77 char buf[MAXHOSTNAMELEN]; 78 char *pos; 79 size_t bufsize; 80 81 /* 82 * First check if the give name matches our full hostname. 83 */ 84 if (gethostname(buf, sizeof(buf)) < 0) { 85 pjdlog_errno(LOG_ERR, "gethostname() failed"); 86 return (-1); 87 } 88 if (strcmp(buf, name) == 0) 89 return (1); 90 91 /* 92 * Now check if it matches first part of the host name. 93 */ 94 pos = strchr(buf, '.'); 95 if (pos != NULL && pos != buf && strncmp(buf, name, pos - buf) == 0) 96 return (1); 97 98 /* 99 * At the end check if name is equal to our host's UUID. 100 */ 101 bufsize = sizeof(buf); 102 if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) { 103 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed"); 104 return (-1); 105 } 106 if (strcasecmp(buf, name) == 0) 107 return (1); 108 109 /* 110 * Looks like this isn't about us. 111 */ 112 return (0); 113 } 114 115 static int 116 node_names(char **namesp) 117 { 118 static char names[MAXHOSTNAMELEN * 3]; 119 char buf[MAXHOSTNAMELEN]; 120 char *pos; 121 size_t bufsize; 122 123 if (gethostname(buf, sizeof(buf)) < 0) { 124 pjdlog_errno(LOG_ERR, "gethostname() failed"); 125 return (-1); 126 } 127 128 /* First component of the host name. */ 129 pos = strchr(buf, '.'); 130 if (pos != NULL && pos != buf) { 131 (void)strlcpy(names, buf, MIN((size_t)(pos - buf + 1), 132 sizeof(names))); 133 (void)strlcat(names, ", ", sizeof(names)); 134 } 135 136 /* Full host name. */ 137 (void)strlcat(names, buf, sizeof(names)); 138 (void)strlcat(names, ", ", sizeof(names)); 139 140 /* Host UUID. */ 141 bufsize = sizeof(buf); 142 if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) { 143 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed"); 144 return (-1); 145 } 146 (void)strlcat(names, buf, sizeof(names)); 147 148 *namesp = names; 149 150 return (0); 151 } 152 153 void 154 yyerror(const char *str) 155 { 156 157 pjdlog_error("Unable to parse configuration file at line %d near '%s': %s", 158 lineno, yytext, str); 159 } 160 161 struct hastd_config * 162 yy_config_parse(const char *config, bool exitonerror) 163 { 164 int ret; 165 166 curres = NULL; 167 mynode = false; 168 depth = 0; 169 lineno = 0; 170 171 depth0_timeout = HAST_TIMEOUT; 172 depth0_replication = HAST_REPLICATION_MEMSYNC; 173 depth0_checksum = HAST_CHECKSUM_NONE; 174 depth0_compression = HAST_COMPRESSION_HOLE; 175 strlcpy(depth0_control, HAST_CONTROL, sizeof(depth0_control)); 176 strlcpy(depth0_listen, HASTD_LISTEN, sizeof(depth0_listen)); 177 depth0_exec[0] = '\0'; 178 179 lconfig = calloc(1, sizeof(*lconfig)); 180 if (lconfig == NULL) { 181 pjdlog_error("Unable to allocate memory for configuration."); 182 if (exitonerror) 183 exit(EX_TEMPFAIL); 184 return (NULL); 185 } 186 187 TAILQ_INIT(&lconfig->hc_resources); 188 189 yyin = fopen(config, "r"); 190 if (yyin == NULL) { 191 pjdlog_errno(LOG_ERR, "Unable to open configuration file %s", 192 config); 193 yy_config_free(lconfig); 194 if (exitonerror) 195 exit(EX_OSFILE); 196 return (NULL); 197 } 198 yyrestart(yyin); 199 ret = yyparse(); 200 fclose(yyin); 201 if (ret != 0) { 202 yy_config_free(lconfig); 203 if (exitonerror) 204 exit(EX_CONFIG); 205 return (NULL); 206 } 207 208 /* 209 * Let's see if everything is set up. 210 */ 211 if (lconfig->hc_controladdr[0] == '\0') { 212 strlcpy(lconfig->hc_controladdr, depth0_control, 213 sizeof(lconfig->hc_controladdr)); 214 } 215 if (lconfig->hc_listenaddr[0] == '\0') { 216 strlcpy(lconfig->hc_listenaddr, depth0_listen, 217 sizeof(lconfig->hc_listenaddr)); 218 } 219 TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) { 220 assert(curres->hr_provname[0] != '\0'); 221 assert(curres->hr_localpath[0] != '\0'); 222 assert(curres->hr_remoteaddr[0] != '\0'); 223 224 if (curres->hr_replication == -1) { 225 /* 226 * Replication is not set at resource-level. 227 * Use global or default setting. 228 */ 229 curres->hr_replication = depth0_replication; 230 } 231 if (curres->hr_checksum == -1) { 232 /* 233 * Checksum is not set at resource-level. 234 * Use global or default setting. 235 */ 236 curres->hr_checksum = depth0_checksum; 237 } 238 if (curres->hr_compression == -1) { 239 /* 240 * Compression is not set at resource-level. 241 * Use global or default setting. 242 */ 243 curres->hr_compression = depth0_compression; 244 } 245 if (curres->hr_timeout == -1) { 246 /* 247 * Timeout is not set at resource-level. 248 * Use global or default setting. 249 */ 250 curres->hr_timeout = depth0_timeout; 251 } 252 if (curres->hr_exec[0] == '\0') { 253 /* 254 * Exec is not set at resource-level. 255 * Use global or default setting. 256 */ 257 strlcpy(curres->hr_exec, depth0_exec, 258 sizeof(curres->hr_exec)); 259 } 260 } 261 262 return (lconfig); 263 } 264 265 void 266 yy_config_free(struct hastd_config *config) 267 { 268 struct hast_resource *res; 269 270 while ((res = TAILQ_FIRST(&config->hc_resources)) != NULL) { 271 TAILQ_REMOVE(&config->hc_resources, res, hr_next); 272 free(res); 273 } 274 free(config); 275 } 276 %} 277 278 %token CONTROL LISTEN PORT REPLICATION CHECKSUM COMPRESSION 279 %token TIMEOUT EXEC EXTENTSIZE RESOURCE NAME LOCAL REMOTE SOURCE ON 280 %token FULLSYNC MEMSYNC ASYNC NONE CRC32 SHA256 HOLE LZF 281 %token NUM STR OB CB 282 283 %type <num> replication_type 284 %type <num> checksum_type 285 %type <num> compression_type 286 287 %union 288 { 289 int num; 290 char *str; 291 } 292 293 %token <num> NUM 294 %token <str> STR 295 296 %% 297 298 statements: 299 | 300 statements statement 301 ; 302 303 statement: 304 control_statement 305 | 306 listen_statement 307 | 308 replication_statement 309 | 310 checksum_statement 311 | 312 compression_statement 313 | 314 timeout_statement 315 | 316 exec_statement 317 | 318 node_statement 319 | 320 resource_statement 321 ; 322 323 control_statement: CONTROL STR 324 { 325 switch (depth) { 326 case 0: 327 if (strlcpy(depth0_control, $2, 328 sizeof(depth0_control)) >= 329 sizeof(depth0_control)) { 330 pjdlog_error("control argument is too long."); 331 free($2); 332 return (1); 333 } 334 break; 335 case 1: 336 if (!mynode) 337 break; 338 if (strlcpy(lconfig->hc_controladdr, $2, 339 sizeof(lconfig->hc_controladdr)) >= 340 sizeof(lconfig->hc_controladdr)) { 341 pjdlog_error("control argument is too long."); 342 free($2); 343 return (1); 344 } 345 break; 346 default: 347 assert(!"control at wrong depth level"); 348 } 349 free($2); 350 } 351 ; 352 353 listen_statement: LISTEN STR 354 { 355 switch (depth) { 356 case 0: 357 if (strlcpy(depth0_listen, $2, 358 sizeof(depth0_listen)) >= 359 sizeof(depth0_listen)) { 360 pjdlog_error("listen argument is too long."); 361 free($2); 362 return (1); 363 } 364 break; 365 case 1: 366 if (!mynode) 367 break; 368 if (strlcpy(lconfig->hc_listenaddr, $2, 369 sizeof(lconfig->hc_listenaddr)) >= 370 sizeof(lconfig->hc_listenaddr)) { 371 pjdlog_error("listen argument is too long."); 372 free($2); 373 return (1); 374 } 375 break; 376 default: 377 assert(!"listen at wrong depth level"); 378 } 379 free($2); 380 } 381 ; 382 383 replication_statement: REPLICATION replication_type 384 { 385 switch (depth) { 386 case 0: 387 depth0_replication = $2; 388 break; 389 case 1: 390 if (curres != NULL) 391 curres->hr_replication = $2; 392 break; 393 default: 394 assert(!"replication at wrong depth level"); 395 } 396 } 397 ; 398 399 replication_type: 400 FULLSYNC { $$ = HAST_REPLICATION_FULLSYNC; } 401 | 402 MEMSYNC { $$ = HAST_REPLICATION_MEMSYNC; } 403 | 404 ASYNC { $$ = HAST_REPLICATION_ASYNC; } 405 ; 406 407 checksum_statement: CHECKSUM checksum_type 408 { 409 switch (depth) { 410 case 0: 411 depth0_checksum = $2; 412 break; 413 case 1: 414 if (curres != NULL) 415 curres->hr_checksum = $2; 416 break; 417 default: 418 assert(!"checksum at wrong depth level"); 419 } 420 } 421 ; 422 423 checksum_type: 424 NONE { $$ = HAST_CHECKSUM_NONE; } 425 | 426 CRC32 { $$ = HAST_CHECKSUM_CRC32; } 427 | 428 SHA256 { $$ = HAST_CHECKSUM_SHA256; } 429 ; 430 431 compression_statement: COMPRESSION compression_type 432 { 433 switch (depth) { 434 case 0: 435 depth0_compression = $2; 436 break; 437 case 1: 438 if (curres != NULL) 439 curres->hr_compression = $2; 440 break; 441 default: 442 assert(!"compression at wrong depth level"); 443 } 444 } 445 ; 446 447 compression_type: 448 NONE { $$ = HAST_COMPRESSION_NONE; } 449 | 450 HOLE { $$ = HAST_COMPRESSION_HOLE; } 451 | 452 LZF { $$ = HAST_COMPRESSION_LZF; } 453 ; 454 455 timeout_statement: TIMEOUT NUM 456 { 457 switch (depth) { 458 case 0: 459 depth0_timeout = $2; 460 break; 461 case 1: 462 if (curres != NULL) 463 curres->hr_timeout = $2; 464 break; 465 default: 466 assert(!"timeout at wrong depth level"); 467 } 468 } 469 ; 470 471 exec_statement: EXEC STR 472 { 473 switch (depth) { 474 case 0: 475 if (strlcpy(depth0_exec, $2, sizeof(depth0_exec)) >= 476 sizeof(depth0_exec)) { 477 pjdlog_error("Exec path is too long."); 478 free($2); 479 return (1); 480 } 481 break; 482 case 1: 483 if (curres == NULL) 484 break; 485 if (strlcpy(curres->hr_exec, $2, 486 sizeof(curres->hr_exec)) >= 487 sizeof(curres->hr_exec)) { 488 pjdlog_error("Exec path is too long."); 489 free($2); 490 return (1); 491 } 492 break; 493 default: 494 assert(!"exec at wrong depth level"); 495 } 496 free($2); 497 } 498 ; 499 500 node_statement: ON node_start OB node_entries CB 501 { 502 mynode = false; 503 } 504 ; 505 506 node_start: STR 507 { 508 switch (isitme($1)) { 509 case -1: 510 free($1); 511 return (1); 512 case 0: 513 break; 514 case 1: 515 mynode = true; 516 break; 517 default: 518 assert(!"invalid isitme() return value"); 519 } 520 free($1); 521 } 522 ; 523 524 node_entries: 525 | 526 node_entries node_entry 527 ; 528 529 node_entry: 530 control_statement 531 | 532 listen_statement 533 ; 534 535 resource_statement: RESOURCE resource_start OB resource_entries CB 536 { 537 if (curres != NULL) { 538 /* 539 * There must be section for this node, at least with 540 * remote address configuration. 541 */ 542 if (!hadmynode) { 543 char *names; 544 545 if (node_names(&names) != 0) 546 return (1); 547 pjdlog_error("No resource %s configuration for this node (acceptable node names: %s).", 548 curres->hr_name, names); 549 return (1); 550 } 551 552 /* 553 * Let's see there are some resource-level settings 554 * that we can use for node-level settings. 555 */ 556 if (curres->hr_provname[0] == '\0' && 557 depth1_provname[0] != '\0') { 558 /* 559 * Provider name is not set at node-level, 560 * but is set at resource-level, use it. 561 */ 562 strlcpy(curres->hr_provname, depth1_provname, 563 sizeof(curres->hr_provname)); 564 } 565 if (curres->hr_localpath[0] == '\0' && 566 depth1_localpath[0] != '\0') { 567 /* 568 * Path to local provider is not set at 569 * node-level, but is set at resource-level, 570 * use it. 571 */ 572 strlcpy(curres->hr_localpath, depth1_localpath, 573 sizeof(curres->hr_localpath)); 574 } 575 576 /* 577 * If provider name is not given, use resource name 578 * as provider name. 579 */ 580 if (curres->hr_provname[0] == '\0') { 581 strlcpy(curres->hr_provname, curres->hr_name, 582 sizeof(curres->hr_provname)); 583 } 584 585 /* 586 * Remote address has to be configured at this point. 587 */ 588 if (curres->hr_remoteaddr[0] == '\0') { 589 pjdlog_error("Remote address not configured for resource %s.", 590 curres->hr_name); 591 return (1); 592 } 593 /* 594 * Path to local provider has to be configured at this 595 * point. 596 */ 597 if (curres->hr_localpath[0] == '\0') { 598 pjdlog_error("Path to local component not configured for resource %s.", 599 curres->hr_name); 600 return (1); 601 } 602 603 /* Put it onto resource list. */ 604 TAILQ_INSERT_TAIL(&lconfig->hc_resources, curres, hr_next); 605 curres = NULL; 606 } 607 } 608 ; 609 610 resource_start: STR 611 { 612 /* Check if there is no duplicate entry. */ 613 TAILQ_FOREACH(curres, &lconfig->hc_resources, hr_next) { 614 if (strcmp(curres->hr_name, $1) == 0) { 615 pjdlog_error("Resource %s configured more than once.", 616 curres->hr_name); 617 free($1); 618 return (1); 619 } 620 } 621 622 /* 623 * Clear those, so we can tell if they were set at 624 * resource-level or not. 625 */ 626 depth1_provname[0] = '\0'; 627 depth1_localpath[0] = '\0'; 628 hadmynode = false; 629 630 curres = calloc(1, sizeof(*curres)); 631 if (curres == NULL) { 632 pjdlog_error("Unable to allocate memory for resource."); 633 free($1); 634 return (1); 635 } 636 if (strlcpy(curres->hr_name, $1, 637 sizeof(curres->hr_name)) >= 638 sizeof(curres->hr_name)) { 639 pjdlog_error("Resource name is too long."); 640 free($1); 641 return (1); 642 } 643 free($1); 644 curres->hr_role = HAST_ROLE_INIT; 645 curres->hr_previous_role = HAST_ROLE_INIT; 646 curres->hr_replication = -1; 647 curres->hr_checksum = -1; 648 curres->hr_compression = -1; 649 curres->hr_timeout = -1; 650 curres->hr_exec[0] = '\0'; 651 curres->hr_provname[0] = '\0'; 652 curres->hr_localpath[0] = '\0'; 653 curres->hr_localfd = -1; 654 curres->hr_remoteaddr[0] = '\0'; 655 curres->hr_sourceaddr[0] = '\0'; 656 curres->hr_ggateunit = -1; 657 } 658 ; 659 660 resource_entries: 661 | 662 resource_entries resource_entry 663 ; 664 665 resource_entry: 666 replication_statement 667 | 668 checksum_statement 669 | 670 compression_statement 671 | 672 timeout_statement 673 | 674 exec_statement 675 | 676 name_statement 677 | 678 local_statement 679 | 680 resource_node_statement 681 ; 682 683 name_statement: NAME STR 684 { 685 switch (depth) { 686 case 1: 687 if (strlcpy(depth1_provname, $2, 688 sizeof(depth1_provname)) >= 689 sizeof(depth1_provname)) { 690 pjdlog_error("name argument is too long."); 691 free($2); 692 return (1); 693 } 694 break; 695 case 2: 696 if (!mynode) 697 break; 698 assert(curres != NULL); 699 if (strlcpy(curres->hr_provname, $2, 700 sizeof(curres->hr_provname)) >= 701 sizeof(curres->hr_provname)) { 702 pjdlog_error("name argument is too long."); 703 free($2); 704 return (1); 705 } 706 break; 707 default: 708 assert(!"name at wrong depth level"); 709 } 710 free($2); 711 } 712 ; 713 714 local_statement: LOCAL STR 715 { 716 switch (depth) { 717 case 1: 718 if (strlcpy(depth1_localpath, $2, 719 sizeof(depth1_localpath)) >= 720 sizeof(depth1_localpath)) { 721 pjdlog_error("local argument is too long."); 722 free($2); 723 return (1); 724 } 725 break; 726 case 2: 727 if (!mynode) 728 break; 729 assert(curres != NULL); 730 if (strlcpy(curres->hr_localpath, $2, 731 sizeof(curres->hr_localpath)) >= 732 sizeof(curres->hr_localpath)) { 733 pjdlog_error("local argument is too long."); 734 free($2); 735 return (1); 736 } 737 break; 738 default: 739 assert(!"local at wrong depth level"); 740 } 741 free($2); 742 } 743 ; 744 745 resource_node_statement:ON resource_node_start OB resource_node_entries CB 746 { 747 mynode = false; 748 } 749 ; 750 751 resource_node_start: STR 752 { 753 if (curres != NULL) { 754 switch (isitme($1)) { 755 case -1: 756 free($1); 757 return (1); 758 case 0: 759 break; 760 case 1: 761 mynode = hadmynode = true; 762 break; 763 default: 764 assert(!"invalid isitme() return value"); 765 } 766 } 767 free($1); 768 } 769 ; 770 771 resource_node_entries: 772 | 773 resource_node_entries resource_node_entry 774 ; 775 776 resource_node_entry: 777 name_statement 778 | 779 local_statement 780 | 781 remote_statement 782 | 783 source_statement 784 ; 785 786 remote_statement: REMOTE STR 787 { 788 assert(depth == 2); 789 if (mynode) { 790 assert(curres != NULL); 791 if (strlcpy(curres->hr_remoteaddr, $2, 792 sizeof(curres->hr_remoteaddr)) >= 793 sizeof(curres->hr_remoteaddr)) { 794 pjdlog_error("remote argument is too long."); 795 free($2); 796 return (1); 797 } 798 } 799 free($2); 800 } 801 ; 802 803 source_statement: SOURCE STR 804 { 805 assert(depth == 2); 806 if (mynode) { 807 assert(curres != NULL); 808 if (strlcpy(curres->hr_sourceaddr, $2, 809 sizeof(curres->hr_sourceaddr)) >= 810 sizeof(curres->hr_sourceaddr)) { 811 pjdlog_error("source argument is too long."); 812 free($2); 813 return (1); 814 } 815 } 816 free($2); 817 } 818 ; 819