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