Deleted Added
sdiff udiff text old ( 207371 ) new ( 210883 )
full compact
parse.y (207371) parse.y (210883)
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 *

--- 13 unchanged lines hidden (view full) ---

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 *
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 *

--- 13 unchanged lines hidden (view full) ---

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: head/sbin/hastd/parse.y 207371 2010-04-29 15:36:32Z pjd $
30 * $FreeBSD: head/sbin/hastd/parse.y 210883 2010-08-05 19:08:54Z pjd $
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
31 */
32
33#include <sys/param.h> /* MAXHOSTNAMELEN */
34#include <sys/queue.h>
35#include <sys/sysctl.h>
36
37#include <arpa/inet.h>
38
39#include <assert.h>
40#include <err.h>
41#include <stdio.h>
42#include <string.h>
43#include <sysexits.h>
44#include <unistd.h>
45
46#include <pjdlog.h>
47
46#include "hast.h"
47
48extern int depth;
49extern int lineno;
50
51extern FILE *yyin;
52extern char *yytext;
53
48#include "hast.h"
49
50extern int depth;
51extern int lineno;
52
53extern FILE *yyin;
54extern char *yytext;
55
54static struct hastd_config lconfig;
56static struct hastd_config *lconfig;
55static struct hast_resource *curres;
56static bool mynode;
57
58static char depth0_control[HAST_ADDRSIZE];
59static char depth0_listen[HAST_ADDRSIZE];
60static int depth0_replication;
61static int depth0_timeout;
62
63static char depth1_provname[PATH_MAX];
64static char depth1_localpath[PATH_MAX];
65
57static struct hast_resource *curres;
58static bool mynode;
59
60static char depth0_control[HAST_ADDRSIZE];
61static char depth0_listen[HAST_ADDRSIZE];
62static int depth0_replication;
63static int depth0_timeout;
64
65static char depth1_provname[PATH_MAX];
66static char depth1_localpath[PATH_MAX];
67
66static bool
68extern void yyrestart(FILE *);
69
70static int
67isitme(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 */
71isitme(const char *name)
72{
73 char buf[MAXHOSTNAMELEN];
74 char *pos;
75 size_t bufsize;
76
77 /*
78 * First check if the give name matches our full hostname.
79 */
76 if (gethostname(buf, sizeof(buf)) < 0)
77 err(EX_OSERR, "gethostname() failed");
80 if (gethostname(buf, sizeof(buf)) < 0) {
81 pjdlog_errno(LOG_ERR, "gethostname() failed");
82 return (-1);
83 }
78 if (strcmp(buf, name) == 0)
84 if (strcmp(buf, name) == 0)
79 return (true);
85 return (1);
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
87 /*
88 * Now check if it matches first part of the host name.
89 */
90 pos = strchr(buf, '.');
91 if (pos != NULL && pos != buf && strncmp(buf, name, pos - buf) == 0)
86 return (true);
92 return (1);
87
88 /*
89 * At the end check if name is equal to our host's UUID.
90 */
91 bufsize = sizeof(buf);
93
94 /*
95 * At the end check if name is equal to our host's UUID.
96 */
97 bufsize = sizeof(buf);
92 if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0)
93 err(EX_OSERR, "sysctlbyname(kern.hostuuid) failed");
98 if (sysctlbyname("kern.hostuuid", buf, &bufsize, NULL, 0) < 0) {
99 pjdlog_errno(LOG_ERR, "sysctlbyname(kern.hostuuid) failed");
100 return (-1);
101 }
94 if (strcasecmp(buf, name) == 0)
102 if (strcasecmp(buf, name) == 0)
95 return (true);
103 return (1);
96
97 /*
98 * Looks like this isn't about us.
99 */
104
105 /*
106 * Looks like this isn't about us.
107 */
100 return (false);
108 return (0);
101}
102
103void
104yyerror(const char *str)
105{
106
109}
110
111void
112yyerror(const char *str)
113{
114
107 fprintf(stderr, "error at line %d near '%s': %s\n",
115 pjdlog_error("Unable to parse configuration file at line %d near '%s': %s",
108 lineno, yytext, str);
109}
110
111struct hastd_config *
116 lineno, yytext, str);
117}
118
119struct hastd_config *
112yy_config_parse(const char *config)
120yy_config_parse(const char *config, bool exitonerror)
113{
114 int ret;
115
116 curres = NULL;
117 mynode = false;
121{
122 int ret;
123
124 curres = NULL;
125 mynode = false;
126 depth = 0;
127 lineno = 0;
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
128
129 depth0_timeout = HAST_TIMEOUT;
130 depth0_replication = HAST_REPLICATION_MEMSYNC;
131 strlcpy(depth0_control, HAST_CONTROL, sizeof(depth0_control));
132 strlcpy(depth0_listen, HASTD_LISTEN, sizeof(depth0_listen));
133
124 TAILQ_INIT(&lconfig.hc_resources);
134 lconfig = calloc(1, sizeof(*lconfig));
135 if (lconfig == NULL) {
136 pjdlog_error("Unable to allocate memory for configuration.");
137 if (exitonerror)
138 exit(EX_TEMPFAIL);
139 return (NULL);
140 }
125
141
142 TAILQ_INIT(&lconfig->hc_resources);
143
126 yyin = fopen(config, "r");
144 yyin = fopen(config, "r");
127 if (yyin == NULL)
128 err(EX_OSFILE, "cannot open configuration file %s", config);
145 if (yyin == NULL) {
146 pjdlog_errno(LOG_ERR, "Unable to open configuration file %s",
147 config);
148 yy_config_free(lconfig);
149 if (exitonerror)
150 exit(EX_OSFILE);
151 return (NULL);
152 }
153 yyrestart(yyin);
129 ret = yyparse();
130 fclose(yyin);
131 if (ret != 0) {
154 ret = yyparse();
155 fclose(yyin);
156 if (ret != 0) {
132 yy_config_free(&lconfig);
133 exit(EX_CONFIG);
157 yy_config_free(lconfig);
158 if (exitonerror)
159 exit(EX_CONFIG);
160 return (NULL);
134 }
135
136 /*
137 * Let's see if everything is set up.
138 */
161 }
162
163 /*
164 * Let's see if everything is set up.
165 */
139 if (lconfig.hc_controladdr[0] == '\0') {
140 strlcpy(lconfig.hc_controladdr, depth0_control,
141 sizeof(lconfig.hc_controladdr));
166 if (lconfig->hc_controladdr[0] == '\0') {
167 strlcpy(lconfig->hc_controladdr, depth0_control,
168 sizeof(lconfig->hc_controladdr));
142 }
169 }
143 if (lconfig.hc_listenaddr[0] == '\0') {
144 strlcpy(lconfig.hc_listenaddr, depth0_listen,
145 sizeof(lconfig.hc_listenaddr));
170 if (lconfig->hc_listenaddr[0] == '\0') {
171 strlcpy(lconfig->hc_listenaddr, depth0_listen,
172 sizeof(lconfig->hc_listenaddr));
146 }
173 }
147 TAILQ_FOREACH(curres, &lconfig.hc_resources, hr_next) {
174 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.

--- 4 unchanged lines hidden (view full) ---

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
175 assert(curres->hr_provname[0] != '\0');
176 assert(curres->hr_localpath[0] != '\0');
177 assert(curres->hr_remoteaddr[0] != '\0');
178
179 if (curres->hr_replication == -1) {
180 /*
181 * Replication is not set at resource-level.
182 * Use global or default setting.

--- 4 unchanged lines hidden (view full) ---

187 /*
188 * Timeout is not set at resource-level.
189 * Use global or default setting.
190 */
191 curres->hr_timeout = depth0_timeout;
192 }
193 }
194
168 return (&lconfig);
195 return (lconfig);
169}
170
171void
172yy_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 }
196}
197
198void
199yy_config_free(struct hastd_config *config)
200{
201 struct hast_resource *res;
202
203 while ((res = TAILQ_FIRST(&config->hc_resources)) != NULL) {
204 TAILQ_REMOVE(&config->hc_resources, res, hr_next);
205 free(res);
206 }
207 free(config);
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

--- 30 unchanged lines hidden (view full) ---

218
219control_statement: CONTROL STR
220 {
221 switch (depth) {
222 case 0:
223 if (strlcpy(depth0_control, $2,
224 sizeof(depth0_control)) >=
225 sizeof(depth0_control)) {
208}
209%}
210
211%token CONTROL LISTEN PORT REPLICATION TIMEOUT EXTENTSIZE RESOURCE NAME LOCAL REMOTE ON
212%token FULLSYNC MEMSYNC ASYNC
213%token NUM STR OB CB
214
215%type <num> replication_type

--- 30 unchanged lines hidden (view full) ---

246
247control_statement: CONTROL STR
248 {
249 switch (depth) {
250 case 0:
251 if (strlcpy(depth0_control, $2,
252 sizeof(depth0_control)) >=
253 sizeof(depth0_control)) {
226 errx(EX_CONFIG, "control argument too long");
254 pjdlog_error("control argument is too long.");
255 return (1);
227 }
228 break;
229 case 1:
230 if (mynode) {
256 }
257 break;
258 case 1:
259 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");
260 if (strlcpy(lconfig->hc_controladdr, $2,
261 sizeof(lconfig->hc_controladdr)) >=
262 sizeof(lconfig->hc_controladdr)) {
263 pjdlog_error("control argument is too long.");
264 return (1);
236 }
237 }
238 break;
239 default:
240 assert(!"control at wrong depth level");
241 }
242 }
243 ;
244
245listen_statement: LISTEN STR
246 {
247 switch (depth) {
248 case 0:
249 if (strlcpy(depth0_listen, $2,
250 sizeof(depth0_listen)) >=
251 sizeof(depth0_listen)) {
265 }
266 }
267 break;
268 default:
269 assert(!"control at wrong depth level");
270 }
271 }
272 ;
273
274listen_statement: LISTEN STR
275 {
276 switch (depth) {
277 case 0:
278 if (strlcpy(depth0_listen, $2,
279 sizeof(depth0_listen)) >=
280 sizeof(depth0_listen)) {
252 errx(EX_CONFIG, "listen argument too long");
281 pjdlog_error("listen argument is too long.");
282 return (1);
253 }
254 break;
255 case 1:
256 if (mynode) {
283 }
284 break;
285 case 1:
286 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");
287 if (strlcpy(lconfig->hc_listenaddr, $2,
288 sizeof(lconfig->hc_listenaddr)) >=
289 sizeof(lconfig->hc_listenaddr)) {
290 pjdlog_error("listen argument is too long.");
291 return (1);
262 }
263 }
264 break;
265 default:
266 assert(!"listen at wrong depth level");
267 }
268 }
269 ;

