xref: /freebsd/contrib/netbsd-tests/lib/libc/db/h_db.c (revision 98e0ffaefb0f241cda3a72395d3be04192ae0d47)
1 /*	$NetBSD: h_db.c,v 1.1 2011/01/07 15:05:58 pgoyette Exp $	*/
2 
3 /*-
4  * Copyright (c) 1992, 1993, 1994
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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 
32 #include <sys/cdefs.h>
33 #ifndef lint
34 __COPYRIGHT("@(#) Copyright (c) 1992, 1993, 1994\
35 	The Regents of the University of California.  All rights reserved.");
36 #endif /* not lint */
37 
38 #ifndef lint
39 #if 0
40 static char sccsid[] = "@(#)dbtest.c	8.17 (Berkeley) 9/1/94";
41 #else
42 __RCSID("$NetBSD: h_db.c,v 1.1 2011/01/07 15:05:58 pgoyette Exp $");
43 #endif
44 #endif /* not lint */
45 
46 #include <sys/param.h>
47 #include <sys/stat.h>
48 
49 #include <ctype.h>
50 #include <errno.h>
51 #include <fcntl.h>
52 #include <limits.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <string.h>
56 #include <stdbool.h>
57 #include <unistd.h>
58 #include <err.h>
59 #include <db.h>
60 
61 enum S { COMMAND, COMPARE, GET, PUT, REMOVE, SEQ, SEQFLAG, KEY, DATA };
62 
63 static void	 compare(DBT *, DBT *);
64 static DBTYPE	 dbtype(const char *);
65 static void	 dump(DB *, int);
66 static void	 get(DB *, DBT *);
67 static void	 getdata(DB *, DBT *, DBT *);
68 static void	 put(DB *, DBT *, DBT *);
69 static void	 rem(DB *, DBT *);
70 static const char *sflags(int);
71 static void	 synk(DB *);
72 static void	*rfile(char *, size_t *);
73 static void	 seq(DB *, DBT *);
74 static u_int	 setflags(char *);
75 static void	*setinfo(DBTYPE, char *);
76 static void	 usage(void) __attribute__((__noreturn__));
77 static void	*xcopy(void *, size_t);
78 static void	 chkcmd(enum S);
79 static void	 chkdata(enum S);
80 static void	 chkkey(enum S);
81 
82 #ifdef STATISTICS
83 extern void __bt_stat(DB *);
84 #endif
85 
86 static DBTYPE type;			/* Database type. */
87 static void *infop;			/* Iflags. */
88 static size_t lineno;			/* Current line in test script. */
89 static u_int flags;				/* Current DB flags. */
90 static int ofd = STDOUT_FILENO;		/* Standard output fd. */
91 
92 static DB *XXdbp;			/* Global for gdb. */
93 static size_t XXlineno;			/* Fast breakpoint for gdb. */
94 
95 int
96 main(int argc, char *argv[])
97 {
98 	extern int optind;
99 	extern char *optarg;
100 	enum S command = COMMAND, state;
101 	DB *dbp;
102 	DBT data, key, keydata;
103 	size_t len;
104 	int ch, oflags, sflag;
105 	char *fname, *infoarg, *p, *t, buf[8 * 1024];
106 	bool unlink_dbfile;
107 
108 	infoarg = NULL;
109 	fname = NULL;
110 	unlink_dbfile = false;
111 	oflags = O_CREAT | O_RDWR;
112 	sflag = 0;
113 	while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
114 		switch (ch) {
115 		case 'f':
116 			fname = optarg;
117 			break;
118 		case 'i':
119 			infoarg = optarg;
120 			break;
121 		case 'l':
122 			oflags |= DB_LOCK;
123 			break;
124 		case 'o':
125 			if ((ofd = open(optarg,
126 			    O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
127 				err(1, "Cannot create `%s'", optarg);
128 			break;
129 		case 's':
130 			sflag = 1;
131 			break;
132 		case '?':
133 		default:
134 			usage();
135 		}
136 	argc -= optind;
137 	argv += optind;
138 
139 	if (argc != 2)
140 		usage();
141 
142 	/* Set the type. */
143 	type = dbtype(*argv++);
144 
145 	/* Open the descriptor file. */
146         if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
147 	    err(1, "Cannot reopen `%s'", *argv);
148 
149 	/* Set up the db structure as necessary. */
150 	if (infoarg == NULL)
151 		infop = NULL;
152 	else
153 		for (p = strtok(infoarg, ",\t "); p != NULL;
154 		    p = strtok(0, ",\t "))
155 			if (*p != '\0')
156 				infop = setinfo(type, p);
157 
158 	/*
159 	 * Open the DB.  Delete any preexisting copy, you almost never
160 	 * want it around, and it often screws up tests.
161 	 */
162 	if (fname == NULL) {
163 		const char *q = getenv("TMPDIR");
164 		if (q == NULL)
165 			q = "/var/tmp";
166 		(void)snprintf(buf, sizeof(buf), "%s/__dbtest", q);
167 		fname = buf;
168 		(void)unlink(buf);
169 		unlink_dbfile = true;
170 	} else  if (!sflag)
171 		(void)unlink(fname);
172 
173 	if ((dbp = dbopen(fname,
174 	    oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
175 		err(1, "Cannot dbopen `%s'", fname);
176 	XXdbp = dbp;
177 	if (unlink_dbfile)
178 		(void)unlink(fname);
179 
180 	state = COMMAND;
181 	for (lineno = 1;
182 	    (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
183 		/* Delete the newline, displaying the key/data is easier. */
184 		if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
185 			*t = '\0';
186 		if ((len = strlen(buf)) == 0 || isspace((unsigned char)*p) ||
187 		    *p == '#')
188 			continue;
189 
190 		/* Convenient gdb break point. */
191 		if (XXlineno == lineno)
192 			XXlineno = 1;
193 		switch (*p) {
194 		case 'c':			/* compare */
195 			chkcmd(state);
196 			state = KEY;
197 			command = COMPARE;
198 			break;
199 		case 'e':			/* echo */
200 			chkcmd(state);
201 			/* Don't display the newline, if CR at EOL. */
202 			if (p[len - 2] == '\r')
203 				--len;
204 			if (write(ofd, p + 1, len - 1) != (ssize_t)len - 1 ||
205 			    write(ofd, "\n", 1) != 1)
206 				err(1, "write failed");
207 			break;
208 		case 'g':			/* get */
209 			chkcmd(state);
210 			state = KEY;
211 			command = GET;
212 			break;
213 		case 'p':			/* put */
214 			chkcmd(state);
215 			state = KEY;
216 			command = PUT;
217 			break;
218 		case 'r':			/* remove */
219 			chkcmd(state);
220                         if (flags == R_CURSOR) {
221 				rem(dbp, &key);
222 				state = COMMAND;
223                         } else {
224 				state = KEY;
225 				command = REMOVE;
226 			}
227 			break;
228 		case 'S':			/* sync */
229 			chkcmd(state);
230 			synk(dbp);
231 			state = COMMAND;
232 			break;
233 		case 's':			/* seq */
234 			chkcmd(state);
235 			if (flags == R_CURSOR) {
236 				state = KEY;
237 				command = SEQ;
238 			} else
239 				seq(dbp, &key);
240 			break;
241 		case 'f':
242 			flags = setflags(p + 1);
243 			break;
244 		case 'D':			/* data file */
245 			chkdata(state);
246 			data.data = rfile(p + 1, &data.size);
247 			goto ldata;
248 		case 'd':			/* data */
249 			chkdata(state);
250 			data.data = xcopy(p + 1, len - 1);
251 			data.size = len - 1;
252 ldata:			switch (command) {
253 			case COMPARE:
254 				compare(&keydata, &data);
255 				break;
256 			case PUT:
257 				put(dbp, &key, &data);
258 				break;
259 			default:
260 				errx(1, "line %zu: command doesn't take data",
261 				    lineno);
262 			}
263 			if (type != DB_RECNO)
264 				free(key.data);
265 			free(data.data);
266 			state = COMMAND;
267 			break;
268 		case 'K':			/* key file */
269 			chkkey(state);
270 			if (type == DB_RECNO)
271 				errx(1, "line %zu: 'K' not available for recno",
272 				    lineno);
273 			key.data = rfile(p + 1, &key.size);
274 			goto lkey;
275 		case 'k':			/* key */
276 			chkkey(state);
277 			if (type == DB_RECNO) {
278 				static recno_t recno;
279 				recno = atoi(p + 1);
280 				key.data = &recno;
281 				key.size = sizeof(recno);
282 			} else {
283 				key.data = xcopy(p + 1, len - 1);
284 				key.size = len - 1;
285 			}
286 lkey:			switch (command) {
287 			case COMPARE:
288 				getdata(dbp, &key, &keydata);
289 				state = DATA;
290 				break;
291 			case GET:
292 				get(dbp, &key);
293 				if (type != DB_RECNO)
294 					free(key.data);
295 				state = COMMAND;
296 				break;
297 			case PUT:
298 				state = DATA;
299 				break;
300 			case REMOVE:
301 				rem(dbp, &key);
302 				if ((type != DB_RECNO) && (flags != R_CURSOR))
303 					free(key.data);
304 				state = COMMAND;
305 				break;
306 			case SEQ:
307 				seq(dbp, &key);
308 				if ((type != DB_RECNO) && (flags != R_CURSOR))
309 					free(key.data);
310 				state = COMMAND;
311 				break;
312 			default:
313 				errx(1, "line %zu: command doesn't take a key",
314 				    lineno);
315 			}
316 			break;
317 		case 'o':
318 			dump(dbp, p[1] == 'r');
319 			break;
320 		default:
321 			errx(1, "line %zu: %s: unknown command character",
322 			    lineno, p);
323 		}
324 	}
325 #ifdef STATISTICS
326 	/*
327 	 * -l must be used (DB_LOCK must be set) for this to be
328 	 * used, otherwise a page will be locked and it will fail.
329 	 */
330 	if (type == DB_BTREE && oflags & DB_LOCK)
331 		__bt_stat(dbp);
332 #endif
333 	if ((*dbp->close)(dbp))
334 		err(1, "db->close failed");
335 	(void)close(ofd);
336 	return 0;
337 }
338 
339 #define	NOOVERWRITE	"put failed, would overwrite key\n"
340 
341 static void
342 compare(DBT *db1, DBT *db2)
343 {
344 	size_t len;
345 	u_char *p1, *p2;
346 
347 	if (db1->size != db2->size)
348 		printf("compare failed: key->data len %zu != data len %zu\n",
349 		    db1->size, db2->size);
350 
351 	len = MIN(db1->size, db2->size);
352 	for (p1 = db1->data, p2 = db2->data; len--;)
353 		if (*p1++ != *p2++) {
354 			printf("compare failed at offset %lu\n",
355 			    (unsigned long)(p1 - (u_char *)db1->data));
356 			break;
357 		}
358 }
359 
360 static void
361 get(DB *dbp, DBT *kp)
362 {
363 	DBT data;
364 
365 	switch ((*dbp->get)(dbp, kp, &data, flags)) {
366 	case 0:
367 		(void)write(ofd, data.data, data.size);
368 		if (ofd == STDOUT_FILENO)
369 			(void)write(ofd, "\n", 1);
370 		break;
371 	case -1:
372 		err(1, "line %zu: get failed", lineno);
373 		/* NOTREACHED */
374 	case 1:
375 #define	NOSUCHKEY	"get failed, no such key\n"
376 		if (ofd != STDOUT_FILENO)
377 			(void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
378 		else
379 			(void)fprintf(stderr, "%zu: %.*s: %s",
380 			    lineno, (int)MIN(kp->size, 20),
381 			    (const char *)kp->data,
382 			    NOSUCHKEY);
383 #undef	NOSUCHKEY
384 		break;
385 	}
386 }
387 
388 static void
389 getdata(DB *dbp, DBT *kp, DBT *dp)
390 {
391 	switch ((*dbp->get)(dbp, kp, dp, flags)) {
392 	case 0:
393 		return;
394 	case -1:
395 		err(1, "line %zu: getdata failed", lineno);
396 		/* NOTREACHED */
397 	case 1:
398 		errx(1, "line %zu: getdata failed, no such key", lineno);
399 		/* NOTREACHED */
400 	}
401 }
402 
403 static void
404 put(DB *dbp, DBT *kp, DBT *dp)
405 {
406 	switch ((*dbp->put)(dbp, kp, dp, flags)) {
407 	case 0:
408 		break;
409 	case -1:
410 		err(1, "line %zu: put failed", lineno);
411 		/* NOTREACHED */
412 	case 1:
413 		(void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
414 		break;
415 	}
416 }
417 
418 static void
419 rem(DB *dbp, DBT *kp)
420 {
421 	switch ((*dbp->del)(dbp, kp, flags)) {
422 	case 0:
423 		break;
424 	case -1:
425 		err(1, "line %zu: rem failed", lineno);
426 		/* NOTREACHED */
427 	case 1:
428 #define	NOSUCHKEY	"rem failed, no such key\n"
429 		if (ofd != STDOUT_FILENO)
430 			(void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
431 		else if (flags != R_CURSOR)
432 			(void)fprintf(stderr, "%zu: %.*s: %s",
433 			    lineno, (int)MIN(kp->size, 20),
434 			    (const char *)kp->data, NOSUCHKEY);
435 		else
436 			(void)fprintf(stderr,
437 			    "%zu: rem of cursor failed\n", lineno);
438 #undef	NOSUCHKEY
439 		break;
440 	}
441 }
442 
443 static void
444 synk(DB *dbp)
445 {
446 	switch ((*dbp->sync)(dbp, flags)) {
447 	case 0:
448 		break;
449 	case -1:
450 		err(1, "line %zu: synk failed", lineno);
451 		/* NOTREACHED */
452 	}
453 }
454 
455 static void
456 seq(DB *dbp, DBT *kp)
457 {
458 	DBT data;
459 
460 	switch (dbp->seq(dbp, kp, &data, flags)) {
461 	case 0:
462 		(void)write(ofd, data.data, data.size);
463 		if (ofd == STDOUT_FILENO)
464 			(void)write(ofd, "\n", 1);
465 		break;
466 	case -1:
467 		err(1, "line %zu: seq failed", lineno);
468 		/* NOTREACHED */
469 	case 1:
470 #define	NOSUCHKEY	"seq failed, no such key\n"
471 		if (ofd != STDOUT_FILENO)
472 			(void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
473 		else if (flags == R_CURSOR)
474 			(void)fprintf(stderr, "%zu: %.*s: %s",
475 			    lineno, (int)MIN(kp->size, 20),
476 			    (const char *)kp->data, NOSUCHKEY);
477 		else
478 			(void)fprintf(stderr,
479 			    "%zu: seq (%s) failed\n", lineno, sflags(flags));
480 #undef	NOSUCHKEY
481 		break;
482 	}
483 }
484 
485 static void
486 dump(DB *dbp, int rev)
487 {
488 	DBT key, data;
489 	int xflags, nflags;
490 
491 	if (rev) {
492 		xflags = R_LAST;
493 		nflags = R_PREV;
494 	} else {
495 		xflags = R_FIRST;
496 		nflags = R_NEXT;
497 	}
498 	for (;; xflags = nflags)
499 		switch (dbp->seq(dbp, &key, &data, xflags)) {
500 		case 0:
501 			(void)write(ofd, data.data, data.size);
502 			if (ofd == STDOUT_FILENO)
503 				(void)write(ofd, "\n", 1);
504 			break;
505 		case 1:
506 			goto done;
507 		case -1:
508 			err(1, "line %zu: (dump) seq failed", lineno);
509 			/* NOTREACHED */
510 		}
511 done:	return;
512 }
513 
514 static u_int
515 setflags(char *s)
516 {
517 	char *p;
518 
519 	for (; isspace((unsigned char)*s); ++s);
520 	if (*s == '\n' || *s == '\0')
521 		return 0;
522 	if ((p = strchr(s, '\n')) != NULL)
523 		*p = '\0';
524 	if (!strcmp(s, "R_CURSOR"))		return R_CURSOR;
525 	if (!strcmp(s, "R_FIRST"))		return R_FIRST;
526 	if (!strcmp(s, "R_IAFTER")) 		return R_IAFTER;
527 	if (!strcmp(s, "R_IBEFORE")) 		return R_IBEFORE;
528 	if (!strcmp(s, "R_LAST")) 		return R_LAST;
529 	if (!strcmp(s, "R_NEXT")) 		return R_NEXT;
530 	if (!strcmp(s, "R_NOOVERWRITE"))	return R_NOOVERWRITE;
531 	if (!strcmp(s, "R_PREV"))		return R_PREV;
532 	if (!strcmp(s, "R_SETCURSOR"))		return R_SETCURSOR;
533 
534 	errx(1, "line %zu: %s: unknown flag", lineno, s);
535 	/* NOTREACHED */
536 }
537 
538 static const char *
539 sflags(int xflags)
540 {
541 	switch (xflags) {
542 	case R_CURSOR:		return "R_CURSOR";
543 	case R_FIRST:		return "R_FIRST";
544 	case R_IAFTER:		return "R_IAFTER";
545 	case R_IBEFORE:		return "R_IBEFORE";
546 	case R_LAST:		return "R_LAST";
547 	case R_NEXT:		return "R_NEXT";
548 	case R_NOOVERWRITE:	return "R_NOOVERWRITE";
549 	case R_PREV:		return "R_PREV";
550 	case R_SETCURSOR:	return "R_SETCURSOR";
551 	}
552 
553 	return "UNKNOWN!";
554 }
555 
556 static DBTYPE
557 dbtype(const char *s)
558 {
559 	if (!strcmp(s, "btree"))
560 		return DB_BTREE;
561 	if (!strcmp(s, "hash"))
562 		return DB_HASH;
563 	if (!strcmp(s, "recno"))
564 		return DB_RECNO;
565 	errx(1, "%s: unknown type (use btree, hash or recno)", s);
566 	/* NOTREACHED */
567 }
568 
569 static void *
570 setinfo(DBTYPE dtype, char *s)
571 {
572 	static BTREEINFO ib;
573 	static HASHINFO ih;
574 	static RECNOINFO rh;
575 	char *eq;
576 
577 	if ((eq = strchr(s, '=')) == NULL)
578 		errx(1, "%s: illegal structure set statement", s);
579 	*eq++ = '\0';
580 	if (!isdigit((unsigned char)*eq))
581 		errx(1, "%s: structure set statement must be a number", s);
582 
583 	switch (dtype) {
584 	case DB_BTREE:
585 		if (!strcmp("flags", s)) {
586 			ib.flags = atoi(eq);
587 			return &ib;
588 		}
589 		if (!strcmp("cachesize", s)) {
590 			ib.cachesize = atoi(eq);
591 			return &ib;
592 		}
593 		if (!strcmp("maxkeypage", s)) {
594 			ib.maxkeypage = atoi(eq);
595 			return &ib;
596 		}
597 		if (!strcmp("minkeypage", s)) {
598 			ib.minkeypage = atoi(eq);
599 			return &ib;
600 		}
601 		if (!strcmp("lorder", s)) {
602 			ib.lorder = atoi(eq);
603 			return &ib;
604 		}
605 		if (!strcmp("psize", s)) {
606 			ib.psize = atoi(eq);
607 			return &ib;
608 		}
609 		break;
610 	case DB_HASH:
611 		if (!strcmp("bsize", s)) {
612 			ih.bsize = atoi(eq);
613 			return &ih;
614 		}
615 		if (!strcmp("ffactor", s)) {
616 			ih.ffactor = atoi(eq);
617 			return &ih;
618 		}
619 		if (!strcmp("nelem", s)) {
620 			ih.nelem = atoi(eq);
621 			return &ih;
622 		}
623 		if (!strcmp("cachesize", s)) {
624 			ih.cachesize = atoi(eq);
625 			return &ih;
626 		}
627 		if (!strcmp("lorder", s)) {
628 			ih.lorder = atoi(eq);
629 			return &ih;
630 		}
631 		break;
632 	case DB_RECNO:
633 		if (!strcmp("flags", s)) {
634 			rh.flags = atoi(eq);
635 			return &rh;
636 		}
637 		if (!strcmp("cachesize", s)) {
638 			rh.cachesize = atoi(eq);
639 			return &rh;
640 		}
641 		if (!strcmp("lorder", s)) {
642 			rh.lorder = atoi(eq);
643 			return &rh;
644 		}
645 		if (!strcmp("reclen", s)) {
646 			rh.reclen = atoi(eq);
647 			return &rh;
648 		}
649 		if (!strcmp("bval", s)) {
650 			rh.bval = atoi(eq);
651 			return &rh;
652 		}
653 		if (!strcmp("psize", s)) {
654 			rh.psize = atoi(eq);
655 			return &rh;
656 		}
657 		break;
658 	}
659 	errx(1, "%s: unknown structure value", s);
660 	/* NOTREACHED */
661 }
662 
663 static void *
664 rfile(char *name, size_t *lenp)
665 {
666 	struct stat sb;
667 	void *p;
668 	int fd;
669 	char *np;
670 
671 	for (; isspace((unsigned char)*name); ++name)
672 		continue;
673 	if ((np = strchr(name, '\n')) != NULL)
674 		*np = '\0';
675 	if ((fd = open(name, O_RDONLY, 0)) == -1 || fstat(fd, &sb) == -1)
676 		err(1, "Cannot open `%s'", name);
677 #ifdef NOT_PORTABLE
678 	if (sb.st_size > (off_t)SIZE_T_MAX) {
679 		errno = E2BIG;
680 		err("Cannot process `%s'", name);
681 	}
682 #endif
683 	if ((p = malloc((size_t)sb.st_size)) == NULL)
684 		err(1, "Cannot allocate %zu bytes", (size_t)sb.st_size);
685 	if (read(fd, p, (ssize_t)sb.st_size) != (ssize_t)sb.st_size)
686 		err(1, "read failed");
687 	*lenp = (size_t)sb.st_size;
688 	(void)close(fd);
689 	return p;
690 }
691 
692 static void *
693 xcopy(void *text, size_t len)
694 {
695 	void *p;
696 
697 	if ((p = malloc(len)) == NULL)
698 		err(1, "Cannot allocate %zu bytes", len);
699 	(void)memmove(p, text, len);
700 	return p;
701 }
702 
703 static void
704 chkcmd(enum S state)
705 {
706 	if (state != COMMAND)
707 		errx(1, "line %zu: not expecting command", lineno);
708 }
709 
710 static void
711 chkdata(enum S state)
712 {
713 	if (state != DATA)
714 		errx(1, "line %zu: not expecting data", lineno);
715 }
716 
717 static void
718 chkkey(enum S state)
719 {
720 	if (state != KEY)
721 		errx(1, "line %zu: not expecting a key", lineno);
722 }
723 
724 static void
725 usage(void)
726 {
727 	(void)fprintf(stderr,
728 	    "Usage: %s [-l] [-f file] [-i info] [-o file] type script\n",
729 	    getprogname());
730 	exit(1);
731 }
732