db.c revision 1.19
1 /* $NetBSD: db.c,v 1.19 2008/09/05 05:04:40 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 2002-2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Luke Mewburn of Wasabi Systems. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #ifdef __RCSID 35 __RCSID("$NetBSD: db.c,v 1.19 2008/09/05 05:04:40 lukem Exp $"); 36 #endif /* __RCSID */ 37 #endif /* not lint */ 38 39 #include <db.h> 40 #include <ctype.h> 41 #include <err.h> 42 #include <fcntl.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <unistd.h> 47 #include <vis.h> 48 49 50 typedef enum { 51 F_WRITE = 1<<0, 52 F_DELETE = 1<<1, 53 F_SHOW_KEY = 1<<2, 54 F_SHOW_VALUE = 1<<3, 55 F_QUIET = 1<<10, 56 F_IGNORECASE = 1<<11, 57 F_ENDIAN_BIG = 1<<12, 58 F_ENDIAN_LITTLE = 1<<13, 59 F_NO_NUL = 1<<14, 60 F_CREATENEW = 1<<20, 61 F_DUPLICATES = 1<<21, 62 F_REPLACE = 1<<22, 63 F_ENCODE_KEY = 1<<23, 64 F_ENCODE_VAL = 1<<24, 65 F_DECODE_KEY = 1<<25, 66 F_DECODE_VAL = 1<<26, 67 } flags_t; 68 69 int main(int, char *[]); 70 void db_print(DBT *, DBT *); 71 int db_dump(void); 72 int db_del(char *); 73 int db_get(char *); 74 int db_put(char *, char *); 75 int parseline(FILE *, const char *, char **, char **); 76 int encode_data(size_t, char *, char **); 77 int decode_data(char *, char **); 78 void parse_encode_decode_arg(const char *, int); 79 int parse_encode_option(char **); 80 void usage(void); 81 82 flags_t flags = 0; 83 DB *db; 84 char *outputsep = "\t"; 85 int visflags = 0; 86 char *extra_echars = NULL; 87 88 int 89 main(int argc, char *argv[]) 90 { 91 struct { 92 char *file; 93 char *type; 94 DBTYPE dbtype; 95 void *info; 96 int flags; 97 mode_t mode; 98 } oi; 99 BTREEINFO btreeinfo; 100 HASHINFO hashinfo; 101 FILE *infp; 102 const char *infile, *fieldsep; 103 char *p, *key, *val; 104 int ch, rv; 105 106 setprogname(argv[0]); 107 108 infile = NULL; 109 fieldsep = " "; 110 infp = NULL; 111 memset(&oi, 0, sizeof(oi)); 112 oi.mode = 0644; 113 114 /* parse arguments */ 115 while ( (ch = getopt(argc, argv, 116 "CDdE:F:f:iKm:NO:qRS:T:U:VwX:")) != -1) { 117 switch (ch) { 118 119 case 'C': 120 flags |= F_CREATENEW; 121 break; 122 123 case 'D': 124 flags |= F_DUPLICATES; 125 break; 126 127 case 'd': 128 flags |= F_DELETE; 129 break; 130 131 case 'E': 132 if (! optarg[0] || optarg[1]) 133 goto badendian; 134 switch (toupper((int)optarg[0])) { 135 case 'B': 136 flags |= F_ENDIAN_BIG; 137 break; 138 case 'L': 139 flags |= F_ENDIAN_LITTLE; 140 break; 141 case 'H': 142 flags &= ~(F_ENDIAN_BIG | F_ENDIAN_LITTLE); 143 break; 144 default: 145 badendian: 146 errx(1, "Bad endian `%s'", optarg); 147 } 148 break; 149 150 case 'F': 151 if (! optarg[0]) 152 errx(1, "Invalid field separator `%s'", 153 optarg); 154 fieldsep = optarg; 155 break; 156 157 case 'f': 158 infile = optarg; 159 break; 160 161 case 'i': 162 flags |= F_IGNORECASE; 163 break; 164 165 case 'K': 166 flags |= F_SHOW_KEY; 167 break; 168 169 case 'm': 170 oi.mode = (int)strtol(optarg, &p, 8); 171 if (p == optarg || *p != '\0') 172 errx(1, "Invalid octal number `%s'", optarg); 173 break; 174 175 case 'N': 176 flags |= F_NO_NUL; 177 break; 178 179 case 'O': 180 outputsep = optarg; 181 break; 182 183 case 'q': 184 flags |= F_QUIET; 185 break; 186 187 case 'R': 188 flags |= F_REPLACE; 189 break; 190 191 case 'S': 192 parse_encode_decode_arg(optarg, 1 /* encode */); 193 if (! (flags & (F_ENCODE_KEY | F_ENCODE_VAL))) 194 errx(1, "Invalid encoding argument `%s'", 195 optarg); 196 break; 197 198 case 'T': 199 visflags = parse_encode_option(&optarg); 200 if (! visflags) 201 errx(1, "Invalid encoding/decoding option `%s'", 202 optarg); 203 break; 204 205 case 'U': 206 parse_encode_decode_arg(optarg, 0 /* decode */); 207 if (! (flags & (F_DECODE_KEY | F_DECODE_VAL))) 208 errx(1, "Invalid decoding argument `%s'", 209 optarg); 210 break; 211 212 case 'V': 213 flags |= F_SHOW_VALUE; 214 break; 215 216 case 'w': 217 flags |= F_WRITE; 218 break; 219 220 case 'X': 221 extra_echars = optarg; 222 break; 223 224 default: 225 usage(); 226 227 } 228 } 229 argc -= optind; 230 argv += optind; 231 232 /* validate arguments */ 233 if (argc < 2) 234 usage(); 235 oi.type = argv[0]; 236 oi.file = argv[1]; 237 argc -= 2; 238 argv += 2; 239 240 if (flags & F_WRITE) { 241 if (flags & (F_SHOW_KEY | F_SHOW_VALUE | F_DELETE)) 242 usage(); 243 if ((!infile && argc < 2) || (argc % 2)) 244 usage(); 245 if (0 != (visflags & ~(VIS_HTTPSTYLE))) 246 errx(1, "Unsupported decoding option provided to -T"); 247 oi.flags = O_RDWR | O_CREAT | O_EXLOCK; 248 if (flags & F_CREATENEW) 249 oi.flags |= O_TRUNC; 250 } else if (flags & F_DELETE) { 251 if (flags & (F_SHOW_KEY | F_SHOW_VALUE | F_WRITE)) 252 usage(); 253 if (!infile && argc < 1) 254 usage(); 255 if (0 != (visflags & ~(VIS_HTTPSTYLE))) 256 errx(1, "Unsupported decoding option provided to -T"); 257 oi.flags = O_RDWR | O_CREAT | O_EXLOCK; 258 } else { 259 if (! (flags & (F_SHOW_KEY | F_SHOW_VALUE))) 260 flags |= (F_SHOW_KEY | F_SHOW_VALUE); 261 oi.flags = O_RDONLY | O_SHLOCK; 262 } 263 264 /* validate oi.type */ 265 if (strcmp(oi.type, "btree") == 0) { 266 memset(&btreeinfo, 0, sizeof(btreeinfo)); 267 if (flags & F_ENDIAN_BIG) 268 btreeinfo.lorder = 4321; 269 else if (flags & F_ENDIAN_LITTLE) 270 btreeinfo.lorder = 1234; 271 if (flags & F_DUPLICATES) 272 btreeinfo.flags = R_DUP; 273 btreeinfo.cachesize = 1024 * 1024; 274 oi.info = &btreeinfo; 275 oi.dbtype = DB_BTREE; 276 } else if (strcmp(oi.type, "hash") == 0) { 277 memset(&hashinfo, 0, sizeof(hashinfo)); 278 if (flags & F_ENDIAN_BIG) 279 hashinfo.lorder = 4321; 280 else if (flags & F_ENDIAN_LITTLE) 281 hashinfo.lorder = 1234; 282 hashinfo.cachesize = 1024 * 1024; 283 oi.info = &hashinfo; 284 oi.dbtype = DB_HASH; 285 } else { 286 warnx("Unknown database type `%s'", oi.type); 287 usage(); 288 } 289 290 if (infile) { 291 if (strcmp(infile, "-") == 0) 292 infp = stdin; 293 else if ((infp = fopen(infile, "r")) == NULL) 294 err(1, "Opening input file `%s'", infile); 295 } 296 297 /* open database */ 298 db = dbopen(oi.file, oi.flags, oi.mode, oi.dbtype, oi.info); 299 if (db == NULL) 300 err(1, "Opening database `%s'", oi.file); 301 302 303 /* manipulate database */ 304 rv = 0; 305 if (flags & F_WRITE) { /* write entries */ 306 for (ch = 0; ch < argc; ch += 2) 307 if ((rv = db_put(argv[ch], argv[ch+1]))) 308 goto cleanup; 309 if (infp) { 310 while (parseline(infp, fieldsep, &key, &val)) { 311 if ((rv = db_put(key, val))) 312 goto cleanup; 313 } 314 if (ferror(infp)) { 315 warnx("Reading `%s'", infile); 316 goto cleanup; 317 } 318 } 319 } else if (!infp && argc == 0) { /* read all */ 320 db_dump(); 321 } else { /* read/delete specific */ 322 int (*dbop)(char *); 323 324 if (flags & F_DELETE) 325 dbop = db_del; 326 else 327 dbop = db_get; 328 for (ch = 0; ch < argc; ch++) { 329 if ((rv = dbop(argv[ch]))) 330 goto cleanup; 331 } 332 if (infp) { 333 while (parseline(infp, fieldsep, &key, NULL)) { 334 if ((rv = dbop(key))) 335 goto cleanup; 336 } 337 if (ferror(infp)) { 338 warnx("Reading `%s'", infile); 339 goto cleanup; 340 } 341 } 342 } 343 344 /* close database */ 345 cleanup: 346 if (db->close(db) == -1) 347 err(1, "Closing database `%s'", oi.file); 348 if (infp) 349 fclose(infp); 350 return (rv); 351 } 352 353 void 354 db_print(DBT *key, DBT *val) 355 { 356 int len; 357 char *data; 358 359 #define MINUSNUL(x) ((x) > 0 ? (x) - (flags & F_NO_NUL ? 0 : 1) : 0) 360 361 if (flags & F_SHOW_KEY) { 362 if (flags & F_ENCODE_KEY) { 363 len = encode_data(MINUSNUL(key->size), 364 (char *)key->data, &data); 365 } else { 366 len = (int)MINUSNUL(key->size); 367 data = (char *)key->data; 368 } 369 printf("%.*s", len, data); 370 } 371 if ((flags & F_SHOW_KEY) && (flags & F_SHOW_VALUE)) 372 printf("%s", outputsep); 373 if (flags & F_SHOW_VALUE) { 374 if (flags & F_ENCODE_VAL) { 375 len = encode_data(MINUSNUL(val->size), 376 (char *)val->data, &data); 377 } else { 378 len = (int)MINUSNUL(val->size); 379 data = (char *)val->data; 380 } 381 printf("%.*s", len, data); 382 } 383 printf("\n"); 384 } 385 386 int 387 db_dump(void) 388 { 389 DBT key, val; 390 int rv; 391 392 while ((rv = db->seq(db, &key, &val, R_NEXT)) == 0) 393 db_print(&key, &val); 394 if (rv == -1) 395 warn("Error dumping database"); 396 return (rv == 1 ? 0 : 1); 397 } 398 399 static void 400 db_makekey(DBT *key, char *keystr, int downcase, int decode) 401 { 402 char *p, *ks; 403 int klen; 404 405 memset(key, 0, sizeof(*key)); 406 if (decode) { 407 if ((klen = decode_data(keystr, &ks)) == -1) 408 errx(1, "Invalid escape sequence in `%s'", keystr); 409 } else { 410 klen = strlen(keystr); 411 ks = keystr; 412 } 413 key->data = ks; 414 key->size = klen + (flags & F_NO_NUL ? 0 : 1); 415 if (downcase && (flags & F_IGNORECASE)) { 416 for (p = ks; *p; p++) 417 if (isupper((int)*p)) 418 *p = tolower((int)*p); 419 } 420 } 421 422 int 423 db_del(char *keystr) 424 { 425 DBT key; 426 int r = 0; 427 428 db_makekey(&key, keystr, 1, (flags & F_DECODE_KEY ? 1 : 0)); 429 switch (db->del(db, &key, 0)) { 430 case -1: 431 warn("Error deleting key `%s'", keystr); 432 r = 1; 433 break; 434 case 0: 435 if (! (flags & F_QUIET)) 436 printf("Deleted key `%s'\n", keystr); 437 break; 438 case 1: 439 warnx("Unknown key `%s'", keystr); 440 break; 441 } 442 if (flags & F_DECODE_KEY) 443 free(key.data); 444 return (r); 445 } 446 447 int 448 db_get(char *keystr) 449 { 450 DBT key, val; 451 char *wantkey; 452 int r, found; 453 u_int seqflags; 454 455 db_makekey(&key, keystr, 1, (flags & F_DECODE_KEY ? 1 : 0)); 456 wantkey = strdup(key.data); 457 if (wantkey == NULL) 458 err(1, "Cannot allocate key buffer"); 459 460 found = 0; 461 seqflags = R_CURSOR; 462 while ((r = db->seq(db, &key, &val, seqflags)) == 0) { 463 if (strcmp((char *)key.data, wantkey) != 0) { 464 r = 1; 465 break; 466 } 467 seqflags = R_NEXT; 468 found++; 469 db_print(&key, &val); 470 if (! (flags & F_DUPLICATES)) 471 break; 472 } 473 474 switch (r) { 475 case -1: 476 warn("Error reading key `%s'", keystr); 477 r = 1; 478 break; 479 case 0: 480 break; 481 case 1: 482 if (found) { 483 r = 0; 484 break; 485 } 486 if (! (flags & F_QUIET)) { 487 warnx("Unknown key `%s'", keystr); 488 } 489 break; 490 } 491 if (flags & F_DECODE_KEY) 492 free(key.data); 493 free(wantkey); 494 return (r); 495 } 496 497 int 498 db_put(char *keystr, char *valstr) 499 { 500 DBT key, val; 501 int r = 0; 502 503 db_makekey(&key, keystr, 1, (flags & F_DECODE_KEY ? 1 : 0)); 504 db_makekey(&val, valstr, 0, (flags & F_DECODE_VAL ? 1 : 0)); 505 switch (db->put(db, &key, &val, 506 (flags & F_REPLACE) ? 0 : R_NOOVERWRITE)) { 507 case -1: 508 warn("Error writing key `%s'", keystr); 509 r = 1; 510 break; 511 case 0: 512 if (! (flags & F_QUIET)) 513 printf("Added key `%s'\n", keystr); 514 break; 515 case 1: 516 if (! (flags & F_QUIET)) 517 warnx("Key `%s' already exists", keystr); 518 break; 519 } 520 if (flags & F_DECODE_KEY) 521 free(key.data); 522 if (flags & F_DECODE_VAL) 523 free(val.data); 524 return (r); 525 } 526 527 int 528 parseline(FILE *fp, const char *sep, char **kp, char **vp) 529 { 530 size_t len; 531 char *key, *val; 532 533 key = fgetln(fp, &len); 534 if (key == NULL) /* end of file, or error */ 535 return (0); 536 537 if (key[len-1] == '\n') /* check for \n at EOL */ 538 key[--len] = '\0'; 539 else 540 return (0); 541 542 *kp = key; 543 if (vp == NULL) /* don't split if don't want value */ 544 return (1); 545 if ((val = strstr(key, sep)) == NULL) 546 val = key + len; 547 else { 548 *val = '\0'; 549 val += strlen(sep); 550 } 551 *vp = val; 552 return (1); 553 } 554 555 int 556 encode_data(size_t len, char *data, char **edata) 557 { 558 static char *buf = NULL; 559 char *nbuf; 560 static size_t buflen = 0; 561 size_t elen; 562 563 elen = 1 + (len * 4); 564 if (elen > buflen) { 565 if ((nbuf = realloc(buf, elen)) == NULL) 566 err(1, "Cannot allocate encoding buffer"); 567 buf = nbuf; 568 buflen = elen; 569 } 570 *edata = buf; 571 if (extra_echars) { 572 return (strsvisx(buf, data, len, visflags, extra_echars)); 573 } else { 574 return (strvisx(buf, data, len, visflags)); 575 } 576 } 577 578 int 579 decode_data(char *data, char **ddata) 580 { 581 char *buf; 582 583 if ((buf = malloc(strlen(data) + 1)) == NULL) 584 err(1, "Cannot allocate decoding buffer"); 585 *ddata = buf; 586 return (strunvisx(buf, data, (visflags & VIS_HTTPSTYLE))); 587 } 588 589 void 590 parse_encode_decode_arg(const char *arg, int encode) 591 { 592 if (! arg[0] || arg[1]) 593 return; 594 if (arg[0] == 'k' || arg[0] == 'b') { 595 if (encode) 596 flags |= F_ENCODE_KEY; 597 else 598 flags |= F_DECODE_KEY; 599 } 600 if (arg[0] == 'v' || arg[0] == 'b') { 601 if (encode) 602 flags |= F_ENCODE_VAL; 603 else 604 flags |= F_DECODE_VAL; 605 } 606 return; 607 } 608 609 int 610 parse_encode_option(char **arg) 611 { 612 int r = 0; 613 int encmask = ~(VIS_CSTYLE | VIS_HTTPSTYLE | VIS_OCTAL); 614 615 for(; **arg; (*arg)++) { 616 switch (**arg) { 617 case 'b': 618 r |= VIS_NOSLASH; 619 break; 620 case 'c': 621 r &= encmask; 622 r |= VIS_CSTYLE; 623 break; 624 case 'h': 625 r &= encmask; 626 r |= VIS_HTTPSTYLE; 627 break; 628 case 'o': 629 r &= encmask; 630 r |= VIS_OCTAL; 631 break; 632 case 's': 633 r |= VIS_SAFE; 634 break; 635 case 't': 636 r |= VIS_TAB; 637 break; 638 case 'w': 639 r |= VIS_WHITE; 640 break; 641 default: 642 return (0); 643 break; 644 } 645 } 646 return (r); 647 } 648 649 void 650 usage(void) 651 { 652 const char *p = getprogname(); 653 654 fprintf(stderr, 655 "usage: %s [-KiNqV] [-E endian] [-f infile] [-O outsep] [-S visitem]\n" 656 " [-T visspec] [-X extravis] type dbfile [key [...]]\n" 657 " %s -d [-iNq] [-E endian] [-f infile] [-T visspec] [-U unvisitem]\n" 658 " type dbfile [key [...]]\n" 659 " %s -w [-CDiNqR] [-E endian] [-F isep] [-f infile] [-m mode]\n" 660 " [-T visspec] [-U unvisitem] type dbfile [key value [...]]\n" 661 ,p ,p ,p ); 662 fprintf(stderr, 663 "Supported modes:\n" 664 " read keys [default]\n" 665 " -d delete keys\n" 666 " -w write (add) keys/values\n" 667 "Supported options:\n" 668 " -C create empty (truncated) database\n" 669 " -D allow duplicates\n" 670 " -E endian database endian: `B'ig, `L'ittle, `H'ost [default: H]\n" 671 " -F isep input field separator string [default: ' ']\n" 672 " -f infile file of keys (read|delete) or keys/vals (write)\n" 673 " -i ignore case of key by converting to lower case\n" 674 " -K print key\n" 675 " -m mode mode of created database [default: 0644]\n" 676 " -N don't NUL terminate key\n" 677 " -O outsep output field separator string [default: '\t']\n" 678 " -q quiet operation (missing keys aren't errors)\n" 679 " -R replace existing keys\n" 680 " -S visitem items to strvis(3) encode: 'k'ey, 'v'alue, 'b'oth\n" 681 " -T visspec options to control -S and -U; like vis(1) options\n" 682 " -U unvisitem items to strunvis(3) decode: 'k'ey, 'v'alue, 'b'oth\n" 683 " -V print value\n" 684 " -X extravis extra characters to encode with -S\n" 685 ); 686 exit(1); 687 } 688
Indexes created Wed Sep 24 05:09:52 GMT 2025