--- 41 unchanged lines hidden (view full) ---

311node_statement: ON node_start OB node_entries CB
312 {
313 mynode = false;
314 }
315 ;
316
317node_start: STR
318 {
292 }
293 }
294 break;
295 default:
296 assert(!"listen at wrong depth level");
297 }
298 }
299 ;

--- 41 unchanged lines hidden (view full) ---

341node_statement: ON node_start OB node_entries CB
342 {
343 mynode = false;
344 }
345 ;
346
347node_start: STR
348 {
319 if (isitme($1))
349 switch (isitme($1)) {
350 case -1:
351 return (1);
352 case 0:
353 break;
354 case 1:
320 mynode = true;
355 mynode = true;
356 break;
357 default:
358 assert(!"invalid isitme() return value");
359 }
321 }
322 ;
323
324node_entries:
325 |
326 node_entries node_entry
327 ;
328

--- 38 unchanged lines hidden (view full) ---

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') {
360 }
361 ;
362
363node_entries:
364 |
365 node_entries node_entry
366 ;
367

--- 38 unchanged lines hidden (view full) ---

406 strlcpy(curres->hr_provname, curres->hr_name,
407 sizeof(curres->hr_provname));
408 }
409
410 /*
411 * Remote address has to be configured at this point.
412 */
413 if (curres->hr_remoteaddr[0] == '\0') {
375 errx(EX_CONFIG,
376 "remote address not configured for resource %s",
414 pjdlog_error("Remote address not configured for resource %s.",
377 curres->hr_name);
415 curres->hr_name);
416 return (1);
378 }
379 /*
380 * Path to local provider has to be configured at this
381 * point.
382 */
383 if (curres->hr_localpath[0] == '\0') {
417 }
418 /*
419 * Path to local provider has to be configured at this
420 * point.
421 */
422 if (curres->hr_localpath[0] == '\0') {
384 errx(EX_CONFIG,
385 "path local component not configured for resource %s",
423 pjdlog_error("Path to local component not configured for resource %s.",
386 curres->hr_name);
424 curres->hr_name);
425 return (1);
387 }
388
389 /* Put it onto resource list. */
426 }
427
428 /* Put it onto resource list. */
390 TAILQ_INSERT_TAIL(&lconfig.hc_resources, curres, hr_next);
429 TAILQ_INSERT_TAIL(&lconfig->hc_resources, curres, hr_next);
391 curres = NULL;
392 }
393 }
394 ;
395
396resource_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) {
430 curres = NULL;
431 }
432 }
433 ;
434
435resource_start: STR
436 {
437 /*
438 * Clear those, so we can tell if they were set at
439 * resource-level or not.
440 */
441 depth1_provname[0] = '\0';
442 depth1_localpath[0] = '\0';
443
444 curres = calloc(1, sizeof(*curres));
445 if (curres == NULL) {
407 errx(EX_TEMPFAIL,
408 "cannot allocate memory for resource");
446 pjdlog_error("Unable to allocate memory for resource.");
447 return (1);
409 }
410 if (strlcpy(curres->hr_name, $1,
411 sizeof(curres->hr_name)) >=
412 sizeof(curres->hr_name)) {
448 }
449 if (strlcpy(curres->hr_name, $1,
450 sizeof(curres->hr_name)) >=
451 sizeof(curres->hr_name)) {
413 errx(EX_CONFIG,
414 "resource name (%s) too long", $1);
452 pjdlog_error("Resource name is too long.");
453 return (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;

--- 21 unchanged lines hidden (view full) ---

444
445name_statement: NAME STR
446 {
447 switch (depth) {
448 case 1:
449 if (strlcpy(depth1_provname, $2,
450 sizeof(depth1_provname)) >=
451 sizeof(depth1_provname)) {
454 }
455 curres->hr_role = HAST_ROLE_INIT;
456 curres->hr_previous_role = HAST_ROLE_INIT;
457 curres->hr_replication = -1;
458 curres->hr_timeout = -1;
459 curres->hr_provname[0] = '\0';
460 curres->hr_localpath[0] = '\0';
461 curres->hr_localfd = -1;

--- 21 unchanged lines hidden (view full) ---

483
484name_statement: NAME STR
485 {
486 switch (depth) {
487 case 1:
488 if (strlcpy(depth1_provname, $2,
489 sizeof(depth1_provname)) >=
490 sizeof(depth1_provname)) {
452 errx(EX_CONFIG, "name argument too long");
491 pjdlog_error("name argument is too long.");
492 return (1);
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)) {
493 }
494 break;
495 case 2:
496 if (mynode) {
497 assert(curres != NULL);
498 if (strlcpy(curres->hr_provname, $2,
499 sizeof(curres->hr_provname)) >=
500 sizeof(curres->hr_provname)) {
461 errx(EX_CONFIG,
462 "name argument too long");
501 pjdlog_error("name argument is too long.");
502 return (1);
463 }
464 }
465 break;
466 default:
467 assert(!"name at wrong depth level");
468 }
469 }
470 ;
471
472local_statement: LOCAL STR
473 {
474 switch (depth) {
475 case 1:
476 if (strlcpy(depth1_localpath, $2,
477 sizeof(depth1_localpath)) >=
478 sizeof(depth1_localpath)) {
503 }
504 }
505 break;
506 default:
507 assert(!"name at wrong depth level");
508 }
509 }
510 ;
511
512local_statement: LOCAL STR
513 {
514 switch (depth) {
515 case 1:
516 if (strlcpy(depth1_localpath, $2,
517 sizeof(depth1_localpath)) >=
518 sizeof(depth1_localpath)) {
479 errx(EX_CONFIG, "local argument too long");
519 pjdlog_error("local argument is too long.");
520 return (1);
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)) {
521 }
522 break;
523 case 2:
524 if (mynode) {
525 assert(curres != NULL);
526 if (strlcpy(curres->hr_localpath, $2,
527 sizeof(curres->hr_localpath)) >=
528 sizeof(curres->hr_localpath)) {
488 errx(EX_CONFIG,
489 "local argument too long");
529 pjdlog_error("local argument is too long.");
530 return (1);
490 }
491 }
492 break;
493 default:
494 assert(!"local at wrong depth level");
495 }
496 }
497 ;
498
499resource_node_statement:ON resource_node_start OB resource_node_entries CB
500 {
501 mynode = false;
502 }
503 ;
504
505resource_node_start: STR
506 {
531 }
532 }
533 break;
534 default:
535 assert(!"local at wrong depth level");
536 }
537 }
538 ;
539
540resource_node_statement:ON resource_node_start OB resource_node_entries CB
541 {
542 mynode = false;
543 }
544 ;
545
546resource_node_start: STR
547 {
507 if (curres != NULL && isitme($1))
508 mynode = true;
548 if (curres != NULL) {
549 switch (isitme($1)) {
550 case -1:
551 return (1);
552 case 0:
553 break;
554 case 1:
555 mynode = true;
556 break;
557 default:
558 assert(!"invalid isitme() return value");
559 }
560 }
509 }
510 ;
511
512resource_node_entries:
513 |
514 resource_node_entries resource_node_entry
515 ;
516

--- 8 unchanged lines hidden (view full) ---

525remote_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)) {
561 }
562 ;
563
564resource_node_entries:
565 |
566 resource_node_entries resource_node_entry
567 ;
568

--- 8 unchanged lines hidden (view full) ---

577remote_statement: REMOTE STR
578 {
579 assert(depth == 2);
580 if (mynode) {
581 assert(curres != NULL);
582 if (strlcpy(curres->hr_remoteaddr, $2,
583 sizeof(curres->hr_remoteaddr)) >=
584 sizeof(curres->hr_remoteaddr)) {
533 errx(EX_CONFIG, "remote argument too long");
585 pjdlog_error("remote argument is too long.");
586 return (1);
534 }
535 }
536 }
537 ;
587 }
588 }
589 }
590 ;