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