1 /* 2 * Copyright (c) 1992 Eric P. Allman. 3 * Copyright (c) 1992, 1993 4 * The Regents of the University of California. All rights reserved. 5 * 6 * %sccs.include.redist.c% 7 */ 8 9 #ifndef lint 10 static char sccsid[] = "@(#)map.c 8.21 (Berkeley) 01/22/94"; 11 #endif /* not lint */ 12 13 #include "sendmail.h" 14 15 #ifdef NDBM 16 #include <ndbm.h> 17 #endif 18 #ifdef NEWDB 19 #include <db.h> 20 #endif 21 #ifdef NIS 22 #include <rpcsvc/ypclnt.h> 23 #endif 24 25 /* 26 ** MAP.C -- implementations for various map classes. 27 ** 28 ** Each map class implements a series of functions: 29 ** 30 ** bool map_parse(MAP *map, char *args) 31 ** Parse the arguments from the config file. Return TRUE 32 ** if they were ok, FALSE otherwise. Fill in map with the 33 ** values. 34 ** 35 ** char *map_lookup(MAP *map, char *key, char **args, int *pstat) 36 ** Look up the key in the given map. If found, do any 37 ** rewriting the map wants (including "args" if desired) 38 ** and return the value. Set *pstat to the appropriate status 39 ** on error and return NULL. Args will be NULL if called 40 ** from the alias routines, although this should probably 41 ** not be relied upon. It is suggested you call map_rewrite 42 ** to return the results -- it takes care of null termination 43 ** and uses a dynamically expanded buffer as needed. 44 ** 45 ** void map_store(MAP *map, char *key, char *value) 46 ** Store the key:value pair in the map. 47 ** 48 ** bool map_open(MAP *map, int mode) 49 ** Open the map for the indicated mode. Mode should 50 ** be either O_RDONLY or O_RDWR. Return TRUE if it 51 ** was opened successfully, FALSE otherwise. If the open 52 ** failed an the MF_OPTIONAL flag is not set, it should 53 ** also print an error. If the MF_ALIAS bit is set 54 ** and this map class understands the @:@ convention, it 55 ** should call aliaswait() before returning. 56 ** 57 ** void map_close(MAP *map) 58 ** Close the map. 59 */ 60 61 #define DBMMODE 0644 62 63 extern bool aliaswait __P((MAP *, char *, int)); 64 /* 65 ** MAP_PARSEARGS -- parse config line arguments for database lookup 66 ** 67 ** This is a generic version of the map_parse method. 68 ** 69 ** Parameters: 70 ** map -- the map being initialized. 71 ** ap -- a pointer to the args on the config line. 72 ** 73 ** Returns: 74 ** TRUE -- if everything parsed OK. 75 ** FALSE -- otherwise. 76 ** 77 ** Side Effects: 78 ** null terminates the filename; stores it in map 79 */ 80 81 bool 82 map_parseargs(map, ap) 83 MAP *map; 84 char *ap; 85 { 86 register char *p = ap; 87 88 map->map_mflags |= MF_TRY0NULL | MF_TRY1NULL; 89 for (;;) 90 { 91 while (isascii(*p) && isspace(*p)) 92 p++; 93 if (*p != '-') 94 break; 95 switch (*++p) 96 { 97 case 'N': 98 map->map_mflags |= MF_INCLNULL; 99 map->map_mflags &= ~MF_TRY0NULL; 100 break; 101 102 case 'O': 103 map->map_mflags &= ~MF_TRY1NULL; 104 break; 105 106 case 'o': 107 map->map_mflags |= MF_OPTIONAL; 108 break; 109 110 case 'f': 111 map->map_mflags |= MF_NOFOLDCASE; 112 break; 113 114 case 'm': 115 map->map_mflags |= MF_MATCHONLY; 116 break; 117 118 case 'a': 119 map->map_app = ++p; 120 break; 121 } 122 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 123 p++; 124 if (*p != '\0') 125 *p++ = '\0'; 126 } 127 if (map->map_app != NULL) 128 map->map_app = newstr(map->map_app); 129 130 if (*p != '\0') 131 { 132 map->map_file = p; 133 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 134 p++; 135 if (*p != '\0') 136 *p++ = '\0'; 137 map->map_file = newstr(map->map_file); 138 } 139 140 while (*p != '\0' && isascii(*p) && isspace(*p)) 141 p++; 142 if (*p != '\0') 143 map->map_rebuild = newstr(p); 144 145 if (map->map_file == NULL) 146 { 147 syserr("No file name for %s map %s", 148 map->map_class->map_cname, map->map_mname); 149 return FALSE; 150 } 151 return TRUE; 152 } 153 /* 154 ** MAP_REWRITE -- rewrite a database key, interpolating %n indications. 155 ** 156 ** It also adds the map_app string. It can be used as a utility 157 ** in the map_lookup method. 158 ** 159 ** Parameters: 160 ** map -- the map that causes this. 161 ** s -- the string to rewrite, NOT necessarily null terminated. 162 ** slen -- the length of s. 163 ** av -- arguments to interpolate into buf. 164 ** 165 ** Returns: 166 ** Pointer to rewritten result. 167 ** 168 ** Side Effects: 169 ** none. 170 */ 171 172 struct rwbuf 173 { 174 int rwb_len; /* size of buffer */ 175 char *rwb_buf; /* ptr to buffer */ 176 }; 177 178 struct rwbuf RwBufs[2]; /* buffers for rewriting output */ 179 180 char * 181 map_rewrite(map, s, slen, av) 182 register MAP *map; 183 register char *s; 184 int slen; 185 char **av; 186 { 187 register char *bp; 188 register char c; 189 char **avp; 190 register char *ap; 191 register struct rwbuf *rwb; 192 int i; 193 int len; 194 195 if (tTd(39, 1)) 196 { 197 printf("map_rewrite(%.*s), av =", slen, s); 198 if (av == NULL) 199 printf(" (nullv)"); 200 else 201 { 202 for (avp = av; *avp != NULL; avp++) 203 printf("\n\t%s", *avp); 204 } 205 printf("\n"); 206 } 207 208 rwb = RwBufs; 209 if (av == NULL) 210 rwb++; 211 212 /* count expected size of output (can safely overestimate) */ 213 i = len = slen; 214 if (av != NULL) 215 { 216 bp = s; 217 for (i = slen; --i >= 0 && (c = *bp++) != 0; ) 218 { 219 if (c != '%') 220 continue; 221 if (--i < 0) 222 break; 223 c = *bp++; 224 if (!(isascii(c) && isdigit(c))) 225 continue; 226 for (avp = av; --c >= '0' && *avp != NULL; avp++) 227 continue; 228 if (*avp == NULL) 229 continue; 230 len += strlen(*avp); 231 } 232 } 233 if (map->map_app != NULL) 234 len += strlen(map->map_app); 235 if (rwb->rwb_len < ++len) 236 { 237 /* need to malloc additional space */ 238 rwb->rwb_len = len; 239 if (rwb->rwb_buf != NULL) 240 free(rwb->rwb_buf); 241 rwb->rwb_buf = xalloc(rwb->rwb_len); 242 } 243 244 bp = rwb->rwb_buf; 245 if (av == NULL) 246 { 247 bcopy(s, bp, slen); 248 bp += slen; 249 } 250 else 251 { 252 while (--slen >= 0 && (c = *s++) != '\0') 253 { 254 if (c != '%') 255 { 256 pushc: 257 *bp++ = c; 258 continue; 259 } 260 if (--slen < 0 || (c = *s++) == '\0') 261 c = '%'; 262 if (c == '%') 263 goto pushc; 264 if (!(isascii(c) && isdigit(c))) 265 { 266 *bp++ = '%'; 267 goto pushc; 268 } 269 for (avp = av; --c >= '0' && *avp != NULL; avp++) 270 continue; 271 if (*avp == NULL) 272 continue; 273 274 /* transliterate argument into output string */ 275 for (ap = *avp; (c = *ap++) != '\0'; ) 276 *bp++ = c; 277 } 278 } 279 if (map->map_app != NULL) 280 strcpy(bp, map->map_app); 281 else 282 *bp = '\0'; 283 if (tTd(39, 1)) 284 printf("map_rewrite => %s\n", rwb->rwb_buf); 285 return rwb->rwb_buf; 286 } 287 /* 288 ** INITMAPS -- initialize for aliasing 289 ** 290 ** Parameters: 291 ** rebuild -- if TRUE, this rebuilds the cached versions. 292 ** e -- current envelope. 293 ** 294 ** Returns: 295 ** none. 296 ** 297 ** Side Effects: 298 ** initializes aliases: 299 ** if NDBM: opens the database. 300 ** if ~NDBM: reads the aliases into the symbol table. 301 */ 302 303 initmaps(rebuild, e) 304 bool rebuild; 305 register ENVELOPE *e; 306 { 307 extern void map_init(); 308 309 #ifdef XDEBUG 310 checkfd012("entering initmaps"); 311 #endif 312 CurEnv = e; 313 if (rebuild) 314 { 315 stabapply(map_init, 1); 316 stabapply(map_init, 2); 317 } 318 else 319 { 320 stabapply(map_init, 0); 321 } 322 #ifdef XDEBUG 323 checkfd012("exiting initmaps"); 324 #endif 325 } 326 327 void 328 map_init(s, rebuild) 329 register STAB *s; 330 int rebuild; 331 { 332 register MAP *map; 333 334 /* has to be a map */ 335 if (s->s_type != ST_MAP) 336 return; 337 338 map = &s->s_map; 339 if (!bitset(MF_VALID, map->map_mflags)) 340 return; 341 342 if (tTd(38, 2)) 343 printf("map_init(%s:%s, %d)\n", 344 map->map_class->map_cname == NULL ? "NULL" : 345 map->map_class->map_cname, 346 map->map_file == NULL ? "NULL" : map->map_file, 347 rebuild); 348 349 if (rebuild == (bitset(MF_ALIAS, map->map_mflags) && 350 bitset(MCF_REBUILDABLE, map->map_class->map_cflags) ? 1 : 2)) 351 { 352 if (tTd(38, 3)) 353 printf("\twrong pass\n"); 354 return; 355 } 356 357 /* if already open, close it (for nested open) */ 358 if (bitset(MF_OPEN, map->map_mflags)) 359 { 360 map->map_class->map_close(map); 361 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE); 362 } 363 364 if (rebuild == 2) 365 { 366 rebuildaliases(map, FALSE); 367 } 368 else 369 { 370 if (map->map_class->map_open(map, O_RDONLY)) 371 { 372 if (tTd(38, 4)) 373 printf("\t%s:%s: valid\n", 374 map->map_class->map_cname == NULL ? "NULL" : 375 map->map_class->map_cname, 376 map->map_file == NULL ? "NULL" : 377 map->map_file); 378 map->map_mflags |= MF_OPEN; 379 } 380 else if (tTd(38, 4)) 381 printf("\t%s:%s: invalid: %s\n", 382 map->map_class->map_cname == NULL ? "NULL" : 383 map->map_class->map_cname, 384 map->map_file == NULL ? "NULL" : 385 map->map_file, 386 errstring(errno)); 387 } 388 } 389 /* 390 ** NDBM modules 391 */ 392 393 #ifdef NDBM 394 395 /* 396 ** DBM_MAP_OPEN -- DBM-style map open 397 */ 398 399 bool 400 ndbm_map_open(map, mode) 401 MAP *map; 402 int mode; 403 { 404 register DBM *dbm; 405 struct stat st; 406 407 if (tTd(38, 2)) 408 printf("ndbm_map_open(%s, %d)\n", map->map_file, mode); 409 410 if (mode == O_RDWR) 411 mode |= O_CREAT|O_TRUNC; 412 413 /* open the database */ 414 dbm = dbm_open(map->map_file, mode, DBMMODE); 415 if (dbm == NULL) 416 { 417 #ifdef MAYBENEXTRELEASE 418 if (aliaswait(map, ".pag", FALSE)) 419 return TRUE; 420 #endif 421 if (!bitset(MF_OPTIONAL, map->map_mflags)) 422 syserr("Cannot open DBM database %s", map->map_file); 423 return FALSE; 424 } 425 map->map_db1 = (void *) dbm; 426 if (mode == O_RDONLY) 427 { 428 if (bitset(MF_ALIAS, map->map_mflags) && 429 !aliaswait(map, ".pag", TRUE)) 430 return FALSE; 431 } 432 else 433 { 434 int fd; 435 436 /* exclusive lock for duration of rebuild */ 437 fd = dbm_dirfno((DBM *) map->map_db1); 438 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags) && 439 lockfile(fd, map->map_file, ".dir", LOCK_EX)) 440 map->map_mflags |= MF_LOCKED; 441 } 442 if (fstat(dbm_dirfno((DBM *) map->map_db1), &st) >= 0) 443 map->map_mtime = st.st_mtime; 444 return TRUE; 445 } 446 447 448 /* 449 ** DBM_MAP_LOOKUP -- look up a datum in a DBM-type map 450 */ 451 452 char * 453 ndbm_map_lookup(map, name, av, statp) 454 MAP *map; 455 char *name; 456 char **av; 457 int *statp; 458 { 459 datum key, val; 460 int fd; 461 char keybuf[MAXNAME + 1]; 462 463 if (tTd(38, 20)) 464 printf("ndbm_map_lookup(%s)\n", name); 465 466 key.dptr = name; 467 key.dsize = strlen(name); 468 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 469 { 470 if (key.dsize > sizeof keybuf - 1) 471 key.dsize = sizeof keybuf - 1; 472 bcopy(key.dptr, keybuf, key.dsize + 1); 473 makelower(keybuf); 474 key.dptr = keybuf; 475 } 476 fd = dbm_dirfno((DBM *) map->map_db1); 477 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 478 (void) lockfile(fd, map->map_file, ".dir", LOCK_SH); 479 val.dptr = NULL; 480 if (bitset(MF_TRY0NULL, map->map_mflags)) 481 { 482 val = dbm_fetch((DBM *) map->map_db1, key); 483 if (val.dptr != NULL) 484 map->map_mflags &= ~MF_TRY1NULL; 485 } 486 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags)) 487 { 488 key.dsize++; 489 val = dbm_fetch((DBM *) map->map_db1, key); 490 if (val.dptr != NULL) 491 map->map_mflags &= ~MF_TRY0NULL; 492 } 493 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 494 (void) lockfile(fd, map->map_file, ".dir", LOCK_UN); 495 if (val.dptr == NULL) 496 return NULL; 497 if (bitset(MF_MATCHONLY, map->map_mflags)) 498 return map_rewrite(map, name, strlen(name), NULL); 499 else 500 return map_rewrite(map, val.dptr, val.dsize, av); 501 } 502 503 504 /* 505 ** DBM_MAP_STORE -- store a datum in the database 506 */ 507 508 void 509 ndbm_map_store(map, lhs, rhs) 510 register MAP *map; 511 char *lhs; 512 char *rhs; 513 { 514 datum key; 515 datum data; 516 int stat; 517 518 if (tTd(38, 12)) 519 printf("ndbm_map_store(%s, %s)\n", lhs, rhs); 520 521 key.dsize = strlen(lhs); 522 key.dptr = lhs; 523 524 data.dsize = strlen(rhs); 525 data.dptr = rhs; 526 527 if (bitset(MF_INCLNULL, map->map_mflags)) 528 { 529 key.dsize++; 530 data.dsize++; 531 } 532 533 stat = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT); 534 if (stat > 0) 535 { 536 usrerr("050 Warning: duplicate alias name %s", lhs); 537 stat = dbm_store((DBM *) map->map_db1, key, data, DBM_REPLACE); 538 } 539 if (stat != 0) 540 syserr("readaliases: dbm put (%s)", lhs); 541 } 542 543 544 /* 545 ** NDBM_MAP_CLOSE -- close the database 546 */ 547 548 void 549 ndbm_map_close(map) 550 register MAP *map; 551 { 552 if (bitset(MF_WRITABLE, map->map_mflags)) 553 { 554 #ifdef NIS 555 bool inclnull; 556 char buf[200]; 557 558 inclnull = bitset(MF_INCLNULL, map->map_mflags); 559 map->map_mflags &= ~MF_INCLNULL; 560 561 (void) sprintf(buf, "%010ld", curtime()); 562 ndbm_map_store(map, "YP_LAST_MODIFIED", buf); 563 564 (void) gethostname(buf, sizeof buf); 565 ndbm_map_store(map, "YP_MASTER_NAME", buf); 566 567 if (inclnull) 568 map->map_mflags |= MF_INCLNULL; 569 #endif 570 571 /* write out the distinguished alias */ 572 ndbm_map_store(map, "@", "@"); 573 } 574 dbm_close((DBM *) map->map_db1); 575 } 576 577 #endif 578 /* 579 ** NEWDB (Hash and BTree) Modules 580 */ 581 582 #ifdef NEWDB 583 584 /* 585 ** BT_MAP_OPEN, HASH_MAP_OPEN -- database open primitives. 586 ** 587 ** These do rather bizarre locking. If you can lock on open, 588 ** do that to avoid the condition of opening a database that 589 ** is being rebuilt. If you don't, we'll try to fake it, but 590 ** there will be a race condition. If opening for read-only, 591 ** we immediately release the lock to avoid freezing things up. 592 ** We really ought to hold the lock, but guarantee that we won't 593 ** be pokey about it. That's hard to do. 594 */ 595 596 bool 597 bt_map_open(map, mode) 598 MAP *map; 599 int mode; 600 { 601 DB *db; 602 int i; 603 int omode; 604 int fd; 605 struct stat st; 606 char buf[MAXNAME]; 607 608 if (tTd(38, 2)) 609 printf("bt_map_open(%s, %d)\n", map->map_file, mode); 610 611 omode = mode; 612 if (omode == O_RDWR) 613 { 614 omode |= O_CREAT|O_TRUNC; 615 #if defined(O_EXLOCK) && HASFLOCK 616 omode |= O_EXLOCK; 617 # if !defined(OLD_NEWDB) 618 } 619 else 620 { 621 omode |= O_SHLOCK; 622 # endif 623 #endif 624 } 625 626 (void) strcpy(buf, map->map_file); 627 i = strlen(buf); 628 if (i < 3 || strcmp(&buf[i - 3], ".db") != 0) 629 (void) strcat(buf, ".db"); 630 db = dbopen(buf, omode, DBMMODE, DB_BTREE, NULL); 631 if (db == NULL) 632 { 633 #ifdef MAYBENEXTRELEASE 634 if (aliaswait(map, ".db", FALSE)) 635 return TRUE; 636 #endif 637 if (!bitset(MF_OPTIONAL, map->map_mflags)) 638 syserr("Cannot open BTREE database %s", map->map_file); 639 return FALSE; 640 } 641 #if !defined(OLD_NEWDB) && HASFLOCK 642 fd = db->fd(db); 643 # if !defined(O_EXLOCK) 644 if (mode == O_RDWR && fd >= 0) 645 { 646 if (lockfile(fd, map->map_file, ".db", LOCK_EX)) 647 map->map_mflags |= MF_LOCKED; 648 } 649 # else 650 if (mode == O_RDONLY && fd >= 0) 651 (void) lockfile(fd, map->map_file, ".db", LOCK_UN); 652 else 653 map->map_mflags |= MF_LOCKED; 654 # endif 655 #endif 656 657 /* try to make sure that at least the database header is on disk */ 658 if (mode == O_RDWR) 659 #ifdef OLD_NEWDB 660 (void) db->sync(db); 661 #else 662 (void) db->sync(db, 0); 663 664 if (fd >= 0 && fstat(fd, &st) >= 0) 665 map->map_mtime = st.st_mtime; 666 #endif 667 668 map->map_db2 = (void *) db; 669 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags)) 670 if (!aliaswait(map, ".db", TRUE)) 671 return FALSE; 672 return TRUE; 673 } 674 675 676 /* 677 ** HASH_MAP_INIT -- HASH-style map initialization 678 */ 679 680 bool 681 hash_map_open(map, mode) 682 MAP *map; 683 int mode; 684 { 685 DB *db; 686 int i; 687 int omode; 688 int fd; 689 struct stat st; 690 char buf[MAXNAME]; 691 692 if (tTd(38, 2)) 693 printf("hash_map_open(%s, %d)\n", map->map_file, mode); 694 695 omode = mode; 696 if (omode == O_RDWR) 697 { 698 omode |= O_CREAT|O_TRUNC; 699 #if defined(O_EXLOCK) && HASFLOCK 700 omode |= O_EXLOCK; 701 # if !defined(OLD_NEWDB) 702 } 703 else 704 { 705 omode |= O_SHLOCK; 706 # endif 707 #endif 708 } 709 710 (void) strcpy(buf, map->map_file); 711 i = strlen(buf); 712 if (i < 3 || strcmp(&buf[i - 3], ".db") != 0) 713 (void) strcat(buf, ".db"); 714 db = dbopen(buf, omode, DBMMODE, DB_HASH, NULL); 715 if (db == NULL) 716 { 717 #ifdef MAYBENEXTRELEASE 718 if (aliaswait(map, ".db", FALSE)) 719 return TRUE; 720 #endif 721 if (!bitset(MF_OPTIONAL, map->map_mflags)) 722 syserr("Cannot open HASH database %s", map->map_file); 723 return FALSE; 724 } 725 #if !defined(OLD_NEWDB) && HASFLOCK 726 fd = db->fd(db); 727 # if !defined(O_EXLOCK) 728 if (mode == O_RDWR && fd >= 0) 729 { 730 if (lockfile(fd, map->map_file, ".db", LOCK_EX)) 731 map->map_mflags |= MF_LOCKED; 732 } 733 # else 734 if (mode == O_RDONLY && fd >= 0) 735 (void) lockfile(fd, map->map_file, ".db", LOCK_UN); 736 else 737 map->map_mflags |= MF_LOCKED; 738 # endif 739 #endif 740 741 /* try to make sure that at least the database header is on disk */ 742 if (mode == O_RDWR) 743 #ifdef OLD_NEWDB 744 (void) db->sync(db); 745 #else 746 (void) db->sync(db, 0); 747 748 if (fd >= 0 && fstat(fd, &st) >= 0) 749 map->map_mtime = st.st_mtime; 750 #endif 751 752 map->map_db2 = (void *) db; 753 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags)) 754 if (!aliaswait(map, ".db", TRUE)) 755 return FALSE; 756 return TRUE; 757 } 758 759 760 /* 761 ** DB_MAP_LOOKUP -- look up a datum in a BTREE- or HASH-type map 762 */ 763 764 char * 765 db_map_lookup(map, name, av, statp) 766 MAP *map; 767 char *name; 768 char **av; 769 int *statp; 770 { 771 DBT key, val; 772 register DB *db = (DB *) map->map_db2; 773 int st; 774 int saveerrno; 775 int fd; 776 char keybuf[MAXNAME + 1]; 777 778 if (tTd(38, 20)) 779 printf("db_map_lookup(%s)\n", name); 780 781 key.size = strlen(name); 782 if (key.size > sizeof keybuf - 1) 783 key.size = sizeof keybuf - 1; 784 key.data = keybuf; 785 bcopy(name, keybuf, key.size + 1); 786 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 787 makelower(keybuf); 788 #ifndef OLD_NEWDB 789 fd = db->fd(db); 790 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 791 (void) lockfile(db->fd(db), map->map_file, ".db", LOCK_SH); 792 #endif 793 st = 1; 794 if (bitset(MF_TRY0NULL, map->map_mflags)) 795 { 796 st = db->get(db, &key, &val, 0); 797 if (st == 0) 798 map->map_mflags &= ~MF_TRY1NULL; 799 } 800 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags)) 801 { 802 key.size++; 803 st = db->get(db, &key, &val, 0); 804 if (st == 0) 805 map->map_mflags &= ~MF_TRY0NULL; 806 } 807 saveerrno = errno; 808 #ifndef OLD_NEWDB 809 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 810 (void) lockfile(fd, map->map_file, ".db", LOCK_UN); 811 #endif 812 if (st != 0) 813 { 814 errno = saveerrno; 815 if (st < 0) 816 syserr("db_map_lookup: get (%s)", name); 817 return NULL; 818 } 819 if (bitset(MF_MATCHONLY, map->map_mflags)) 820 return map_rewrite(map, name, strlen(name), NULL); 821 else 822 return map_rewrite(map, val.data, val.size, av); 823 } 824 825 826 /* 827 ** DB_MAP_STORE -- store a datum in the NEWDB database 828 */ 829 830 void 831 db_map_store(map, lhs, rhs) 832 register MAP *map; 833 char *lhs; 834 char *rhs; 835 { 836 int stat; 837 DBT key; 838 DBT data; 839 register DB *db = map->map_db2; 840 841 if (tTd(38, 20)) 842 printf("db_map_store(%s, %s)\n", lhs, rhs); 843 844 key.size = strlen(lhs); 845 key.data = lhs; 846 847 data.size = strlen(rhs); 848 data.data = rhs; 849 850 if (bitset(MF_INCLNULL, map->map_mflags)) 851 { 852 key.size++; 853 data.size++; 854 } 855 856 stat = db->put(db, &key, &data, R_NOOVERWRITE); 857 if (stat > 0) 858 { 859 usrerr("050 Warning: duplicate alias name %s", lhs); 860 stat = db->put(db, &key, &data, 0); 861 } 862 if (stat != 0) 863 syserr("readaliases: db put (%s)", lhs); 864 } 865 866 867 /* 868 ** DB_MAP_CLOSE -- add distinguished entries and close the database 869 */ 870 871 void 872 db_map_close(map) 873 MAP *map; 874 { 875 register DB *db = map->map_db2; 876 877 if (tTd(38, 9)) 878 printf("db_map_close(%s, %x)\n", map->map_file, map->map_mflags); 879 880 if (bitset(MF_WRITABLE, map->map_mflags)) 881 { 882 /* write out the distinguished alias */ 883 db_map_store(map, "@", "@"); 884 } 885 886 if (db->close(db) != 0) 887 syserr("readaliases: db close failure"); 888 } 889 890 #endif 891 /* 892 ** NIS Modules 893 */ 894 895 # ifdef NIS 896 897 # ifndef YPERR_BUSY 898 # define YPERR_BUSY 16 899 # endif 900 901 /* 902 ** NIS_MAP_OPEN -- open DBM map 903 */ 904 905 bool 906 nis_map_open(map, mode) 907 MAP *map; 908 int mode; 909 { 910 int yperr; 911 register char *p; 912 auto char *vp; 913 auto int vsize; 914 char *master; 915 916 if (tTd(38, 2)) 917 printf("nis_map_open(%s)\n", map->map_file); 918 919 if (mode != O_RDONLY) 920 { 921 /* issue a pseudo-error message */ 922 #ifdef ENOSYS 923 errno = ENOSYS; 924 #else 925 # ifdef EFTYPE 926 errno = EFTYPE; 927 # else 928 errno = ENXIO; 929 # endif 930 #endif 931 return FALSE; 932 } 933 934 p = strchr(map->map_file, '@'); 935 if (p != NULL) 936 { 937 *p++ = '\0'; 938 if (*p != '\0') 939 map->map_domain = p; 940 } 941 942 if (map->map_domain == NULL) 943 yp_get_default_domain(&map->map_domain); 944 945 if (*map->map_file == '\0') 946 map->map_file = "mail.aliases"; 947 948 /* check to see if this map actually exists */ 949 yperr = yp_match(map->map_domain, map->map_file, "@", 1, 950 &vp, &vsize); 951 if (tTd(38, 10)) 952 printf("nis_map_open: yp_match(%s, %s) => %s\n", 953 map->map_domain, map->map_file, yperr_string(yperr)); 954 if (yperr == 0 || yperr == YPERR_KEY || yperr == YPERR_BUSY) 955 return TRUE; 956 957 if (!bitset(MF_OPTIONAL, map->map_mflags)) 958 syserr("Cannot bind to domain %s: %s", map->map_domain, 959 yperr_string(yperr)); 960 961 return FALSE; 962 } 963 964 965 /* 966 ** NIS_MAP_LOOKUP -- look up a datum in a NIS map 967 */ 968 969 char * 970 nis_map_lookup(map, name, av, statp) 971 MAP *map; 972 char *name; 973 char **av; 974 int *statp; 975 { 976 char *vp; 977 auto int vsize; 978 int buflen; 979 int yperr; 980 char keybuf[MAXNAME + 1]; 981 982 if (tTd(38, 20)) 983 printf("nis_map_lookup(%s)\n", name); 984 985 buflen = strlen(name); 986 if (buflen > sizeof keybuf - 1) 987 buflen = sizeof keybuf - 1; 988 bcopy(name, keybuf, buflen + 1); 989 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 990 makelower(keybuf); 991 yperr = YPERR_KEY; 992 if (bitset(MF_TRY0NULL, map->map_mflags)) 993 { 994 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen, 995 &vp, &vsize); 996 if (yperr == 0) 997 map->map_mflags &= ~MF_TRY1NULL; 998 } 999 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags)) 1000 { 1001 buflen++; 1002 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen, 1003 &vp, &vsize); 1004 if (yperr == 0) 1005 map->map_mflags &= ~MF_TRY0NULL; 1006 } 1007 if (yperr != 0) 1008 { 1009 if (yperr != YPERR_KEY && yperr != YPERR_BUSY) 1010 map->map_mflags &= ~(MF_VALID|MF_OPEN); 1011 return NULL; 1012 } 1013 if (bitset(MF_MATCHONLY, map->map_mflags)) 1014 return map_rewrite(map, name, strlen(name), NULL); 1015 else 1016 return map_rewrite(map, vp, vsize, av); 1017 } 1018 1019 1020 /* 1021 ** NIS_MAP_STORE 1022 */ 1023 1024 void 1025 nis_map_store(map, lhs, rhs) 1026 MAP *map; 1027 char *lhs; 1028 char *rhs; 1029 { 1030 /* nothing */ 1031 } 1032 1033 1034 /* 1035 ** NIS_MAP_CLOSE 1036 */ 1037 1038 void 1039 nis_map_close(map) 1040 MAP *map; 1041 { 1042 /* nothing */ 1043 } 1044 1045 #endif /* NIS */ 1046 /* 1047 ** STAB (Symbol Table) Modules 1048 */ 1049 1050 1051 /* 1052 ** STAB_MAP_LOOKUP -- look up alias in symbol table 1053 */ 1054 1055 char * 1056 stab_map_lookup(map, name, av, pstat) 1057 register MAP *map; 1058 char *name; 1059 char **av; 1060 int *pstat; 1061 { 1062 register STAB *s; 1063 1064 if (tTd(38, 20)) 1065 printf("stab_lookup(%s)\n", name); 1066 1067 s = stab(name, ST_ALIAS, ST_FIND); 1068 if (s != NULL) 1069 return (s->s_alias); 1070 return (NULL); 1071 } 1072 1073 1074 /* 1075 ** STAB_MAP_STORE -- store in symtab (actually using during init, not rebuild) 1076 */ 1077 1078 void 1079 stab_map_store(map, lhs, rhs) 1080 register MAP *map; 1081 char *lhs; 1082 char *rhs; 1083 { 1084 register STAB *s; 1085 1086 s = stab(lhs, ST_ALIAS, ST_ENTER); 1087 s->s_alias = newstr(rhs); 1088 } 1089 1090 1091 /* 1092 ** STAB_MAP_OPEN -- initialize (reads data file) 1093 ** 1094 ** This is a wierd case -- it is only intended as a fallback for 1095 ** aliases. For this reason, opens for write (only during a 1096 ** "newaliases") always fails, and opens for read open the 1097 ** actual underlying text file instead of the database. 1098 */ 1099 1100 bool 1101 stab_map_open(map, mode) 1102 register MAP *map; 1103 int mode; 1104 { 1105 FILE *af; 1106 struct stat st; 1107 1108 if (tTd(38, 2)) 1109 printf("stab_map_open(%s)\n", map->map_file); 1110 1111 if (mode != O_RDONLY) 1112 { 1113 errno = ENODEV; 1114 return FALSE; 1115 } 1116 1117 af = fopen(map->map_file, "r"); 1118 if (af == NULL) 1119 return FALSE; 1120 readaliases(map, af, TRUE); 1121 1122 if (fstat(fileno(af), &st) >= 0) 1123 map->map_mtime = st.st_mtime; 1124 fclose(af); 1125 1126 return TRUE; 1127 } 1128 1129 1130 /* 1131 ** STAB_MAP_CLOSE -- close symbol table. 1132 ** 1133 ** Since this is in memory, there is nothing to do. 1134 */ 1135 1136 void 1137 stab_map_close(map) 1138 MAP *map; 1139 { 1140 /* ignore it */ 1141 } 1142 /* 1143 ** Implicit Modules 1144 ** 1145 ** Tries several types. For back compatibility of aliases. 1146 */ 1147 1148 1149 /* 1150 ** IMPL_MAP_LOOKUP -- lookup in best open database 1151 */ 1152 1153 char * 1154 impl_map_lookup(map, name, av, pstat) 1155 MAP *map; 1156 char *name; 1157 char **av; 1158 int *pstat; 1159 { 1160 if (tTd(38, 20)) 1161 printf("impl_map_lookup(%s)\n", name); 1162 1163 #ifdef NEWDB 1164 if (bitset(MF_IMPL_HASH, map->map_mflags)) 1165 return db_map_lookup(map, name, av, pstat); 1166 #endif 1167 #ifdef NDBM 1168 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 1169 return ndbm_map_lookup(map, name, av, pstat); 1170 #endif 1171 return stab_map_lookup(map, name, av, pstat); 1172 } 1173 1174 /* 1175 ** IMPL_MAP_STORE -- store in open databases 1176 */ 1177 1178 void 1179 impl_map_store(map, lhs, rhs) 1180 MAP *map; 1181 char *lhs; 1182 char *rhs; 1183 { 1184 #ifdef NEWDB 1185 if (bitset(MF_IMPL_HASH, map->map_mflags)) 1186 db_map_store(map, lhs, rhs); 1187 #endif 1188 #ifdef NDBM 1189 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 1190 ndbm_map_store(map, lhs, rhs); 1191 #endif 1192 stab_map_store(map, lhs, rhs); 1193 } 1194 1195 /* 1196 ** IMPL_MAP_OPEN -- implicit database open 1197 */ 1198 1199 bool 1200 impl_map_open(map, mode) 1201 MAP *map; 1202 int mode; 1203 { 1204 struct stat stb; 1205 1206 if (tTd(38, 2)) 1207 printf("impl_map_open(%s, %d)\n", map->map_file, mode); 1208 1209 if (stat(map->map_file, &stb) < 0) 1210 { 1211 /* no alias file at all */ 1212 if (tTd(38, 3)) 1213 printf("no map file\n"); 1214 return FALSE; 1215 } 1216 1217 #ifdef NEWDB 1218 map->map_mflags |= MF_IMPL_HASH; 1219 if (hash_map_open(map, mode)) 1220 { 1221 #if defined(NDBM) && defined(NIS) 1222 if (mode == O_RDONLY || access("/var/yp/Makefile", R_OK) != 0) 1223 #endif 1224 return TRUE; 1225 } 1226 else 1227 map->map_mflags &= ~MF_IMPL_HASH; 1228 #endif 1229 #ifdef NDBM 1230 map->map_mflags |= MF_IMPL_NDBM; 1231 if (ndbm_map_open(map, mode)) 1232 { 1233 return TRUE; 1234 } 1235 else 1236 map->map_mflags &= ~MF_IMPL_NDBM; 1237 #endif 1238 1239 #if defined(NEWDB) || defined(NDBM) 1240 if (Verbose) 1241 message("WARNING: cannot open alias database %s", map->map_file); 1242 #else 1243 if (mode != O_RDONLY) 1244 usrerr("Cannot rebuild aliases: no database format defined"); 1245 #endif 1246 1247 return stab_map_open(map, mode); 1248 } 1249 1250 1251 /* 1252 ** IMPL_MAP_CLOSE -- close any open database(s) 1253 */ 1254 1255 void 1256 impl_map_close(map) 1257 MAP *map; 1258 { 1259 #ifdef NEWDB 1260 if (bitset(MF_IMPL_HASH, map->map_mflags)) 1261 { 1262 db_map_close(map); 1263 map->map_mflags &= ~MF_IMPL_HASH; 1264 } 1265 #endif 1266 1267 #ifdef NDBM 1268 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 1269 { 1270 ndbm_map_close(map); 1271 map->map_mflags &= ~MF_IMPL_NDBM; 1272 } 1273 #endif 1274 } 1275 /* 1276 ** NULL stubs 1277 */ 1278 1279 bool 1280 null_map_open(map, mode) 1281 MAP *map; 1282 int mode; 1283 { 1284 return TRUE; 1285 } 1286 1287 void 1288 null_map_close(map) 1289 MAP *map; 1290 { 1291 return; 1292 } 1293 1294 void 1295 null_map_store(map, key, val) 1296 MAP *map; 1297 char *key; 1298 char *val; 1299 { 1300 return; 1301 } 1302