1 %{
2 /* $NetBSD: testlang_parse.y,v 1.14 2015/01/04 20:19:46 christos Exp $ */
3
4 /*-
5 * Copyright 2009 Brett Lymn <blymn@NetBSD.org>
6 *
7 * All rights reserved.
8 *
9 * This code has been donated to The NetBSD Foundation by the Author.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. The name of the author may not be used to endorse or promote products
17 * derived from this software withough specific prior written permission
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 *
31 */
32 #include <assert.h>
33 #include <curses.h>
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <err.h>
37 #include <unistd.h>
38 #include <poll.h>
39 #include <stdbool.h>
40 #include <stdio.h>
41 #include <string.h>
42 #include <stdlib.h>
43 #include <limits.h>
44 #include <time.h>
45 #include <vis.h>
46 #include <stdint.h>
47 #include "returns.h"
48
49 #define YYDEBUG 1
50
51 extern int verbose;
52 extern int cmdpipe[2];
53 extern int slvpipe[2];
54 extern int master;
55 extern struct pollfd readfd;
56 extern char *check_path;
57 extern char *cur_file; /* from director.c */
58
59 int yylex(void);
60
61 size_t line;
62
63 static int input_delay;
64
65 /* time delay between inputs chars - default to 0.1ms minimum to prevent
66 * problems with input tests
67 */
68 #define DELAY_MIN 0.1
69
70 /* time delay after a function call - allows the slave time to
71 * run the function and output data before we do other actions.
72 * Set this to 50ms.
73 */
74 #define POST_CALL_DELAY 50
75
76 static struct timespec delay_spec = {0, 1000 * DELAY_MIN};
77 static struct timespec delay_post_call = {0, 1000 * POST_CALL_DELAY};
78
79 static char *input_str; /* string to feed in as input */
80 static bool no_input; /* don't need more input */
81
82 #define READ_PIPE 0
83 #define WRITE_PIPE 1
84
85 const char *returns_enum_names[] = {
86 "unused", "numeric", "string", "byte", "ERR", "OK", "NULL", "not NULL",
87 "variable", "reference", "returns count", "slave error"
88 };
89
90 typedef enum {
91 arg_static,
92 arg_byte,
93 arg_var,
94 arg_null
95 } args_state_t;
96
97 static const char *args_enum_names[] = {
98 "static", "byte", "var", "NULL"
99 };
100
101 typedef struct {
102 args_state_t arg_type;
103 size_t arg_len;
104 char *arg_string;
105 int var_index;
106 } args_t;
107
108 typedef struct {
109 char *function;
110 int nrets; /* number of returns */
111 returns_t *returns; /* array of expected returns */
112 int nargs; /* number of arguments */
113 args_t *args; /* arguments for the call */
114 } cmd_line_t;
115
116 static cmd_line_t command;
117
118 typedef struct {
119 char *name;
120 size_t len;
121 returns_enum_t type;
122 void *value;
123 } var_t;
124
125 static size_t nvars; /* Number of declared variables */
126 static var_t *vars; /* Variables defined during the test. */
127
128 static int check_function_table(char *, const char *[], int);
129 static int find_var_index(const char *);
130 static void assign_arg(args_state_t, void *);
131 static int assign_var(char *);
132 void init_parse_variables(int);
133 static void validate(int, void *);
134 static void validate_return(const char *, const char *, int);
135 static void validate_variable(int, returns_enum_t, const void *, int, int);
136 static void validate_byte(returns_t *, returns_t *, int);
137 static void write_cmd_pipe(char *);
138 static void write_cmd_pipe_args(args_state_t, void *);
139 static void read_cmd_pipe(returns_t *);
140 static void write_func_and_args(void);
141 static void compare_streams(char *, bool);
142 static void do_function_call(size_t);
143 static void save_slave_output(bool);
144 static void validate_type(returns_enum_t, returns_t *, int);
145 static void set_var(returns_enum_t, char *, void *);
146 static void validate_reference(int, void *);
147 static char *numeric_or(char *, char *);
148 static char *get_numeric_var(const char *);
149 static void perform_delay(struct timespec *);
150
151 static const char *input_functions[] = {
152 "getch", "getnstr", "getstr", "mvgetnstr", "mvgetstr", "mvgetnstr",
153 "mvgetstr", "mvscanw", "mvwscanw", "scanw", "wgetch", "wgetnstr",
154 "wgetstr"
155 };
156
157 static const unsigned ninput_functions =
158 sizeof(input_functions) / sizeof(char *);
159
160 saved_data_t saved_output;
161
162 %}
163
164 %union {
165 char *string;
166 returns_t *retval;
167 }
168
169 %token <string> PATH
170 %token <string> STRING
171 %token <retval> BYTE
172 %token <string> VARNAME
173 %token <string> FILENAME
174 %token <string> VARIABLE
175 %token <string> REFERENCE
176 %token <string> NULL_RET
177 %token <string> NON_NULL
178 %token <string> ERR_RET
179 %token <string> OK_RET
180 %token <string> numeric
181 %token <string> DELAY
182 %token <string> INPUT
183 %token <string> COMPARE
184 %token <string> COMPAREND
185 %token <string> ASSIGN
186 %token EOL CALL CHECK NOINPUT OR LHB RHB
187 %token CALL2 CALL3 CALL4 DRAIN
188
189 %nonassoc OR
190
191 %%
192
193 statement : /* empty */
194 | assign statement
195 | call statement
196 | call2 statement
197 | call3 statement
198 | call4 statement
199 | check statement
200 | delay statement
201 | input statement
202 | noinput statement
203 | compare statement
204 | comparend statement
205 | eol statement
206 ;
207
208 assign : ASSIGN VARNAME numeric {set_var(ret_number, $2, $3);} eol
209 | ASSIGN VARNAME LHB expr RHB {set_var(ret_number, $2, $<string>4);} eol
210 | ASSIGN VARNAME STRING {set_var(ret_string, $2, $3);} eol
211 | ASSIGN VARNAME BYTE {set_var(ret_byte, $2, $3);} eol
212 ;
213
214 call : CALL result fn_name args eol {
215 do_function_call(1);
216 }
217 ;
218
219 call2 : CALL2 result result fn_name args eol {
220 do_function_call(2);
221 }
222 ;
223
224 call3 : CALL3 result result result fn_name args eol {
225 do_function_call(3);
226 }
227 ;
228
229 call4 : CALL4 result result result result fn_name args eol {
230 do_function_call(4);
231 }
232 ;
233
234 check : CHECK var returns eol {
235 returns_t retvar;
236 var_t *vptr;
237 if (command.returns[0].return_index == -1)
238 err(1, "Undefined variable in check statement, line %zu"
239 " of file %s", line, cur_file);
240
241 if (verbose) {
242 fprintf(stderr, "Checking contents of variable %s for %s\n",
243 vars[command.returns[0].return_index].name,
244 returns_enum_names[command.returns[1].return_type]);
245 }
246
247 if (((command.returns[1].return_type == ret_byte) &&
248 (vars[command.returns[0].return_index].type != ret_byte)) ||
249 vars[command.returns[0].return_index].type != ret_string)
250 err(1, "Var type %s (%d) does not match return type %s (%d)",
251 returns_enum_names[
252 vars[command.returns[0].return_index].type],
253 vars[command.returns[0].return_index].type,
254 returns_enum_names[command.returns[1].return_type],
255 command.returns[1].return_type);
256
257 switch (command.returns[1].return_type) {
258 case ret_err:
259 validate_variable(0, ret_string, "ERR",
260 command.returns[0].return_index, 0);
261 break;
262
263 case ret_ok:
264 validate_variable(0, ret_string, "OK",
265 command.returns[0].return_index, 0);
266 break;
267
268 case ret_null:
269 validate_variable(0, ret_string, "NULL",
270 command.returns[0].return_index, 0);
271 break;
272
273 case ret_nonnull:
274 validate_variable(0, ret_string, "NULL",
275 command.returns[0].return_index, 1);
276 break;
277
278 case ret_string:
279 case ret_number:
280 if (verbose) {
281 fprintf(stderr, " %s == returned %s\n",
282 (const char *)command.returns[1].return_value,
283 (const char *)
284 vars[command.returns[0].return_index].value);
285 }
286 validate_variable(0, ret_string,
287 command.returns[1].return_value,
288 command.returns[0].return_index, 0);
289 break;
290
291 case ret_byte:
292 vptr = &vars[command.returns[0].return_index];
293 retvar.return_len = vptr->len;
294 retvar.return_type = vptr->type;
295 retvar.return_value = vptr->value;
296 validate_byte(&retvar, &command.returns[1], 0);
297 break;
298
299 default:
300 err(1, "Malformed check statement at line %zu "
301 "of file %s", line, cur_file);
302 break;
303 }
304
305 init_parse_variables(0);
306 }
307 ;
308
309 delay : DELAY numeric eol {
310 /* set the inter-character delay */
311 if (sscanf($2, "%d", &input_delay) == 0)
312 err(1, "delay specification %s could not be converted to "
313 "numeric at line %zu of file %s", $2, line, cur_file);
314 if (verbose) {
315 fprintf(stderr, "Set input delay to %d ms\n", input_delay);
316 }
317
318 if (input_delay < DELAY_MIN)
319 input_delay = DELAY_MIN;
320 /*
321 * Fill in the timespec structure now ready for use later.
322 * The delay is specified in milliseconds so convert to timespec
323 * values
324 */
325 delay_spec.tv_sec = input_delay / 1000;
326 delay_spec.tv_nsec = (input_delay - 1000 * delay_spec.tv_sec) * 1000;
327 if (verbose) {
328 fprintf(stderr, "set delay to %jd.%jd\n",
329 (intmax_t)delay_spec.tv_sec,
330 (intmax_t)delay_spec.tv_nsec);
331 }
332
333 init_parse_variables(0);
334 }
335 ;
336
337 input : INPUT STRING eol {
338 if (input_str != NULL) {
339 warnx("%s, %zu: Discarding unused input string",
340 cur_file, line);
341 free(input_str);
342 }
343
344 if ((input_str = malloc(strlen($2) + 1)) == NULL)
345 err(2, "Cannot allocate memory for input string");
346
347 strlcpy(input_str, $2, strlen($2) + 1);
348 }
349 ;
350
351
352 noinput : NOINPUT eol {
353 if (input_str != NULL) {
354 warnx("%s, %zu: Discarding unused input string",
355 cur_file, line);
356 free(input_str);
357 }
358
359 no_input = true;
360 }
361
362 compare : COMPARE PATH eol
363 | COMPARE FILENAME eol
364 {
365 compare_streams($2, true);
366 }
367 ;
368
369
370 comparend : COMPAREND PATH eol
371 | COMPAREND FILENAME eol
372 {
373 compare_streams($2, false);
374 }
375 ;
376
377
378 result : returns
379 | var
380 | reference
381 ;
382
383 returns : numeric { assign_rets(ret_number, $1); }
384 | LHB expr RHB { assign_rets(ret_number, $<string>2); }
385 | STRING { assign_rets(ret_string, $1); }
386 | BYTE { assign_rets(ret_byte, (void *) $1); }
387 | ERR_RET { assign_rets(ret_err, NULL); }
388 | OK_RET { assign_rets(ret_ok, NULL); }
389 | NULL_RET { assign_rets(ret_null, NULL); }
390 | NON_NULL { assign_rets(ret_nonnull, NULL); }
391 ;
392
393 var : VARNAME {
394 assign_rets(ret_var, $1);
395 }
396 ;
397
398 reference : VARIABLE {
399 assign_rets(ret_ref, $1);
400 }
401
402 fn_name : VARNAME {
403 if (command.function != NULL)
404 free(command.function);
405
406 command.function = malloc(strlen($1) + 1);
407 if (command.function == NULL)
408 err(1, "Could not allocate memory for function name");
409 strcpy(command.function, $1);
410 }
411 ;
412
413 expr : numeric
414 | VARIABLE
415 { $<string>$ = get_numeric_var($1); }
416 | expr OR expr
417 { $<string>$ = numeric_or($<string>1, $<string>3); }
418 ;
419
420 args : /* empty */
421 | LHB expr RHB { assign_arg(arg_static, $<string>2); } args
422 | numeric { assign_arg(arg_static, $1); } args
423 | STRING { assign_arg(arg_static, $1); } args
424 | BYTE { assign_arg(arg_byte, $1); } args
425 | PATH { assign_arg(arg_static, $1); } args
426 | FILENAME { assign_arg(arg_static, $1); } args
427 | VARNAME { assign_arg(arg_static, $1); } args
428 | VARIABLE { assign_arg(arg_var, $1); } args
429 | NULL_RET { assign_arg(arg_null, $1); } args
430 ;
431
432 eol : EOL
433 ;
434
435 %%
436
437 static void
438 excess(const char *fname, size_t lineno, const char *func, const char *comment,
439 const void *data, size_t datalen)
440 {
441 size_t dstlen = datalen * 4 + 1;
442 char *dst = malloc(dstlen);
443
444 if (dst == NULL)
445 err(1, "malloc");
446
447 if (strnvisx(dst, dstlen, data, datalen, VIS_WHITE | VIS_OCTAL) == -1)
448 err(1, "strnvisx");
449
450 warnx("%s, %zu: [%s] Excess %zu bytes%s [%s]",
451 fname, lineno, func, datalen, comment, dst);
452 free(dst);
453 }
454
455 /*
456 * Get the value of a variable, error if the variable has not been set or
457 * is not a numeric type.
458 */
459 static char *
get_numeric_var(const char * var)460 get_numeric_var(const char *var)
461 {
462 int i;
463
464 if ((i = find_var_index(var)) < 0)
465 err(1, "Variable %s is undefined", var);
466
467 if (vars[i].type != ret_number)
468 err(1, "Variable %s is not a numeric type", var);
469
470 return vars[i].value;
471 }
472
473 /*
474 * Perform a bitwise OR on two numbers and return the result.
475 */
476 static char *
numeric_or(char * n1,char * n2)477 numeric_or(char *n1, char *n2)
478 {
479 unsigned long i1, i2, result;
480 char *ret;
481
482 i1 = strtoul(n1, NULL, 10);
483 i2 = strtoul(n2, NULL, 10);
484
485 result = i1 | i2;
486 asprintf(&ret, "%lu", result);
487
488 if (verbose) {
489 fprintf(stderr, "numeric or of 0x%lx (%s) and 0x%lx (%s)"
490 " results in 0x%lx (%s)\n",
491 i1, n1, i2, n2, result, ret);
492 }
493
494 return ret;
495 }
496
497 /*
498 * Sleep for the specified time, handle the sleep getting interrupted
499 * by a signal.
500 */
501 static void
perform_delay(struct timespec * ts)502 perform_delay(struct timespec *ts)
503 {
504 struct timespec delay_copy, delay_remainder;
505
506 delay_copy = *ts;
507 while (nanosleep(&delay_copy, &delay_remainder) < 0) {
508 if (errno != EINTR)
509 err(2, "nanosleep returned error");
510 delay_copy = delay_remainder;
511 }
512 }
513
514 /*
515 * Assign the value given to the named variable.
516 */
517 static void
set_var(returns_enum_t type,char * name,void * value)518 set_var(returns_enum_t type, char *name, void *value)
519 {
520 int i;
521 char *number;
522 returns_t *ret;
523
524 i = find_var_index(name);
525 if (i < 0)
526 i = assign_var(name);
527
528 vars[i].type = type;
529 if ((type == ret_number) || (type == ret_string)) {
530 number = value;
531 vars[i].len = strlen(number) + 1;
532 vars[i].value = malloc(vars[i].len + 1);
533 if (vars[i].value == NULL)
534 err(1, "Could not malloc memory for assign string");
535 strcpy(vars[i].value, number);
536 } else {
537 /* can only be a byte value */
538 ret = value;
539 vars[i].len = ret->return_len;
540 vars[i].value = malloc(vars[i].len);
541 if (vars[i].value == NULL)
542 err(1, "Could not malloc memory to assign byte string");
543 memcpy(vars[i].value, ret->return_value, vars[i].len);
544 }
545 }
546
547 /*
548 * Add a new variable to the vars array, the value will be assigned later,
549 * when a test function call returns.
550 */
551 static int
assign_var(char * varname)552 assign_var(char *varname)
553 {
554 var_t *temp;
555 char *name;
556
557 if ((name = malloc(strlen(varname) + 1)) == NULL)
558 err(1, "Alloc of varname failed");
559
560 if ((temp = realloc(vars, sizeof(*temp) * (nvars + 1))) == NULL) {
561 free(name);
562 err(1, "Realloc of vars array failed");
563 }
564
565 strcpy(name, varname);
566 vars = temp;
567 vars[nvars].name = name;
568 vars[nvars].len = 0;
569 vars[nvars].value = NULL;
570 nvars++;
571
572 return (nvars - 1);
573 }
574
575 /*
576 * Allocate and assign a new argument of the given type.
577 */
578 static void
assign_arg(args_state_t arg_type,void * arg)579 assign_arg(args_state_t arg_type, void *arg)
580 {
581 args_t *temp, cur;
582 char *str = arg;
583 returns_t *ret;
584
585 if (verbose) {
586 fprintf(stderr, "function is >%s<, adding arg >%s< type %s\n",
587 command.function, str, args_enum_names[arg_type]);
588 }
589
590 cur.arg_type = arg_type;
591 switch (arg_type) {
592 case arg_var:
593 cur.var_index = find_var_index(arg);
594 if (cur.var_index < 0)
595 err(1, "Invalid variable %s at line %zu of file %s",
596 str, line, cur_file);
597 cur.arg_type = ret_string;
598 break;
599
600 case arg_byte:
601 ret = arg;
602 cur.arg_len = ret->return_len;
603 cur.arg_string = malloc(cur.arg_len);
604 if (cur.arg_string == NULL)
605 err(1, "Could not malloc memory for arg bytes");
606 memcpy(cur.arg_string, ret->return_value, cur.arg_len);
607 break;
608
609 case arg_null:
610 cur.arg_len = 0;
611 cur.arg_string = NULL;
612 break;
613
614 default:
615 cur.arg_len = strlen(str);
616 cur.arg_string = malloc(cur.arg_len + 1);
617 if (cur.arg_string == NULL)
618 err(1, "Could not malloc memory for arg string");
619 strcpy(cur.arg_string, arg);
620 }
621
622 temp = realloc(command.args, sizeof(*temp) * (command.nargs + 1));
623 if (temp == NULL)
624 err(1, "Failed to reallocate args");
625 command.args = temp;
626 memcpy(&command.args[command.nargs], &cur, sizeof(args_t));
627 command.nargs++;
628 }
629
630 /*
631 * Allocate and assign a new return.
632 */
633 static void
assign_rets(returns_enum_t ret_type,void * ret)634 assign_rets(returns_enum_t ret_type, void *ret)
635 {
636 returns_t *temp, cur;
637 char *ret_str;
638 returns_t *ret_ret;
639
640 cur.return_type = ret_type;
641 if (ret_type != ret_var) {
642 if ((ret_type == ret_number) || (ret_type == ret_string)) {
643 ret_str = ret;
644 cur.return_len = strlen(ret_str) + 1;
645 cur.return_value = malloc(cur.return_len + 1);
646 if (cur.return_value == NULL)
647 err(1,
648 "Could not malloc memory for arg string");
649 strcpy(cur.return_value, ret_str);
650 } else if (ret_type == ret_byte) {
651 ret_ret = ret;
652 cur.return_len = ret_ret->return_len;
653 cur.return_value = malloc(cur.return_len);
654 if (cur.return_value == NULL)
655 err(1,
656 "Could not malloc memory for byte string");
657 memcpy(cur.return_value, ret_ret->return_value,
658 cur.return_len);
659 } else if (ret_type == ret_ref) {
660 if ((cur.return_index = find_var_index(ret)) < 0)
661 err(1, "Undefined variable reference");
662 }
663 } else {
664 cur.return_index = find_var_index(ret);
665 if (cur.return_index < 0)
666 cur.return_index = assign_var(ret);
667 }
668
669 temp = realloc(command.returns, sizeof(*temp) * (command.nrets + 1));
670 if (temp == NULL)
671 err(1, "Failed to reallocate returns");
672 command.returns = temp;
673 memcpy(&command.returns[command.nrets], &cur, sizeof(returns_t));
674 command.nrets++;
675 }
676
677 /*
678 * Find the given variable name in the var array and return the i
679 * return -1 if var is not found.
680 */
681 static int
find_var_index(const char * var_name)682 find_var_index(const char *var_name)
683 {
684 int result;
685 size_t i;
686
687 result = -1;
688
689 for (i = 0; i < nvars; i++) {
690 if (strcmp(var_name, vars[i].name) == 0) {
691 result = i;
692 break;
693 }
694 }
695
696 return result;
697 }
698
699 /*
700 * Check the given function name in the given table of names, return 1 if
701 * there is a match.
702 */
check_function_table(char * function,const char * table[],int nfunctions)703 static int check_function_table(char *function, const char *table[],
704 int nfunctions)
705 {
706 int i;
707
708 for (i = 0; i < nfunctions; i++) {
709 if ((strlen(function) == strlen(table[i])) &&
710 (strcmp(function, table[i]) == 0))
711 return 1;
712 }
713
714 return 0;
715 }
716
717 /*
718 * Compare the output from the slave against the given file and report
719 * any differences.
720 */
721 static void
compare_streams(char * filename,bool discard)722 compare_streams(char *filename, bool discard)
723 {
724 char check_file[PATH_MAX], drain[100], ref, data;
725 struct pollfd fds[2];
726 int nfd, check_fd;
727 ssize_t result;
728 size_t offs;
729
730 /*
731 * Don't prepend check path iff check file has an absolute
732 * path.
733 */
734 if (filename[0] != '/') {
735 if (strlcpy(check_file, check_path, sizeof(check_file))
736 >= sizeof(check_file))
737 err(2, "CHECK_PATH too long");
738
739 if (strlcat(check_file, "/", sizeof(check_file))
740 >= sizeof(check_file))
741 err(2, "Could not append / to check file path");
742 } else {
743 check_file[0] = '\0';
744 }
745
746 if (strlcat(check_file, filename, sizeof(check_file))
747 >= sizeof(check_file))
748 err(2, "Path to check file path overflowed");
749
750 if ((check_fd = open(check_file, O_RDONLY, 0)) < 0)
751 err(2, "failed to open file %s line %zu of file %s",
752 check_file, line, cur_file);
753
754 fds[0].fd = check_fd;
755 fds[0].events = POLLIN;
756 fds[1].fd = master;
757 fds[1].events = POLLIN;
758
759 nfd = 2;
760 /*
761 * if we have saved output then only check for data in the
762 * reference file since the slave data may already be drained.
763 */
764 if (saved_output.count > 0)
765 nfd = 1;
766
767 offs = 0;
768 while (poll(fds, nfd, 500) == nfd) {
769 if (fds[0].revents & POLLIN) {
770 if ((result = read(check_fd, &ref, 1)) < 1) {
771 if (result != 0) {
772 err(2,
773 "Bad read on file %s", check_file);
774 } else {
775 break;
776 }
777 }
778 }
779
780 if (saved_output.count > 0) {
781 data = saved_output.data[saved_output.readp];
782 saved_output.count--;
783 saved_output.readp++;
784 /* run out of saved data, switch to file */
785 if (saved_output.count == 0)
786 nfd = 2;
787 } else {
788 if (fds[0].revents & POLLIN) {
789 if (read(master, &data, 1) < 1)
790 err(2, "Bad read on slave pty");
791 } else
792 continue;
793 }
794
795 if (verbose) {
796 fprintf(stderr, "Comparing reference byte 0x%x (%c)"
797 " against slave byte 0x%x (%c)\n",
798 ref, (ref >= ' ') ? ref : '-',
799 data, (data >= ' ' )? data : '-');
800 }
801
802 if (ref != data) {
803 errx(2, "%s, %zu: refresh data from slave does "
804 "not match expected from file %s offs %zu "
805 "[reference 0x%x (%c) != slave 0x%x (%c)]",
806 cur_file, line, check_file, offs,
807 ref, (ref >= ' ') ? ref : '-',
808 data, (data >= ' ') ? data : '-');
809 }
810
811 offs++;
812 }
813
814
815 if (saved_output.count > 0)
816 excess(cur_file, line, __func__, " from slave",
817 &saved_output.data[saved_output.readp], saved_output.count);
818
819 /* discard any excess saved output if required */
820 if (discard) {
821 saved_output.count = 0;
822 saved_output.readp = 0;
823 }
824
825 if ((result = poll(&fds[0], 2, 0)) != 0) {
826 if (result == -1)
827 err(2, "poll of file descriptors failed");
828
829 if ((fds[1].revents & POLLIN) == POLLIN) {
830 save_slave_output(true);
831 } else if ((fds[0].revents & POLLIN) == POLLIN) {
832 /*
833 * handle excess in file if it exists. Poll
834 * says there is data until EOF is read.
835 * Check next read is EOF, if it is not then
836 * the file really has more data than the
837 * slave produced so flag this as a warning.
838 */
839 result = read(check_fd, drain, sizeof(drain));
840 if (result == -1)
841 err(1, "read of data file failed");
842
843 if (result > 0) {
844 excess(check_file, 0, __func__, "", drain,
845 result);
846 }
847 }
848 }
849
850 close(check_fd);
851 }
852
853 /*
854 * Pass a function call and arguments to the slave and wait for the
855 * results. The variable nresults determines how many returns we expect
856 * back from the slave. These results will be validated against the
857 * expected returns or assigned to variables.
858 */
859 static void
do_function_call(size_t nresults)860 do_function_call(size_t nresults)
861 {
862 #define MAX_RESULTS 4
863 char *p;
864 int do_input;
865 size_t i;
866 struct pollfd fds[3];
867 returns_t response[MAX_RESULTS], returns_count;
868 assert(nresults <= MAX_RESULTS);
869
870 do_input = check_function_table(command.function, input_functions,
871 ninput_functions);
872
873 write_func_and_args();
874
875 /*
876 * We should get the number of returns back here, grab it before
877 * doing input otherwise it will confuse the input poll
878 */
879 read_cmd_pipe(&returns_count);
880 if (returns_count.return_type != ret_count)
881 err(2, "expected return type of ret_count but received %s",
882 returns_enum_names[returns_count.return_type]);
883
884 perform_delay(&delay_post_call); /* let slave catch up */
885
886 if (verbose) {
887 fprintf(stderr, "Expect %zu results from slave, slave "
888 "reported %zu\n", nresults, returns_count.return_len);
889 }
890
891 if ((no_input == false) && (do_input == 1)) {
892 if (verbose) {
893 fprintf(stderr, "doing input with inputstr >%s<\n",
894 input_str);
895 }
896
897 if (input_str == NULL)
898 errx(2, "%s, %zu: Call to input function "
899 "but no input defined", cur_file, line);
900
901 fds[0].fd = slvpipe[READ_PIPE];
902 fds[0].events = POLLIN;
903 fds[1].fd = master;
904 fds[1].events = POLLOUT;
905 p = input_str;
906 save_slave_output(false);
907 while(*p != '\0') {
908 perform_delay(&delay_spec);
909
910 if (poll(fds, 2, 0) < 0)
911 err(2, "poll failed");
912 if (fds[0].revents & POLLIN) {
913 warnx("%s, %zu: Slave function "
914 "returned before end of input string",
915 cur_file, line);
916 break;
917 }
918 if ((fds[1].revents & POLLOUT) == 0)
919 continue;
920 if (verbose) {
921 fprintf(stderr, "Writing char >%c< to slave\n",
922 *p);
923 }
924 if (write(master, p, 1) != 1) {
925 warn("%s, %zu: Slave function write error",
926 cur_file, line);
927 break;
928 }
929 p++;
930
931 }
932 save_slave_output(false);
933
934 if (verbose) {
935 fprintf(stderr, "Input done.\n");
936 }
937
938 /* done with the input string, free the resources */
939 free(input_str);
940 input_str = NULL;
941 }
942
943 if (verbose) {
944 fds[0].fd = slvpipe[READ_PIPE];
945 fds[0].events = POLLIN;
946
947 fds[1].fd = slvpipe[WRITE_PIPE];
948 fds[1].events = POLLOUT;
949
950 fds[2].fd = master;
951 fds[2].events = POLLIN | POLLOUT;
952
953 i = poll(&fds[0], 3, 1000);
954 fprintf(stderr, "Poll returned %zu\n", i);
955 for (i = 0; i < 3; i++) {
956 fprintf(stderr, "revents for fd[%zu] = 0x%x\n",
957 i, fds[i].revents);
958 }
959 }
960
961 /* drain any trailing output */
962 save_slave_output(false);
963
964 for (i = 0; i < returns_count.return_len; i++) {
965 read_cmd_pipe(&response[i]);
966 }
967
968 /*
969 * Check for a slave error in the first return slot, if the
970 * slave errored then we may not have the number of returns we
971 * expect but in this case we should report the slave error
972 * instead of a return count mismatch.
973 */
974 if ((returns_count.return_len > 0) &&
975 (response[0].return_type == ret_slave_error))
976 err(2, "Slave returned error: %s",
977 (const char *)response[0].return_value);
978
979 if (returns_count.return_len != nresults)
980 err(2, "Incorrect number of returns from slave, expected %zu "
981 "but received %zu", nresults, returns_count.return_len);
982
983 if (verbose) {
984 for (i = 0; i < nresults; i++) {
985 if ((response[i].return_type != ret_byte) &&
986 (response[i].return_type != ret_err) &&
987 (response[i].return_type != ret_ok))
988 fprintf(stderr,
989 "received response >%s< "
990 "expected",
991 (const char *)response[i].return_value);
992 else
993 fprintf(stderr, "received");
994
995 fprintf(stderr, " return_type %s\n",
996 returns_enum_names[command.returns[i].return_type]);
997 }
998 }
999
1000 for (i = 0; i < nresults; i++) {
1001 if (command.returns[i].return_type != ret_var) {
1002 validate(i, &response[i]);
1003 } else {
1004 vars[command.returns[i].return_index].len =
1005 response[i].return_len;
1006 vars[command.returns[i].return_index].value =
1007 response[i].return_value;
1008 vars[command.returns[i].return_index].type =
1009 response[i].return_type;
1010 }
1011 }
1012
1013 if (verbose && (saved_output.count > 0))
1014 excess(cur_file, line, __func__, " from slave",
1015 &saved_output.data[saved_output.readp], saved_output.count);
1016
1017 init_parse_variables(0);
1018 }
1019
1020 /*
1021 * Write the function and command arguments to the command pipe.
1022 */
1023 static void
write_func_and_args(void)1024 write_func_and_args(void)
1025 {
1026 int i;
1027
1028 if (verbose) {
1029 fprintf(stderr, "calling function >%s<\n", command.function);
1030 }
1031
1032 write_cmd_pipe(command.function);
1033 for (i = 0; i < command.nargs; i++) {
1034 if (command.args[i].arg_type == arg_var)
1035 write_cmd_pipe_args(command.args[i].arg_type,
1036 &vars[command.args[i].var_index]);
1037 else
1038 write_cmd_pipe_args(command.args[i].arg_type,
1039 &command.args[i]);
1040 }
1041
1042 write_cmd_pipe(NULL); /* signal end of arguments */
1043 }
1044
1045 /*
1046 * Initialise the command structure - if initial is non-zero then just set
1047 * everything to sane values otherwise free any memory that was allocated
1048 * when building the structure.
1049 */
1050 void
init_parse_variables(int initial)1051 init_parse_variables(int initial)
1052 {
1053 int i, result;
1054 struct pollfd slave_pty;
1055
1056 if (initial == 0) {
1057 free(command.function);
1058 for (i = 0; i < command.nrets; i++) {
1059 if (command.returns[i].return_type == ret_number)
1060 free(command.returns[i].return_value);
1061 }
1062 free(command.returns);
1063
1064 for (i = 0; i < command.nargs; i++) {
1065 if (command.args[i].arg_type != arg_var)
1066 free(command.args[i].arg_string);
1067 }
1068 free(command.args);
1069 } else {
1070 line = 0;
1071 input_delay = 0;
1072 vars = NULL;
1073 nvars = 0;
1074 input_str = NULL;
1075 saved_output.allocated = 0;
1076 saved_output.count = 0;
1077 saved_output.readp = 0;
1078 saved_output.data = NULL;
1079 }
1080
1081 no_input = false;
1082 command.function = NULL;
1083 command.nargs = 0;
1084 command.args = NULL;
1085 command.nrets = 0;
1086 command.returns = NULL;
1087
1088 /*
1089 * Check the slave pty for stray output from the slave, at this
1090 * point we should not see any data as it should have been
1091 * consumed by the test functions. If we see data then we have
1092 * either a bug or are not handling an output generating function
1093 * correctly.
1094 */
1095 slave_pty.fd = master;
1096 slave_pty.events = POLLIN;
1097 result = poll(&slave_pty, 1, 0);
1098
1099 if (result < 0)
1100 err(2, "Poll of slave pty failed");
1101 else if (result > 0)
1102 warnx("%s, %zu: Unexpected data from slave", cur_file, line);
1103 }
1104
1105 /*
1106 * Validate the response against the expected return. The variable
1107 * i is the i into the rets array in command.
1108 */
1109 static void
validate(int i,void * data)1110 validate(int i, void *data)
1111 {
1112 char *response;
1113 returns_t *byte_response;
1114
1115 byte_response = data;
1116 if ((command.returns[i].return_type != ret_byte) &&
1117 (command.returns[i].return_type != ret_err) &&
1118 (command.returns[i].return_type != ret_ok)) {
1119 if ((byte_response->return_type == ret_byte) ||
1120 (byte_response->return_type == ret_err) ||
1121 (byte_response->return_type == ret_ok))
1122 err(1, "%s: expecting type %s, received type %s"
1123 " at line %zu of file %s", __func__,
1124 returns_enum_names[command.returns[i].return_type],
1125 returns_enum_names[byte_response->return_type],
1126 line, cur_file);
1127
1128 response = byte_response->return_value;
1129 }
1130
1131 switch (command.returns[i].return_type) {
1132 case ret_err:
1133 validate_type(ret_err, byte_response, 0);
1134 break;
1135
1136 case ret_ok:
1137 validate_type(ret_ok, byte_response, 0);
1138 break;
1139
1140 case ret_null:
1141 validate_return("NULL", response, 0);
1142 break;
1143
1144 case ret_nonnull:
1145 validate_return("NULL", response, 1);
1146 break;
1147
1148 case ret_string:
1149 case ret_number:
1150 validate_return(command.returns[i].return_value,
1151 response, 0);
1152 break;
1153
1154 case ret_ref:
1155 validate_reference(i, response);
1156 break;
1157
1158 case ret_byte:
1159 validate_byte(&command.returns[i], byte_response, 0);
1160 break;
1161
1162 default:
1163 err(1, "Malformed statement at line %zu of file %s",
1164 line, cur_file);
1165 break;
1166 }
1167 }
1168
1169 /*
1170 * Validate the return against the contents of a variable.
1171 */
1172 static void
validate_reference(int i,void * data)1173 validate_reference(int i, void *data)
1174 {
1175 char *response;
1176 returns_t *byte_response;
1177 var_t *varp;
1178
1179 varp = &vars[command.returns[i].return_index];
1180
1181 byte_response = data;
1182 if (command.returns[i].return_type != ret_byte)
1183 response = data;
1184
1185 if (verbose) {
1186 fprintf(stderr,
1187 "%s: return type of %s, value %s \n", __func__,
1188 returns_enum_names[varp->type],
1189 (const char *)varp->value);
1190 }
1191
1192 switch (varp->type) {
1193 case ret_string:
1194 case ret_number:
1195 validate_return(varp->value, response, 0);
1196 break;
1197
1198 case ret_byte:
1199 validate_byte(varp->value, byte_response, 0);
1200 break;
1201
1202 default:
1203 err(1,
1204 "Invalid return type for reference at line %zu of file %s",
1205 line, cur_file);
1206 break;
1207 }
1208 }
1209
1210 /*
1211 * Validate the return type against the expected type, throw an error
1212 * if they don't match.
1213 */
1214 static void
validate_type(returns_enum_t expected,returns_t * value,int check)1215 validate_type(returns_enum_t expected, returns_t *value, int check)
1216 {
1217 if (((check == 0) && (expected != value->return_type)) ||
1218 ((check == 1) && (expected == value->return_type)))
1219 err(1, "Validate expected type %s %s %s line %zu of file %s",
1220 returns_enum_names[expected],
1221 (check == 0)? "matching" : "not matching",
1222 returns_enum_names[value->return_type], line, cur_file);
1223
1224 if (verbose) {
1225 fprintf(stderr, "Validate expected type %s %s %s line %zu"
1226 " of file %s\n",
1227 returns_enum_names[expected],
1228 (check == 0)? "matching" : "not matching",
1229 returns_enum_names[value->return_type], line, cur_file);
1230 }
1231 }
1232
1233 /*
1234 * Validate the return value against the expected value, throw an error
1235 * if they don't match.
1236 */
1237 static void
validate_return(const char * expected,const char * value,int check)1238 validate_return(const char *expected, const char *value, int check)
1239 {
1240 if (((check == 0) && strcmp(expected, value) != 0) ||
1241 ((check == 1) && strcmp(expected, value) == 0))
1242 errx(1, "Validate expected %s %s %s line %zu of file %s",
1243 expected,
1244 (check == 0)? "matching" : "not matching", value,
1245 line, cur_file);
1246 if (verbose) {
1247 fprintf(stderr, "Validated expected value %s %s %s "
1248 "at line %zu of file %s\n", expected,
1249 (check == 0)? "matches" : "does not match",
1250 value, line, cur_file);
1251 }
1252 }
1253
1254 /*
1255 * Validate the return value against the expected value, throw an error
1256 * if they don't match expectations.
1257 */
1258 static void
validate_byte(returns_t * expected,returns_t * value,int check)1259 validate_byte(returns_t *expected, returns_t *value, int check)
1260 {
1261 char *ch;
1262 size_t i;
1263
1264 if (verbose) {
1265 ch = value->return_value;
1266 fprintf(stderr, "checking returned byte stream: ");
1267 for (i = 0; i < value->return_len; i++)
1268 fprintf(stderr, "%s0x%x", (i != 0)? ", " : "", ch[i]);
1269 fprintf(stderr, "\n");
1270
1271 fprintf(stderr, "%s byte stream: ",
1272 (check == 0)? "matches" : "does not match");
1273 ch = (char *) expected->return_value;
1274 for (i = 0; i < expected->return_len; i++)
1275 fprintf(stderr, "%s0x%x", (i != 0)? ", " : "", ch[i]);
1276 fprintf(stderr, "\n");
1277 }
1278
1279 /*
1280 * No chance of a match if lengths differ...
1281 */
1282 if ((check == 0) && (expected->return_len != value->return_len))
1283 errx(1, "Byte validation failed, length mismatch, expected %zu,"
1284 "received %zu", expected->return_len, value->return_len);
1285
1286 /*
1287 * If check is 0 then we want to throw an error IFF the byte streams
1288 * do not match, if check is 1 then throw an error if the byte
1289 * streams match.
1290 */
1291 if (((check == 0) && memcmp(expected->return_value, value->return_value,
1292 value->return_len) != 0) ||
1293 ((check == 1) && (expected->return_len == value->return_len) &&
1294 memcmp(expected->return_value, value->return_value,
1295 value->return_len) == 0))
1296 errx(1, "Validate expected %s byte stream at line %zu"
1297 "of file %s",
1298 (check == 0)? "matching" : "not matching", line, cur_file);
1299 if (verbose) {
1300 fprintf(stderr, "Validated expected %s byte stream "
1301 "at line %zu of file %s\n",
1302 (check == 0)? "matching" : "not matching",
1303 line, cur_file);
1304 }
1305 }
1306
1307 /*
1308 * Validate the variable at i against the expected value, throw an
1309 * error if they don't match, if check is non-zero then the match is
1310 * negated.
1311 */
1312 static void
validate_variable(int ret,returns_enum_t type,const void * value,int i,int check)1313 validate_variable(int ret, returns_enum_t type, const void *value, int i,
1314 int check)
1315 {
1316 returns_t *retval;
1317 var_t *varptr;
1318
1319 retval = &command.returns[ret];
1320 varptr = &vars[command.returns[ret].return_index];
1321
1322 if (varptr->value == NULL)
1323 err(1, "Variable %s has no value assigned to it", varptr->name);
1324
1325
1326 if (varptr->type != type)
1327 err(1, "Variable %s is not the expected type", varptr->name);
1328
1329 if (type != ret_byte) {
1330 if ((((check == 0) && strcmp(value, varptr->value) != 0))
1331 || ((check == 1) && strcmp(value, varptr->value) == 0))
1332 err(1, "Variable %s contains %s instead of %s"
1333 " value %s at line %zu of file %s",
1334 varptr->name, (const char *)varptr->value,
1335 (check == 0)? "expected" : "not matching",
1336 (const char *)value,
1337 line, cur_file);
1338 if (verbose) {
1339 fprintf(stderr, "Variable %s contains %s value "
1340 "%s at line %zu of file %s\n",
1341 varptr->name,
1342 (check == 0)? "expected" : "not matching",
1343 (const char *)varptr->value, line, cur_file);
1344 }
1345 } else {
1346 if ((check == 0) && (retval->return_len != varptr->len))
1347 err(1, "Byte validation failed, length mismatch");
1348
1349 /*
1350 * If check is 0 then we want to throw an error IFF
1351 * the byte streams do not match, if check is 1 then
1352 * throw an error if the byte streams match.
1353 */
1354 if (((check == 0) && memcmp(retval->return_value, varptr->value,
1355 varptr->len) != 0) ||
1356 ((check == 1) && (retval->return_len == varptr->len) &&
1357 memcmp(retval->return_value, varptr->value,
1358 varptr->len) == 0))
1359 err(1, "Validate expected %s byte stream at line %zu"
1360 " of file %s",
1361 (check == 0)? "matching" : "not matching",
1362 line, cur_file);
1363 if (verbose) {
1364 fprintf(stderr, "Validated expected %s byte stream "
1365 "at line %zu of file %s\n",
1366 (check == 0)? "matching" : "not matching",
1367 line, cur_file);
1368 }
1369 }
1370 }
1371
1372 /*
1373 * Write a string to the command pipe - we feed the number of bytes coming
1374 * down first to allow storage allocation and then follow up with the data.
1375 * If cmd is NULL then feed a -1 down the pipe to say the end of the args.
1376 */
1377 static void
write_cmd_pipe(char * cmd)1378 write_cmd_pipe(char *cmd)
1379 {
1380 args_t arg;
1381 size_t len;
1382
1383 if (cmd == NULL)
1384 len = 0;
1385 else
1386 len = strlen(cmd);
1387
1388 arg.arg_type = arg_static;
1389 arg.arg_len = len;
1390 arg.arg_string = cmd;
1391 write_cmd_pipe_args(arg.arg_type, &arg);
1392
1393 }
1394
1395 static void
write_cmd_pipe_args(args_state_t type,void * data)1396 write_cmd_pipe_args(args_state_t type, void *data)
1397 {
1398 var_t *var_data;
1399 args_t *arg_data;
1400 int len, send_type;
1401 void *cmd;
1402
1403 arg_data = data;
1404 switch (type) {
1405 case arg_var:
1406 var_data = data;
1407 len = var_data->len;
1408 cmd = var_data->value;
1409 if (type == arg_byte)
1410 send_type = ret_byte;
1411 else
1412 send_type = ret_string;
1413 break;
1414
1415 case arg_null:
1416 send_type = ret_null;
1417 len = 0;
1418 break;
1419
1420 default:
1421 if ((arg_data->arg_len == 0) && (arg_data->arg_string == NULL))
1422 len = -1;
1423 else
1424 len = arg_data->arg_len;
1425 cmd = arg_data->arg_string;
1426 if (type == arg_byte)
1427 send_type = ret_byte;
1428 else
1429 send_type = ret_string;
1430 }
1431
1432 if (verbose) {
1433 fprintf(stderr, "Writing type %s to command pipe\n",
1434 returns_enum_names[send_type]);
1435 }
1436
1437 if (write(cmdpipe[WRITE_PIPE], &send_type, sizeof(int)) < 0)
1438 err(1, "command pipe write for type failed");
1439
1440 if (verbose) {
1441 fprintf(stderr, "Writing length %d to command pipe\n", len);
1442 }
1443
1444 if (write(cmdpipe[WRITE_PIPE], &len, sizeof(int)) < 0)
1445 err(1, "command pipe write for length failed");
1446
1447 if (len > 0) {
1448 if (verbose) {
1449 fprintf(stderr, "Writing data >%s< to command pipe\n",
1450 (const char *)cmd);
1451 }
1452 if (write(cmdpipe[WRITE_PIPE], cmd, len) < 0)
1453 err(1, "command pipe write of data failed");
1454 }
1455 }
1456
1457 /*
1458 * Read a response from the command pipe, first we will receive the
1459 * length of the response then the actual data.
1460 */
1461 static void
read_cmd_pipe(returns_t * response)1462 read_cmd_pipe(returns_t *response)
1463 {
1464 int len, type;
1465 struct pollfd rfd[2];
1466 char *str;
1467
1468 /*
1469 * Check if there is data to read - just in case slave has died, we
1470 * don't want to block on the read and just hang. We also check
1471 * output from the slave because the slave may be blocked waiting
1472 * for a flush on its stdout.
1473 */
1474 rfd[0].fd = slvpipe[READ_PIPE];
1475 rfd[0].events = POLLIN;
1476 rfd[1].fd = master;
1477 rfd[1].events = POLLIN;
1478
1479 do {
1480 if (poll(rfd, 2, 4000) == 0)
1481 errx(2, "%s, %zu: Command pipe read timeout",
1482 cur_file, line);
1483
1484 if ((rfd[1].revents & POLLIN) == POLLIN) {
1485 if (verbose) {
1486 fprintf(stderr,
1487 "draining output from slave\n");
1488 }
1489 save_slave_output(false);
1490 }
1491 }
1492 while((rfd[1].revents & POLLIN) == POLLIN);
1493
1494 if (read(slvpipe[READ_PIPE], &type, sizeof(int)) < 0)
1495 err(1, "command pipe read for type failed");
1496 response->return_type = type;
1497
1498 if ((type != ret_ok) && (type != ret_err) && (type != ret_count)) {
1499 if (read(slvpipe[READ_PIPE], &len, sizeof(int)) < 0)
1500 err(1, "command pipe read for length failed");
1501 response->return_len = len;
1502
1503 if (verbose) {
1504 fprintf(stderr,
1505 "Reading %d bytes from command pipe\n", len);
1506 }
1507
1508 if ((response->return_value = malloc(len + 1)) == NULL)
1509 err(1, "Failed to alloc memory for cmd pipe read");
1510
1511 if (read(slvpipe[READ_PIPE], response->return_value, len) < 0)
1512 err(1, "command pipe read of data failed");
1513
1514 if (response->return_type != ret_byte) {
1515 str = response->return_value;
1516 str[len] = '\0';
1517
1518 if (verbose) {
1519 fprintf(stderr, "Read data >%s< from pipe\n",
1520 (const char *)response->return_value);
1521 }
1522 }
1523 } else {
1524 response->return_value = NULL;
1525 if (type == ret_count) {
1526 if (read(slvpipe[READ_PIPE], &len, sizeof(int)) < 0)
1527 err(1, "command pipe read for number of "
1528 "returns failed");
1529 response->return_len = len;
1530 }
1531
1532 if (verbose) {
1533 fprintf(stderr, "Read type %s from pipe\n",
1534 returns_enum_names[type]);
1535 }
1536 }
1537 }
1538
1539 /*
1540 * Check for writes from the slave on the pty, save the output into a
1541 * buffer for later checking if discard is false.
1542 */
1543 #define MAX_DRAIN 256
1544
1545 static void
save_slave_output(bool discard)1546 save_slave_output(bool discard)
1547 {
1548 char *new_data, drain[MAX_DRAIN];
1549 size_t to_allocate;
1550 ssize_t result;
1551 size_t i;
1552
1553 result = 0;
1554 for (;;) {
1555 if (result == -1)
1556 err(2, "poll of slave pty failed");
1557 result = MAX_DRAIN;
1558 if ((result = read(master, drain, result)) < 0) {
1559 if (errno == EAGAIN)
1560 break;
1561 else
1562 err(2, "draining slave pty failed");
1563 }
1564 if (result == 0)
1565 abort();
1566
1567 if (!discard) {
1568 if ((size_t)result >
1569 (saved_output.allocated - saved_output.count)) {
1570 to_allocate = 1024 * ((result / 1024) + 1);
1571
1572 if ((new_data = realloc(saved_output.data,
1573 saved_output.allocated + to_allocate))
1574 == NULL)
1575 err(2, "Realloc of saved_output failed");
1576 saved_output.data = new_data;
1577 saved_output.allocated += to_allocate;
1578 }
1579
1580 if (verbose) {
1581 fprintf(stderr, "count = %zu, "
1582 "allocated = %zu\n", saved_output.count,
1583 saved_output.allocated);
1584 for (i = 0; i < (size_t)result; i++) {
1585 fprintf(stderr, "Saving slave output "
1586 "at %zu: 0x%x (%c)\n",
1587 saved_output.count + i, drain[i],
1588 (drain[i] >= ' ')? drain[i] : '-');
1589 }
1590 }
1591
1592 memcpy(&saved_output.data[saved_output.count], drain,
1593 result);
1594 saved_output.count += result;
1595
1596 if (verbose) {
1597 fprintf(stderr, "count = %zu, "
1598 "allocated = %zu\n", saved_output.count,
1599 saved_output.allocated);
1600 }
1601 } else {
1602 if (verbose) {
1603 for (i = 0; i < (size_t)result; i++) {
1604 fprintf(stderr, "Discarding slave "
1605 "output 0x%x (%c)\n",
1606 drain[i],
1607 (drain[i] >= ' ')? drain[i] : '-');
1608 }
1609 }
1610 }
1611 }
1612 }
1613
1614 static void
yyerror(const char * msg)1615 yyerror(const char *msg)
1616 {
1617 warnx("%s in line %zu of file %s", msg, line, cur_file);
1618 }
1619