1 /* 2 * Copyright (c) 1998-2005 Sendmail, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1992, 1995-1997 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1992, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #include <sendmail.h> 15 16 SM_RCSID("@(#)$Id: map.c,v 8.669 2005/02/09 01:46:35 ca Exp $") 17 18 #if LDAPMAP 19 # include <sm/ldap.h> 20 #endif /* LDAPMAP */ 21 22 #if NDBM 23 # include <ndbm.h> 24 # ifdef R_FIRST 25 ERROR README: You are running the Berkeley DB version of ndbm.h. See 26 ERROR README: the README file about tweaking Berkeley DB so it can 27 ERROR README: coexist with NDBM, or delete -DNDBM from the Makefile 28 ERROR README: and use -DNEWDB instead. 29 # endif /* R_FIRST */ 30 #endif /* NDBM */ 31 #if NEWDB 32 # include "sm/bdb.h" 33 #endif /* NEWDB */ 34 #if NIS 35 struct dom_binding; /* forward reference needed on IRIX */ 36 # include <rpcsvc/ypclnt.h> 37 # if NDBM 38 # define NDBM_YP_COMPAT /* create YP-compatible NDBM files */ 39 # endif /* NDBM */ 40 #endif /* NIS */ 41 42 #if NEWDB 43 # if DB_VERSION_MAJOR < 2 44 static bool db_map_open __P((MAP *, int, char *, DBTYPE, const void *)); 45 # endif /* DB_VERSION_MAJOR < 2 */ 46 # if DB_VERSION_MAJOR == 2 47 static bool db_map_open __P((MAP *, int, char *, DBTYPE, DB_INFO *)); 48 # endif /* DB_VERSION_MAJOR == 2 */ 49 # if DB_VERSION_MAJOR > 2 50 static bool db_map_open __P((MAP *, int, char *, DBTYPE, void **)); 51 # endif /* DB_VERSION_MAJOR > 2 */ 52 #endif /* NEWDB */ 53 static bool extract_canonname __P((char *, char *, char *, char[], int)); 54 static void map_close __P((STAB *, int)); 55 static void map_init __P((STAB *, int)); 56 #ifdef LDAPMAP 57 static STAB * ldapmap_findconn __P((SM_LDAP_STRUCT *)); 58 #endif /* LDAPMAP */ 59 #if NISPLUS 60 static bool nisplus_getcanonname __P((char *, int, int *)); 61 #endif /* NISPLUS */ 62 #if NIS 63 static bool nis_getcanonname __P((char *, int, int *)); 64 #endif /* NIS */ 65 #if NETINFO 66 static bool ni_getcanonname __P((char *, int, int *)); 67 #endif /* NETINFO */ 68 static bool text_getcanonname __P((char *, int, int *)); 69 #if SOCKETMAP 70 static STAB *socket_map_findconn __P((const char*)); 71 72 /* XXX arbitrary limit for sanity */ 73 # define SOCKETMAP_MAXL 1000000 74 #endif /* SOCKETMAP */ 75 76 /* default error message for trying to open a map in write mode */ 77 #ifdef ENOSYS 78 # define SM_EMAPCANTWRITE ENOSYS 79 #else /* ENOSYS */ 80 # ifdef EFTYPE 81 # define SM_EMAPCANTWRITE EFTYPE 82 # else /* EFTYPE */ 83 # define SM_EMAPCANTWRITE ENXIO 84 # endif /* EFTYPE */ 85 #endif /* ENOSYS */ 86 87 /* 88 ** MAP.C -- implementations for various map classes. 89 ** 90 ** Each map class implements a series of functions: 91 ** 92 ** bool map_parse(MAP *map, char *args) 93 ** Parse the arguments from the config file. Return true 94 ** if they were ok, false otherwise. Fill in map with the 95 ** values. 96 ** 97 ** char *map_lookup(MAP *map, char *key, char **args, int *pstat) 98 ** Look up the key in the given map. If found, do any 99 ** rewriting the map wants (including "args" if desired) 100 ** and return the value. Set *pstat to the appropriate status 101 ** on error and return NULL. Args will be NULL if called 102 ** from the alias routines, although this should probably 103 ** not be relied upon. It is suggested you call map_rewrite 104 ** to return the results -- it takes care of null termination 105 ** and uses a dynamically expanded buffer as needed. 106 ** 107 ** void map_store(MAP *map, char *key, char *value) 108 ** Store the key:value pair in the map. 109 ** 110 ** bool map_open(MAP *map, int mode) 111 ** Open the map for the indicated mode. Mode should 112 ** be either O_RDONLY or O_RDWR. Return true if it 113 ** was opened successfully, false otherwise. If the open 114 ** failed and the MF_OPTIONAL flag is not set, it should 115 ** also print an error. If the MF_ALIAS bit is set 116 ** and this map class understands the @:@ convention, it 117 ** should call aliaswait() before returning. 118 ** 119 ** void map_close(MAP *map) 120 ** Close the map. 121 ** 122 ** This file also includes the implementation for getcanonname. 123 ** It is currently implemented in a pretty ad-hoc manner; it ought 124 ** to be more properly integrated into the map structure. 125 */ 126 127 #if O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL 128 # define LOCK_ON_OPEN 1 /* we can open/create a locked file */ 129 #else /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */ 130 # define LOCK_ON_OPEN 0 /* no such luck -- bend over backwards */ 131 #endif /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */ 132 133 /* 134 ** MAP_PARSEARGS -- parse config line arguments for database lookup 135 ** 136 ** This is a generic version of the map_parse method. 137 ** 138 ** Parameters: 139 ** map -- the map being initialized. 140 ** ap -- a pointer to the args on the config line. 141 ** 142 ** Returns: 143 ** true -- if everything parsed OK. 144 ** false -- otherwise. 145 ** 146 ** Side Effects: 147 ** null terminates the filename; stores it in map 148 */ 149 150 bool 151 map_parseargs(map, ap) 152 MAP *map; 153 char *ap; 154 { 155 register char *p = ap; 156 157 /* 158 ** There is no check whether there is really an argument, 159 ** but that's not important enough to warrant extra code. 160 */ 161 162 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL; 163 map->map_spacesub = SpaceSub; /* default value */ 164 for (;;) 165 { 166 while (isascii(*p) && isspace(*p)) 167 p++; 168 if (*p != '-') 169 break; 170 switch (*++p) 171 { 172 case 'N': 173 map->map_mflags |= MF_INCLNULL; 174 map->map_mflags &= ~MF_TRY0NULL; 175 break; 176 177 case 'O': 178 map->map_mflags &= ~MF_TRY1NULL; 179 break; 180 181 case 'o': 182 map->map_mflags |= MF_OPTIONAL; 183 break; 184 185 case 'f': 186 map->map_mflags |= MF_NOFOLDCASE; 187 break; 188 189 case 'm': 190 map->map_mflags |= MF_MATCHONLY; 191 break; 192 193 case 'A': 194 map->map_mflags |= MF_APPEND; 195 break; 196 197 case 'q': 198 map->map_mflags |= MF_KEEPQUOTES; 199 break; 200 201 case 'a': 202 map->map_app = ++p; 203 break; 204 205 case 'T': 206 map->map_tapp = ++p; 207 break; 208 209 case 'k': 210 while (isascii(*++p) && isspace(*p)) 211 continue; 212 map->map_keycolnm = p; 213 break; 214 215 case 'v': 216 while (isascii(*++p) && isspace(*p)) 217 continue; 218 map->map_valcolnm = p; 219 break; 220 221 case 'z': 222 if (*++p != '\\') 223 map->map_coldelim = *p; 224 else 225 { 226 switch (*++p) 227 { 228 case 'n': 229 map->map_coldelim = '\n'; 230 break; 231 232 case 't': 233 map->map_coldelim = '\t'; 234 break; 235 236 default: 237 map->map_coldelim = '\\'; 238 } 239 } 240 break; 241 242 case 't': 243 map->map_mflags |= MF_NODEFER; 244 break; 245 246 247 case 'S': 248 map->map_spacesub = *++p; 249 break; 250 251 case 'D': 252 map->map_mflags |= MF_DEFER; 253 break; 254 255 default: 256 syserr("Illegal option %c map %s", *p, map->map_mname); 257 break; 258 } 259 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 260 p++; 261 if (*p != '\0') 262 *p++ = '\0'; 263 } 264 if (map->map_app != NULL) 265 map->map_app = newstr(map->map_app); 266 if (map->map_tapp != NULL) 267 map->map_tapp = newstr(map->map_tapp); 268 if (map->map_keycolnm != NULL) 269 map->map_keycolnm = newstr(map->map_keycolnm); 270 if (map->map_valcolnm != NULL) 271 map->map_valcolnm = newstr(map->map_valcolnm); 272 273 if (*p != '\0') 274 { 275 map->map_file = p; 276 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 277 p++; 278 if (*p != '\0') 279 *p++ = '\0'; 280 map->map_file = newstr(map->map_file); 281 } 282 283 while (*p != '\0' && isascii(*p) && isspace(*p)) 284 p++; 285 if (*p != '\0') 286 map->map_rebuild = newstr(p); 287 288 if (map->map_file == NULL && 289 !bitset(MCF_OPTFILE, map->map_class->map_cflags)) 290 { 291 syserr("No file name for %s map %s", 292 map->map_class->map_cname, map->map_mname); 293 return false; 294 } 295 return true; 296 } 297 /* 298 ** MAP_REWRITE -- rewrite a database key, interpolating %n indications. 299 ** 300 ** It also adds the map_app string. It can be used as a utility 301 ** in the map_lookup method. 302 ** 303 ** Parameters: 304 ** map -- the map that causes this. 305 ** s -- the string to rewrite, NOT necessarily null terminated. 306 ** slen -- the length of s. 307 ** av -- arguments to interpolate into buf. 308 ** 309 ** Returns: 310 ** Pointer to rewritten result. This is static data that 311 ** should be copied if it is to be saved! 312 */ 313 314 char * 315 map_rewrite(map, s, slen, av) 316 register MAP *map; 317 register const char *s; 318 size_t slen; 319 char **av; 320 { 321 register char *bp; 322 register char c; 323 char **avp; 324 register char *ap; 325 size_t l; 326 size_t len; 327 static size_t buflen = 0; 328 static char *buf = NULL; 329 330 if (tTd(39, 1)) 331 { 332 sm_dprintf("map_rewrite(%.*s), av =", (int) slen, s); 333 if (av == NULL) 334 sm_dprintf(" (nullv)"); 335 else 336 { 337 for (avp = av; *avp != NULL; avp++) 338 sm_dprintf("\n\t%s", *avp); 339 } 340 sm_dprintf("\n"); 341 } 342 343 /* count expected size of output (can safely overestimate) */ 344 l = len = slen; 345 if (av != NULL) 346 { 347 const char *sp = s; 348 349 while (l-- > 0 && (c = *sp++) != '\0') 350 { 351 if (c != '%') 352 continue; 353 if (l-- <= 0) 354 break; 355 c = *sp++; 356 if (!(isascii(c) && isdigit(c))) 357 continue; 358 for (avp = av; --c >= '0' && *avp != NULL; avp++) 359 continue; 360 if (*avp == NULL) 361 continue; 362 len += strlen(*avp); 363 } 364 } 365 if (map->map_app != NULL) 366 len += strlen(map->map_app); 367 if (buflen < ++len) 368 { 369 /* need to malloc additional space */ 370 buflen = len; 371 if (buf != NULL) 372 sm_free(buf); 373 buf = sm_pmalloc_x(buflen); 374 } 375 376 bp = buf; 377 if (av == NULL) 378 { 379 memmove(bp, s, slen); 380 bp += slen; 381 382 /* assert(len > slen); */ 383 len -= slen; 384 } 385 else 386 { 387 while (slen-- > 0 && (c = *s++) != '\0') 388 { 389 if (c != '%') 390 { 391 pushc: 392 if (len-- <= 1) 393 break; 394 *bp++ = c; 395 continue; 396 } 397 if (slen-- <= 0 || (c = *s++) == '\0') 398 c = '%'; 399 if (c == '%') 400 goto pushc; 401 if (!(isascii(c) && isdigit(c))) 402 { 403 if (len-- <= 1) 404 break; 405 *bp++ = '%'; 406 goto pushc; 407 } 408 for (avp = av; --c >= '0' && *avp != NULL; avp++) 409 continue; 410 if (*avp == NULL) 411 continue; 412 413 /* transliterate argument into output string */ 414 for (ap = *avp; (c = *ap++) != '\0' && len > 0; --len) 415 *bp++ = c; 416 } 417 } 418 if (map->map_app != NULL && len > 0) 419 (void) sm_strlcpy(bp, map->map_app, len); 420 else 421 *bp = '\0'; 422 if (tTd(39, 1)) 423 sm_dprintf("map_rewrite => %s\n", buf); 424 return buf; 425 } 426 /* 427 ** INITMAPS -- rebuild alias maps 428 ** 429 ** Parameters: 430 ** none. 431 ** 432 ** Returns: 433 ** none. 434 */ 435 436 void 437 initmaps() 438 { 439 #if XDEBUG 440 checkfd012("entering initmaps"); 441 #endif /* XDEBUG */ 442 stabapply(map_init, 0); 443 #if XDEBUG 444 checkfd012("exiting initmaps"); 445 #endif /* XDEBUG */ 446 } 447 /* 448 ** MAP_INIT -- rebuild a map 449 ** 450 ** Parameters: 451 ** s -- STAB entry: if map: try to rebuild 452 ** unused -- unused variable 453 ** 454 ** Returns: 455 ** none. 456 ** 457 ** Side Effects: 458 ** will close already open rebuildable map. 459 */ 460 461 /* ARGSUSED1 */ 462 static void 463 map_init(s, unused) 464 register STAB *s; 465 int unused; 466 { 467 register MAP *map; 468 469 /* has to be a map */ 470 if (s->s_symtype != ST_MAP) 471 return; 472 473 map = &s->s_map; 474 if (!bitset(MF_VALID, map->map_mflags)) 475 return; 476 477 if (tTd(38, 2)) 478 sm_dprintf("map_init(%s:%s, %s)\n", 479 map->map_class->map_cname == NULL ? "NULL" : 480 map->map_class->map_cname, 481 map->map_mname == NULL ? "NULL" : map->map_mname, 482 map->map_file == NULL ? "NULL" : map->map_file); 483 484 if (!bitset(MF_ALIAS, map->map_mflags) || 485 !bitset(MCF_REBUILDABLE, map->map_class->map_cflags)) 486 { 487 if (tTd(38, 3)) 488 sm_dprintf("\tnot rebuildable\n"); 489 return; 490 } 491 492 /* if already open, close it (for nested open) */ 493 if (bitset(MF_OPEN, map->map_mflags)) 494 { 495 map->map_mflags |= MF_CLOSING; 496 map->map_class->map_close(map); 497 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING); 498 } 499 500 (void) rebuildaliases(map, false); 501 return; 502 } 503 /* 504 ** OPENMAP -- open a map 505 ** 506 ** Parameters: 507 ** map -- map to open (it must not be open). 508 ** 509 ** Returns: 510 ** whether open succeeded. 511 */ 512 513 bool 514 openmap(map) 515 MAP *map; 516 { 517 bool restore = false; 518 bool savehold = HoldErrs; 519 bool savequick = QuickAbort; 520 int saveerrors = Errors; 521 522 if (!bitset(MF_VALID, map->map_mflags)) 523 return false; 524 525 /* better safe than sorry... */ 526 if (bitset(MF_OPEN, map->map_mflags)) 527 return true; 528 529 /* Don't send a map open error out via SMTP */ 530 if ((OnlyOneError || QuickAbort) && 531 (OpMode == MD_SMTP || OpMode == MD_DAEMON)) 532 { 533 restore = true; 534 HoldErrs = true; 535 QuickAbort = false; 536 } 537 538 errno = 0; 539 if (map->map_class->map_open(map, O_RDONLY)) 540 { 541 if (tTd(38, 4)) 542 sm_dprintf("openmap()\t%s:%s %s: valid\n", 543 map->map_class->map_cname == NULL ? "NULL" : 544 map->map_class->map_cname, 545 map->map_mname == NULL ? "NULL" : 546 map->map_mname, 547 map->map_file == NULL ? "NULL" : 548 map->map_file); 549 map->map_mflags |= MF_OPEN; 550 map->map_pid = CurrentPid; 551 } 552 else 553 { 554 if (tTd(38, 4)) 555 sm_dprintf("openmap()\t%s:%s %s: invalid%s%s\n", 556 map->map_class->map_cname == NULL ? "NULL" : 557 map->map_class->map_cname, 558 map->map_mname == NULL ? "NULL" : 559 map->map_mname, 560 map->map_file == NULL ? "NULL" : 561 map->map_file, 562 errno == 0 ? "" : ": ", 563 errno == 0 ? "" : sm_errstring(errno)); 564 if (!bitset(MF_OPTIONAL, map->map_mflags)) 565 { 566 extern MAPCLASS BogusMapClass; 567 568 map->map_orgclass = map->map_class; 569 map->map_class = &BogusMapClass; 570 map->map_mflags |= MF_OPEN|MF_OPENBOGUS; 571 map->map_pid = CurrentPid; 572 } 573 else 574 { 575 /* don't try again */ 576 map->map_mflags &= ~MF_VALID; 577 } 578 } 579 580 if (restore) 581 { 582 Errors = saveerrors; 583 HoldErrs = savehold; 584 QuickAbort = savequick; 585 } 586 587 return bitset(MF_OPEN, map->map_mflags); 588 } 589 /* 590 ** CLOSEMAPS -- close all open maps opened by the current pid. 591 ** 592 ** Parameters: 593 ** bogus -- only close bogus maps. 594 ** 595 ** Returns: 596 ** none. 597 */ 598 599 void 600 closemaps(bogus) 601 bool bogus; 602 { 603 stabapply(map_close, bogus); 604 } 605 /* 606 ** MAP_CLOSE -- close a map opened by the current pid. 607 ** 608 ** Parameters: 609 ** s -- STAB entry: if map: try to close 610 ** bogus -- only close bogus maps or MCF_NOTPERSIST maps. 611 ** 612 ** Returns: 613 ** none. 614 */ 615 616 /* ARGSUSED1 */ 617 static void 618 map_close(s, bogus) 619 register STAB *s; 620 int bogus; /* int because of stabapply(), used as bool */ 621 { 622 MAP *map; 623 extern MAPCLASS BogusMapClass; 624 625 if (s->s_symtype != ST_MAP) 626 return; 627 628 map = &s->s_map; 629 630 /* 631 ** close the map iff: 632 ** it is valid and open and opened by this process 633 ** and (!bogus or it's a bogus map or it is not persistent) 634 ** negate this: return iff 635 ** it is not valid or it is not open or not opened by this process 636 ** or (bogus and it's not a bogus map and it's not not-persistent) 637 */ 638 639 if (!bitset(MF_VALID, map->map_mflags) || 640 !bitset(MF_OPEN, map->map_mflags) || 641 bitset(MF_CLOSING, map->map_mflags) || 642 map->map_pid != CurrentPid || 643 (bogus && map->map_class != &BogusMapClass && 644 !bitset(MCF_NOTPERSIST, map->map_class->map_cflags))) 645 return; 646 647 if (map->map_class == &BogusMapClass && map->map_orgclass != NULL && 648 map->map_orgclass != &BogusMapClass) 649 map->map_class = map->map_orgclass; 650 if (tTd(38, 5)) 651 sm_dprintf("closemaps: closing %s (%s)\n", 652 map->map_mname == NULL ? "NULL" : map->map_mname, 653 map->map_file == NULL ? "NULL" : map->map_file); 654 655 if (!bitset(MF_OPENBOGUS, map->map_mflags)) 656 { 657 map->map_mflags |= MF_CLOSING; 658 map->map_class->map_close(map); 659 } 660 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_OPENBOGUS|MF_CLOSING); 661 } 662 /* 663 ** GETCANONNAME -- look up name using service switch 664 ** 665 ** Parameters: 666 ** host -- the host name to look up. 667 ** hbsize -- the size of the host buffer. 668 ** trymx -- if set, try MX records. 669 ** pttl -- pointer to return TTL (can be NULL). 670 ** 671 ** Returns: 672 ** true -- if the host was found. 673 ** false -- otherwise. 674 */ 675 676 bool 677 getcanonname(host, hbsize, trymx, pttl) 678 char *host; 679 int hbsize; 680 bool trymx; 681 int *pttl; 682 { 683 int nmaps; 684 int mapno; 685 bool found = false; 686 bool got_tempfail = false; 687 auto int status; 688 char *maptype[MAXMAPSTACK]; 689 short mapreturn[MAXMAPACTIONS]; 690 691 nmaps = switch_map_find("hosts", maptype, mapreturn); 692 if (pttl != 0) 693 *pttl = SM_DEFAULT_TTL; 694 for (mapno = 0; mapno < nmaps; mapno++) 695 { 696 int i; 697 698 if (tTd(38, 20)) 699 sm_dprintf("getcanonname(%s), trying %s\n", 700 host, maptype[mapno]); 701 if (strcmp("files", maptype[mapno]) == 0) 702 { 703 found = text_getcanonname(host, hbsize, &status); 704 } 705 #if NIS 706 else if (strcmp("nis", maptype[mapno]) == 0) 707 { 708 found = nis_getcanonname(host, hbsize, &status); 709 } 710 #endif /* NIS */ 711 #if NISPLUS 712 else if (strcmp("nisplus", maptype[mapno]) == 0) 713 { 714 found = nisplus_getcanonname(host, hbsize, &status); 715 } 716 #endif /* NISPLUS */ 717 #if NAMED_BIND 718 else if (strcmp("dns", maptype[mapno]) == 0) 719 { 720 found = dns_getcanonname(host, hbsize, trymx, &status, pttl); 721 } 722 #endif /* NAMED_BIND */ 723 #if NETINFO 724 else if (strcmp("netinfo", maptype[mapno]) == 0) 725 { 726 found = ni_getcanonname(host, hbsize, &status); 727 } 728 #endif /* NETINFO */ 729 else 730 { 731 found = false; 732 status = EX_UNAVAILABLE; 733 } 734 735 /* 736 ** Heuristic: if $m is not set, we are running during system 737 ** startup. In this case, when a name is apparently found 738 ** but has no dot, treat is as not found. This avoids 739 ** problems if /etc/hosts has no FQDN but is listed first 740 ** in the service switch. 741 */ 742 743 if (found && 744 (macvalue('m', CurEnv) != NULL || strchr(host, '.') != NULL)) 745 break; 746 747 /* see if we should continue */ 748 if (status == EX_TEMPFAIL) 749 { 750 i = MA_TRYAGAIN; 751 got_tempfail = true; 752 } 753 else if (status == EX_NOTFOUND) 754 i = MA_NOTFOUND; 755 else 756 i = MA_UNAVAIL; 757 if (bitset(1 << mapno, mapreturn[i])) 758 break; 759 } 760 761 if (found) 762 { 763 char *d; 764 765 if (tTd(38, 20)) 766 sm_dprintf("getcanonname(%s), found\n", host); 767 768 /* 769 ** If returned name is still single token, compensate 770 ** by tagging on $m. This is because some sites set 771 ** up their DNS or NIS databases wrong. 772 */ 773 774 if ((d = strchr(host, '.')) == NULL || d[1] == '\0') 775 { 776 d = macvalue('m', CurEnv); 777 if (d != NULL && 778 hbsize > (int) (strlen(host) + strlen(d) + 1)) 779 { 780 if (host[strlen(host) - 1] != '.') 781 (void) sm_strlcat2(host, ".", d, 782 hbsize); 783 else 784 (void) sm_strlcat(host, d, hbsize); 785 } 786 else 787 return false; 788 } 789 return true; 790 } 791 792 if (tTd(38, 20)) 793 sm_dprintf("getcanonname(%s), failed, status=%d\n", host, 794 status); 795 796 if (got_tempfail) 797 SM_SET_H_ERRNO(TRY_AGAIN); 798 else 799 SM_SET_H_ERRNO(HOST_NOT_FOUND); 800 801 return false; 802 } 803 /* 804 ** EXTRACT_CANONNAME -- extract canonical name from /etc/hosts entry 805 ** 806 ** Parameters: 807 ** name -- the name against which to match. 808 ** dot -- where to reinsert '.' to get FQDN 809 ** line -- the /etc/hosts line. 810 ** cbuf -- the location to store the result. 811 ** cbuflen -- the size of cbuf. 812 ** 813 ** Returns: 814 ** true -- if the line matched the desired name. 815 ** false -- otherwise. 816 */ 817 818 static bool 819 extract_canonname(name, dot, line, cbuf, cbuflen) 820 char *name; 821 char *dot; 822 char *line; 823 char cbuf[]; 824 int cbuflen; 825 { 826 int i; 827 char *p; 828 bool found = false; 829 830 cbuf[0] = '\0'; 831 if (line[0] == '#') 832 return false; 833 834 for (i = 1; ; i++) 835 { 836 char nbuf[MAXNAME + 1]; 837 838 p = get_column(line, i, '\0', nbuf, sizeof nbuf); 839 if (p == NULL) 840 break; 841 if (*p == '\0') 842 continue; 843 if (cbuf[0] == '\0' || 844 (strchr(cbuf, '.') == NULL && strchr(p, '.') != NULL)) 845 { 846 (void) sm_strlcpy(cbuf, p, cbuflen); 847 } 848 if (sm_strcasecmp(name, p) == 0) 849 found = true; 850 else if (dot != NULL) 851 { 852 /* try looking for the FQDN as well */ 853 *dot = '.'; 854 if (sm_strcasecmp(name, p) == 0) 855 found = true; 856 *dot = '\0'; 857 } 858 } 859 if (found && strchr(cbuf, '.') == NULL) 860 { 861 /* try to add a domain on the end of the name */ 862 char *domain = macvalue('m', CurEnv); 863 864 if (domain != NULL && 865 strlen(domain) + (i = strlen(cbuf)) + 1 < (size_t) cbuflen) 866 { 867 p = &cbuf[i]; 868 *p++ = '.'; 869 (void) sm_strlcpy(p, domain, cbuflen - i - 1); 870 } 871 } 872 return found; 873 } 874 875 /* 876 ** DNS modules 877 */ 878 879 #if NAMED_BIND 880 # if DNSMAP 881 882 # include "sm_resolve.h" 883 # if NETINET || NETINET6 884 # include <arpa/inet.h> 885 # endif /* NETINET || NETINET6 */ 886 887 /* 888 ** DNS_MAP_OPEN -- stub to check proper value for dns map type 889 */ 890 891 bool 892 dns_map_open(map, mode) 893 MAP *map; 894 int mode; 895 { 896 if (tTd(38,2)) 897 sm_dprintf("dns_map_open(%s, %d)\n", map->map_mname, mode); 898 899 mode &= O_ACCMODE; 900 if (mode != O_RDONLY) 901 { 902 /* issue a pseudo-error message */ 903 errno = SM_EMAPCANTWRITE; 904 return false; 905 } 906 return true; 907 } 908 909 /* 910 ** DNS_MAP_PARSEARGS -- parse dns map definition args. 911 ** 912 ** Parameters: 913 ** map -- pointer to MAP 914 ** args -- pointer to the args on the config line. 915 ** 916 ** Returns: 917 ** true -- if everything parsed OK. 918 ** false -- otherwise. 919 */ 920 921 # if _FFR_DNSMAP_MULTILIMIT 922 # if !_FFR_DNSMAP_MULTI 923 ERROR README: You must define _FFR_DNSMAP_MULTI to use _FFR_DNSMAP_MULTILIMIT 924 # endif /* ! _FFR_DNSMAP_MULTI */ 925 # endif /* _FFR_DNSMAP_MULTILIMIT */ 926 927 # if _FFR_DNSMAP_MULTI 928 # if _FFR_DNSMAP_MULTILIMIT 929 # define map_sizelimit map_lockfd /* overload field */ 930 # endif /* _FFR_DNSMAP_MULTILIMIT */ 931 # endif /* _FFR_DNSMAP_MULTI */ 932 933 struct dns_map 934 { 935 int dns_m_type; 936 }; 937 938 bool 939 dns_map_parseargs(map,args) 940 MAP *map; 941 char *args; 942 { 943 register char *p = args; 944 struct dns_map *map_p; 945 946 map_p = (struct dns_map *) xalloc(sizeof *map_p); 947 map_p->dns_m_type = -1; 948 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL; 949 950 for (;;) 951 { 952 while (isascii(*p) && isspace(*p)) 953 p++; 954 if (*p != '-') 955 break; 956 switch (*++p) 957 { 958 case 'N': 959 map->map_mflags |= MF_INCLNULL; 960 map->map_mflags &= ~MF_TRY0NULL; 961 break; 962 963 case 'O': 964 map->map_mflags &= ~MF_TRY1NULL; 965 break; 966 967 case 'o': 968 map->map_mflags |= MF_OPTIONAL; 969 break; 970 971 case 'f': 972 map->map_mflags |= MF_NOFOLDCASE; 973 break; 974 975 case 'm': 976 map->map_mflags |= MF_MATCHONLY; 977 break; 978 979 case 'A': 980 map->map_mflags |= MF_APPEND; 981 break; 982 983 case 'q': 984 map->map_mflags |= MF_KEEPQUOTES; 985 break; 986 987 case 't': 988 map->map_mflags |= MF_NODEFER; 989 break; 990 991 case 'a': 992 map->map_app = ++p; 993 break; 994 995 case 'T': 996 map->map_tapp = ++p; 997 break; 998 999 case 'd': 1000 { 1001 char *h; 1002 1003 ++p; 1004 h = strchr(p, ' '); 1005 if (h != NULL) 1006 *h = '\0'; 1007 map->map_timeout = convtime(p, 's'); 1008 if (h != NULL) 1009 *h = ' '; 1010 } 1011 break; 1012 1013 case 'r': 1014 while (isascii(*++p) && isspace(*p)) 1015 continue; 1016 map->map_retry = atoi(p); 1017 break; 1018 1019 # if _FFR_DNSMAP_MULTI 1020 case 'z': 1021 if (*++p != '\\') 1022 map->map_coldelim = *p; 1023 else 1024 { 1025 switch (*++p) 1026 { 1027 case 'n': 1028 map->map_coldelim = '\n'; 1029 break; 1030 1031 case 't': 1032 map->map_coldelim = '\t'; 1033 break; 1034 1035 default: 1036 map->map_coldelim = '\\'; 1037 } 1038 } 1039 break; 1040 1041 # if _FFR_DNSMAP_MULTILIMIT 1042 case 'Z': 1043 while (isascii(*++p) && isspace(*p)) 1044 continue; 1045 map->map_sizelimit = atoi(p); 1046 break; 1047 # endif /* _FFR_DNSMAP_MULTILIMIT */ 1048 # endif /* _FFR_DNSMAP_MULTI */ 1049 1050 /* Start of dns_map specific args */ 1051 case 'R': /* search field */ 1052 { 1053 char *h; 1054 1055 while (isascii(*++p) && isspace(*p)) 1056 continue; 1057 h = strchr(p, ' '); 1058 if (h != NULL) 1059 *h = '\0'; 1060 map_p->dns_m_type = dns_string_to_type(p); 1061 if (h != NULL) 1062 *h = ' '; 1063 if (map_p->dns_m_type < 0) 1064 syserr("dns map %s: wrong type %s", 1065 map->map_mname, p); 1066 } 1067 break; 1068 1069 # if _FFR_DNSMAP_BASE 1070 case 'B': /* base domain */ 1071 { 1072 char *h; 1073 1074 while (isascii(*++p) && isspace(*p)) 1075 continue; 1076 h = strchr(p, ' '); 1077 if (h != NULL) 1078 *h = '\0'; 1079 1080 /* 1081 ** slight abuse of map->map_file; it isn't 1082 ** used otherwise in this map type. 1083 */ 1084 1085 map->map_file = newstr(p); 1086 if (h != NULL) 1087 *h = ' '; 1088 } 1089 break; 1090 # endif /* _FFR_DNSMAP_BASE */ 1091 1092 } 1093 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 1094 p++; 1095 if (*p != '\0') 1096 *p++ = '\0'; 1097 } 1098 if (map_p->dns_m_type < 0) 1099 syserr("dns map %s: missing -R type", map->map_mname); 1100 if (map->map_app != NULL) 1101 map->map_app = newstr(map->map_app); 1102 if (map->map_tapp != NULL) 1103 map->map_tapp = newstr(map->map_tapp); 1104 1105 /* 1106 ** Assumption: assert(sizeof int <= sizeof(ARBPTR_T)); 1107 ** Even if this assumption is wrong, we use only one byte, 1108 ** so it doesn't really matter. 1109 */ 1110 1111 map->map_db1 = (ARBPTR_T) map_p; 1112 return true; 1113 } 1114 1115 /* 1116 ** DNS_MAP_LOOKUP -- perform dns map lookup. 1117 ** 1118 ** Parameters: 1119 ** map -- pointer to MAP 1120 ** name -- name to lookup 1121 ** av -- arguments to interpolate into buf. 1122 ** statp -- pointer to status (EX_) 1123 ** 1124 ** Returns: 1125 ** result of lookup if succeeded. 1126 ** NULL -- otherwise. 1127 */ 1128 1129 char * 1130 dns_map_lookup(map, name, av, statp) 1131 MAP *map; 1132 char *name; 1133 char **av; 1134 int *statp; 1135 { 1136 # if _FFR_DNSMAP_MULTI 1137 # if _FFR_DNSMAP_MULTILIMIT 1138 int resnum = 0; 1139 # endif /* _FFR_DNSMAP_MULTILIMIT */ 1140 # endif /* _FFR_DNSMAP_MULTI */ 1141 char *vp = NULL, *result = NULL; 1142 size_t vsize; 1143 struct dns_map *map_p; 1144 RESOURCE_RECORD_T *rr = NULL; 1145 DNS_REPLY_T *r = NULL; 1146 # if NETINET6 1147 static char buf6[INET6_ADDRSTRLEN]; 1148 # endif /* NETINET6 */ 1149 1150 if (tTd(38, 20)) 1151 sm_dprintf("dns_map_lookup(%s, %s)\n", 1152 map->map_mname, name); 1153 1154 map_p = (struct dns_map *)(map->map_db1); 1155 # if _FFR_DNSMAP_BASE 1156 if (map->map_file != NULL && *map->map_file != '\0') 1157 { 1158 size_t len; 1159 char *appdomain; 1160 1161 len = strlen(map->map_file) + strlen(name) + 2; 1162 appdomain = (char *) sm_malloc(len); 1163 if (appdomain == NULL) 1164 { 1165 *statp = EX_UNAVAILABLE; 1166 return NULL; 1167 } 1168 (void) sm_strlcpyn(appdomain, len, 3, name, ".", map->map_file); 1169 r = dns_lookup_int(appdomain, C_IN, map_p->dns_m_type, 1170 map->map_timeout, map->map_retry); 1171 sm_free(appdomain); 1172 } 1173 else 1174 # endif /* _FFR_DNSMAP_BASE */ 1175 { 1176 r = dns_lookup_int(name, C_IN, map_p->dns_m_type, 1177 map->map_timeout, map->map_retry); 1178 } 1179 1180 if (r == NULL) 1181 { 1182 result = NULL; 1183 if (h_errno == TRY_AGAIN || transienterror(errno)) 1184 *statp = EX_TEMPFAIL; 1185 else 1186 *statp = EX_NOTFOUND; 1187 goto cleanup; 1188 } 1189 *statp = EX_OK; 1190 for (rr = r->dns_r_head; rr != NULL; rr = rr->rr_next) 1191 { 1192 char *type = NULL; 1193 char *value = NULL; 1194 1195 switch (rr->rr_type) 1196 { 1197 case T_NS: 1198 type = "T_NS"; 1199 value = rr->rr_u.rr_txt; 1200 break; 1201 case T_CNAME: 1202 type = "T_CNAME"; 1203 value = rr->rr_u.rr_txt; 1204 break; 1205 case T_AFSDB: 1206 type = "T_AFSDB"; 1207 value = rr->rr_u.rr_mx->mx_r_domain; 1208 break; 1209 case T_SRV: 1210 type = "T_SRV"; 1211 value = rr->rr_u.rr_srv->srv_r_target; 1212 break; 1213 case T_PTR: 1214 type = "T_PTR"; 1215 value = rr->rr_u.rr_txt; 1216 break; 1217 case T_TXT: 1218 type = "T_TXT"; 1219 value = rr->rr_u.rr_txt; 1220 break; 1221 case T_MX: 1222 type = "T_MX"; 1223 value = rr->rr_u.rr_mx->mx_r_domain; 1224 break; 1225 # if NETINET 1226 case T_A: 1227 type = "T_A"; 1228 value = inet_ntoa(*(rr->rr_u.rr_a)); 1229 break; 1230 # endif /* NETINET */ 1231 # if NETINET6 1232 case T_AAAA: 1233 type = "T_AAAA"; 1234 value = anynet_ntop(rr->rr_u.rr_aaaa, buf6, 1235 sizeof buf6); 1236 break; 1237 # endif /* NETINET6 */ 1238 } 1239 1240 (void) strreplnonprt(value, 'X'); 1241 if (map_p->dns_m_type != rr->rr_type) 1242 { 1243 if (tTd(38, 40)) 1244 sm_dprintf("\tskipping type %s (%d) value %s\n", 1245 type != NULL ? type : "<UNKNOWN>", 1246 rr->rr_type, 1247 value != NULL ? value : "<NO VALUE>"); 1248 continue; 1249 } 1250 1251 # if NETINET6 1252 if (rr->rr_type == T_AAAA && value == NULL) 1253 { 1254 result = NULL; 1255 *statp = EX_DATAERR; 1256 if (tTd(38, 40)) 1257 sm_dprintf("\tbad T_AAAA conversion\n"); 1258 goto cleanup; 1259 } 1260 # endif /* NETINET6 */ 1261 if (tTd(38, 40)) 1262 sm_dprintf("\tfound type %s (%d) value %s\n", 1263 type != NULL ? type : "<UNKNOWN>", 1264 rr->rr_type, 1265 value != NULL ? value : "<NO VALUE>"); 1266 # if _FFR_DNSMAP_MULTI 1267 if (value != NULL && 1268 (map->map_coldelim == '\0' || 1269 # if _FFR_DNSMAP_MULTILIMIT 1270 map->map_sizelimit == 1 || 1271 # endif /* _FFR_DNSMAP_MULTILIMIT */ 1272 bitset(MF_MATCHONLY, map->map_mflags))) 1273 { 1274 /* Only care about the first match */ 1275 vp = newstr(value); 1276 break; 1277 } 1278 else if (vp == NULL) 1279 { 1280 /* First result */ 1281 vp = newstr(value); 1282 } 1283 else 1284 { 1285 /* concatenate the results */ 1286 int sz; 1287 char *new; 1288 1289 sz = strlen(vp) + strlen(value) + 2; 1290 new = xalloc(sz); 1291 (void) sm_snprintf(new, sz, "%s%c%s", 1292 vp, map->map_coldelim, value); 1293 sm_free(vp); 1294 vp = new; 1295 # if _FFR_DNSMAP_MULTILIMIT 1296 if (map->map_sizelimit > 0 && 1297 ++resnum >= map->map_sizelimit) 1298 break; 1299 # endif /* _FFR_DNSMAP_MULTILIMIT */ 1300 } 1301 # else /* _FFR_DNSMAP_MULTI */ 1302 vp = value; 1303 break; 1304 # endif /* _FFR_DNSMAP_MULTI */ 1305 } 1306 if (vp == NULL) 1307 { 1308 result = NULL; 1309 *statp = EX_NOTFOUND; 1310 if (tTd(38, 40)) 1311 sm_dprintf("\tno match found\n"); 1312 goto cleanup; 1313 } 1314 1315 # if _FFR_DNSMAP_MULTI 1316 /* Cleanly truncate for rulesets */ 1317 truncate_at_delim(vp, PSBUFSIZE / 2, map->map_coldelim); 1318 # endif /* _FFR_DNSMAP_MULTI */ 1319 1320 vsize = strlen(vp); 1321 1322 if (LogLevel > 9) 1323 sm_syslog(LOG_INFO, CurEnv->e_id, "dns %.100s => %s", 1324 name, vp); 1325 if (bitset(MF_MATCHONLY, map->map_mflags)) 1326 result = map_rewrite(map, name, strlen(name), NULL); 1327 else 1328 result = map_rewrite(map, vp, vsize, av); 1329 1330 cleanup: 1331 # if _FFR_DNSMAP_MULTI 1332 if (vp != NULL) 1333 sm_free(vp); 1334 # endif /* _FFR_DNSMAP_MULTI */ 1335 if (r != NULL) 1336 dns_free_data(r); 1337 return result; 1338 } 1339 # endif /* DNSMAP */ 1340 #endif /* NAMED_BIND */ 1341 1342 /* 1343 ** NDBM modules 1344 */ 1345 1346 #if NDBM 1347 1348 /* 1349 ** NDBM_MAP_OPEN -- DBM-style map open 1350 */ 1351 1352 bool 1353 ndbm_map_open(map, mode) 1354 MAP *map; 1355 int mode; 1356 { 1357 register DBM *dbm; 1358 int save_errno; 1359 int dfd; 1360 int pfd; 1361 long sff; 1362 int ret; 1363 int smode = S_IREAD; 1364 char dirfile[MAXPATHLEN]; 1365 char pagfile[MAXPATHLEN]; 1366 struct stat st; 1367 struct stat std, stp; 1368 1369 if (tTd(38, 2)) 1370 sm_dprintf("ndbm_map_open(%s, %s, %d)\n", 1371 map->map_mname, map->map_file, mode); 1372 map->map_lockfd = -1; 1373 mode &= O_ACCMODE; 1374 1375 /* do initial file and directory checks */ 1376 if (sm_strlcpyn(dirfile, sizeof dirfile, 2, 1377 map->map_file, ".dir") >= sizeof dirfile || 1378 sm_strlcpyn(pagfile, sizeof pagfile, 2, 1379 map->map_file, ".pag") >= sizeof pagfile) 1380 { 1381 errno = 0; 1382 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1383 syserr("dbm map \"%s\": map file %s name too long", 1384 map->map_mname, map->map_file); 1385 return false; 1386 } 1387 sff = SFF_ROOTOK|SFF_REGONLY; 1388 if (mode == O_RDWR) 1389 { 1390 sff |= SFF_CREAT; 1391 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail)) 1392 sff |= SFF_NOSLINK; 1393 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail)) 1394 sff |= SFF_NOHLINK; 1395 smode = S_IWRITE; 1396 } 1397 else 1398 { 1399 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail)) 1400 sff |= SFF_NOWLINK; 1401 } 1402 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail)) 1403 sff |= SFF_SAFEDIRPATH; 1404 ret = safefile(dirfile, RunAsUid, RunAsGid, RunAsUserName, 1405 sff, smode, &std); 1406 if (ret == 0) 1407 ret = safefile(pagfile, RunAsUid, RunAsGid, RunAsUserName, 1408 sff, smode, &stp); 1409 1410 if (ret != 0) 1411 { 1412 char *prob = "unsafe"; 1413 1414 /* cannot open this map */ 1415 if (ret == ENOENT) 1416 prob = "missing"; 1417 if (tTd(38, 2)) 1418 sm_dprintf("\t%s map file: %d\n", prob, ret); 1419 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1420 syserr("dbm map \"%s\": %s map file %s", 1421 map->map_mname, prob, map->map_file); 1422 return false; 1423 } 1424 if (std.st_mode == ST_MODE_NOFILE) 1425 mode |= O_CREAT|O_EXCL; 1426 1427 # if LOCK_ON_OPEN 1428 if (mode == O_RDONLY) 1429 mode |= O_SHLOCK; 1430 else 1431 mode |= O_TRUNC|O_EXLOCK; 1432 # else /* LOCK_ON_OPEN */ 1433 if ((mode & O_ACCMODE) == O_RDWR) 1434 { 1435 # if NOFTRUNCATE 1436 /* 1437 ** Warning: race condition. Try to lock the file as 1438 ** quickly as possible after opening it. 1439 ** This may also have security problems on some systems, 1440 ** but there isn't anything we can do about it. 1441 */ 1442 1443 mode |= O_TRUNC; 1444 # else /* NOFTRUNCATE */ 1445 /* 1446 ** This ugly code opens the map without truncating it, 1447 ** locks the file, then truncates it. Necessary to 1448 ** avoid race conditions. 1449 */ 1450 1451 int dirfd; 1452 int pagfd; 1453 long sff = SFF_CREAT|SFF_OPENASROOT; 1454 1455 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail)) 1456 sff |= SFF_NOSLINK; 1457 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail)) 1458 sff |= SFF_NOHLINK; 1459 1460 dirfd = safeopen(dirfile, mode, DBMMODE, sff); 1461 pagfd = safeopen(pagfile, mode, DBMMODE, sff); 1462 1463 if (dirfd < 0 || pagfd < 0) 1464 { 1465 save_errno = errno; 1466 if (dirfd >= 0) 1467 (void) close(dirfd); 1468 if (pagfd >= 0) 1469 (void) close(pagfd); 1470 errno = save_errno; 1471 syserr("ndbm_map_open: cannot create database %s", 1472 map->map_file); 1473 return false; 1474 } 1475 if (ftruncate(dirfd, (off_t) 0) < 0 || 1476 ftruncate(pagfd, (off_t) 0) < 0) 1477 { 1478 save_errno = errno; 1479 (void) close(dirfd); 1480 (void) close(pagfd); 1481 errno = save_errno; 1482 syserr("ndbm_map_open: cannot truncate %s.{dir,pag}", 1483 map->map_file); 1484 return false; 1485 } 1486 1487 /* if new file, get "before" bits for later filechanged check */ 1488 if (std.st_mode == ST_MODE_NOFILE && 1489 (fstat(dirfd, &std) < 0 || fstat(pagfd, &stp) < 0)) 1490 { 1491 save_errno = errno; 1492 (void) close(dirfd); 1493 (void) close(pagfd); 1494 errno = save_errno; 1495 syserr("ndbm_map_open(%s.{dir,pag}): cannot fstat pre-opened file", 1496 map->map_file); 1497 return false; 1498 } 1499 1500 /* have to save the lock for the duration (bletch) */ 1501 map->map_lockfd = dirfd; 1502 (void) close(pagfd); 1503 1504 /* twiddle bits for dbm_open */ 1505 mode &= ~(O_CREAT|O_EXCL); 1506 # endif /* NOFTRUNCATE */ 1507 } 1508 # endif /* LOCK_ON_OPEN */ 1509 1510 /* open the database */ 1511 dbm = dbm_open(map->map_file, mode, DBMMODE); 1512 if (dbm == NULL) 1513 { 1514 save_errno = errno; 1515 if (bitset(MF_ALIAS, map->map_mflags) && 1516 aliaswait(map, ".pag", false)) 1517 return true; 1518 # if !LOCK_ON_OPEN && !NOFTRUNCATE 1519 if (map->map_lockfd >= 0) 1520 (void) close(map->map_lockfd); 1521 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */ 1522 errno = save_errno; 1523 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1524 syserr("Cannot open DBM database %s", map->map_file); 1525 return false; 1526 } 1527 dfd = dbm_dirfno(dbm); 1528 pfd = dbm_pagfno(dbm); 1529 if (dfd == pfd) 1530 { 1531 /* heuristic: if files are linked, this is actually gdbm */ 1532 dbm_close(dbm); 1533 # if !LOCK_ON_OPEN && !NOFTRUNCATE 1534 if (map->map_lockfd >= 0) 1535 (void) close(map->map_lockfd); 1536 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */ 1537 errno = 0; 1538 syserr("dbm map \"%s\": cannot support GDBM", 1539 map->map_mname); 1540 return false; 1541 } 1542 1543 if (filechanged(dirfile, dfd, &std) || 1544 filechanged(pagfile, pfd, &stp)) 1545 { 1546 save_errno = errno; 1547 dbm_close(dbm); 1548 # if !LOCK_ON_OPEN && !NOFTRUNCATE 1549 if (map->map_lockfd >= 0) 1550 (void) close(map->map_lockfd); 1551 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */ 1552 errno = save_errno; 1553 syserr("ndbm_map_open(%s): file changed after open", 1554 map->map_file); 1555 return false; 1556 } 1557 1558 map->map_db1 = (ARBPTR_T) dbm; 1559 1560 /* 1561 ** Need to set map_mtime before the call to aliaswait() 1562 ** as aliaswait() will call map_lookup() which requires 1563 ** map_mtime to be set 1564 */ 1565 1566 if (fstat(pfd, &st) >= 0) 1567 map->map_mtime = st.st_mtime; 1568 1569 if (mode == O_RDONLY) 1570 { 1571 # if LOCK_ON_OPEN 1572 if (dfd >= 0) 1573 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN); 1574 if (pfd >= 0) 1575 (void) lockfile(pfd, map->map_file, ".pag", LOCK_UN); 1576 # endif /* LOCK_ON_OPEN */ 1577 if (bitset(MF_ALIAS, map->map_mflags) && 1578 !aliaswait(map, ".pag", true)) 1579 return false; 1580 } 1581 else 1582 { 1583 map->map_mflags |= MF_LOCKED; 1584 if (geteuid() == 0 && TrustedUid != 0) 1585 { 1586 # if HASFCHOWN 1587 if (fchown(dfd, TrustedUid, -1) < 0 || 1588 fchown(pfd, TrustedUid, -1) < 0) 1589 { 1590 int err = errno; 1591 1592 sm_syslog(LOG_ALERT, NOQID, 1593 "ownership change on %s failed: %s", 1594 map->map_file, sm_errstring(err)); 1595 message("050 ownership change on %s failed: %s", 1596 map->map_file, sm_errstring(err)); 1597 } 1598 # else /* HASFCHOWN */ 1599 sm_syslog(LOG_ALERT, NOQID, 1600 "no fchown(): cannot change ownership on %s", 1601 map->map_file); 1602 message("050 no fchown(): cannot change ownership on %s", 1603 map->map_file); 1604 # endif /* HASFCHOWN */ 1605 } 1606 } 1607 return true; 1608 } 1609 1610 1611 /* 1612 ** NDBM_MAP_LOOKUP -- look up a datum in a DBM-type map 1613 */ 1614 1615 char * 1616 ndbm_map_lookup(map, name, av, statp) 1617 MAP *map; 1618 char *name; 1619 char **av; 1620 int *statp; 1621 { 1622 datum key, val; 1623 int dfd, pfd; 1624 char keybuf[MAXNAME + 1]; 1625 struct stat stbuf; 1626 1627 if (tTd(38, 20)) 1628 sm_dprintf("ndbm_map_lookup(%s, %s)\n", 1629 map->map_mname, name); 1630 1631 key.dptr = name; 1632 key.dsize = strlen(name); 1633 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 1634 { 1635 if (key.dsize > sizeof keybuf - 1) 1636 key.dsize = sizeof keybuf - 1; 1637 memmove(keybuf, key.dptr, key.dsize); 1638 keybuf[key.dsize] = '\0'; 1639 makelower(keybuf); 1640 key.dptr = keybuf; 1641 } 1642 lockdbm: 1643 dfd = dbm_dirfno((DBM *) map->map_db1); 1644 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 1645 (void) lockfile(dfd, map->map_file, ".dir", LOCK_SH); 1646 pfd = dbm_pagfno((DBM *) map->map_db1); 1647 if (pfd < 0 || fstat(pfd, &stbuf) < 0 || 1648 stbuf.st_mtime > map->map_mtime) 1649 { 1650 /* Reopen the database to sync the cache */ 1651 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR 1652 : O_RDONLY; 1653 1654 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 1655 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN); 1656 map->map_mflags |= MF_CLOSING; 1657 map->map_class->map_close(map); 1658 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING); 1659 if (map->map_class->map_open(map, omode)) 1660 { 1661 map->map_mflags |= MF_OPEN; 1662 map->map_pid = CurrentPid; 1663 if ((omode && O_ACCMODE) == O_RDWR) 1664 map->map_mflags |= MF_WRITABLE; 1665 goto lockdbm; 1666 } 1667 else 1668 { 1669 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1670 { 1671 extern MAPCLASS BogusMapClass; 1672 1673 *statp = EX_TEMPFAIL; 1674 map->map_orgclass = map->map_class; 1675 map->map_class = &BogusMapClass; 1676 map->map_mflags |= MF_OPEN; 1677 map->map_pid = CurrentPid; 1678 syserr("Cannot reopen NDBM database %s", 1679 map->map_file); 1680 } 1681 return NULL; 1682 } 1683 } 1684 val.dptr = NULL; 1685 if (bitset(MF_TRY0NULL, map->map_mflags)) 1686 { 1687 val = dbm_fetch((DBM *) map->map_db1, key); 1688 if (val.dptr != NULL) 1689 map->map_mflags &= ~MF_TRY1NULL; 1690 } 1691 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags)) 1692 { 1693 key.dsize++; 1694 val = dbm_fetch((DBM *) map->map_db1, key); 1695 if (val.dptr != NULL) 1696 map->map_mflags &= ~MF_TRY0NULL; 1697 } 1698 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 1699 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN); 1700 if (val.dptr == NULL) 1701 return NULL; 1702 if (bitset(MF_MATCHONLY, map->map_mflags)) 1703 return map_rewrite(map, name, strlen(name), NULL); 1704 else 1705 return map_rewrite(map, val.dptr, val.dsize, av); 1706 } 1707 1708 1709 /* 1710 ** NDBM_MAP_STORE -- store a datum in the database 1711 */ 1712 1713 void 1714 ndbm_map_store(map, lhs, rhs) 1715 register MAP *map; 1716 char *lhs; 1717 char *rhs; 1718 { 1719 datum key; 1720 datum data; 1721 int status; 1722 char keybuf[MAXNAME + 1]; 1723 1724 if (tTd(38, 12)) 1725 sm_dprintf("ndbm_map_store(%s, %s, %s)\n", 1726 map->map_mname, lhs, rhs); 1727 1728 key.dsize = strlen(lhs); 1729 key.dptr = lhs; 1730 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 1731 { 1732 if (key.dsize > sizeof keybuf - 1) 1733 key.dsize = sizeof keybuf - 1; 1734 memmove(keybuf, key.dptr, key.dsize); 1735 keybuf[key.dsize] = '\0'; 1736 makelower(keybuf); 1737 key.dptr = keybuf; 1738 } 1739 1740 data.dsize = strlen(rhs); 1741 data.dptr = rhs; 1742 1743 if (bitset(MF_INCLNULL, map->map_mflags)) 1744 { 1745 key.dsize++; 1746 data.dsize++; 1747 } 1748 1749 status = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT); 1750 if (status > 0) 1751 { 1752 if (!bitset(MF_APPEND, map->map_mflags)) 1753 message("050 Warning: duplicate alias name %s", lhs); 1754 else 1755 { 1756 static char *buf = NULL; 1757 static int bufsiz = 0; 1758 auto int xstat; 1759 datum old; 1760 1761 old.dptr = ndbm_map_lookup(map, key.dptr, 1762 (char **) NULL, &xstat); 1763 if (old.dptr != NULL && *(char *) old.dptr != '\0') 1764 { 1765 old.dsize = strlen(old.dptr); 1766 if (data.dsize + old.dsize + 2 > bufsiz) 1767 { 1768 if (buf != NULL) 1769 (void) sm_free(buf); 1770 bufsiz = data.dsize + old.dsize + 2; 1771 buf = sm_pmalloc_x(bufsiz); 1772 } 1773 (void) sm_strlcpyn(buf, bufsiz, 3, 1774 data.dptr, ",", old.dptr); 1775 data.dsize = data.dsize + old.dsize + 1; 1776 data.dptr = buf; 1777 if (tTd(38, 9)) 1778 sm_dprintf("ndbm_map_store append=%s\n", 1779 data.dptr); 1780 } 1781 } 1782 status = dbm_store((DBM *) map->map_db1, 1783 key, data, DBM_REPLACE); 1784 } 1785 if (status != 0) 1786 syserr("readaliases: dbm put (%s): %d", lhs, status); 1787 } 1788 1789 1790 /* 1791 ** NDBM_MAP_CLOSE -- close the database 1792 */ 1793 1794 void 1795 ndbm_map_close(map) 1796 register MAP *map; 1797 { 1798 if (tTd(38, 9)) 1799 sm_dprintf("ndbm_map_close(%s, %s, %lx)\n", 1800 map->map_mname, map->map_file, map->map_mflags); 1801 1802 if (bitset(MF_WRITABLE, map->map_mflags)) 1803 { 1804 # ifdef NDBM_YP_COMPAT 1805 bool inclnull; 1806 char buf[MAXHOSTNAMELEN]; 1807 1808 inclnull = bitset(MF_INCLNULL, map->map_mflags); 1809 map->map_mflags &= ~MF_INCLNULL; 1810 1811 if (strstr(map->map_file, "/yp/") != NULL) 1812 { 1813 long save_mflags = map->map_mflags; 1814 1815 map->map_mflags |= MF_NOFOLDCASE; 1816 1817 (void) sm_snprintf(buf, sizeof buf, "%010ld", curtime()); 1818 ndbm_map_store(map, "YP_LAST_MODIFIED", buf); 1819 1820 (void) gethostname(buf, sizeof buf); 1821 ndbm_map_store(map, "YP_MASTER_NAME", buf); 1822 1823 map->map_mflags = save_mflags; 1824 } 1825 1826 if (inclnull) 1827 map->map_mflags |= MF_INCLNULL; 1828 # endif /* NDBM_YP_COMPAT */ 1829 1830 /* write out the distinguished alias */ 1831 ndbm_map_store(map, "@", "@"); 1832 } 1833 dbm_close((DBM *) map->map_db1); 1834 1835 /* release lock (if needed) */ 1836 # if !LOCK_ON_OPEN 1837 if (map->map_lockfd >= 0) 1838 (void) close(map->map_lockfd); 1839 # endif /* !LOCK_ON_OPEN */ 1840 } 1841 1842 #endif /* NDBM */ 1843 /* 1844 ** NEWDB (Hash and BTree) Modules 1845 */ 1846 1847 #if NEWDB 1848 1849 /* 1850 ** BT_MAP_OPEN, HASH_MAP_OPEN -- database open primitives. 1851 ** 1852 ** These do rather bizarre locking. If you can lock on open, 1853 ** do that to avoid the condition of opening a database that 1854 ** is being rebuilt. If you don't, we'll try to fake it, but 1855 ** there will be a race condition. If opening for read-only, 1856 ** we immediately release the lock to avoid freezing things up. 1857 ** We really ought to hold the lock, but guarantee that we won't 1858 ** be pokey about it. That's hard to do. 1859 */ 1860 1861 /* these should be K line arguments */ 1862 # if DB_VERSION_MAJOR < 2 1863 # define db_cachesize cachesize 1864 # define h_nelem nelem 1865 # ifndef DB_CACHE_SIZE 1866 # define DB_CACHE_SIZE (1024 * 1024) /* database memory cache size */ 1867 # endif /* ! DB_CACHE_SIZE */ 1868 # ifndef DB_HASH_NELEM 1869 # define DB_HASH_NELEM 4096 /* (starting) size of hash table */ 1870 # endif /* ! DB_HASH_NELEM */ 1871 # endif /* DB_VERSION_MAJOR < 2 */ 1872 1873 bool 1874 bt_map_open(map, mode) 1875 MAP *map; 1876 int mode; 1877 { 1878 # if DB_VERSION_MAJOR < 2 1879 BTREEINFO btinfo; 1880 # endif /* DB_VERSION_MAJOR < 2 */ 1881 # if DB_VERSION_MAJOR == 2 1882 DB_INFO btinfo; 1883 # endif /* DB_VERSION_MAJOR == 2 */ 1884 # if DB_VERSION_MAJOR > 2 1885 void *btinfo = NULL; 1886 # endif /* DB_VERSION_MAJOR > 2 */ 1887 1888 if (tTd(38, 2)) 1889 sm_dprintf("bt_map_open(%s, %s, %d)\n", 1890 map->map_mname, map->map_file, mode); 1891 1892 # if DB_VERSION_MAJOR < 3 1893 memset(&btinfo, '\0', sizeof btinfo); 1894 # ifdef DB_CACHE_SIZE 1895 btinfo.db_cachesize = DB_CACHE_SIZE; 1896 # endif /* DB_CACHE_SIZE */ 1897 # endif /* DB_VERSION_MAJOR < 3 */ 1898 1899 return db_map_open(map, mode, "btree", DB_BTREE, &btinfo); 1900 } 1901 1902 bool 1903 hash_map_open(map, mode) 1904 MAP *map; 1905 int mode; 1906 { 1907 # if DB_VERSION_MAJOR < 2 1908 HASHINFO hinfo; 1909 # endif /* DB_VERSION_MAJOR < 2 */ 1910 # if DB_VERSION_MAJOR == 2 1911 DB_INFO hinfo; 1912 # endif /* DB_VERSION_MAJOR == 2 */ 1913 # if DB_VERSION_MAJOR > 2 1914 void *hinfo = NULL; 1915 # endif /* DB_VERSION_MAJOR > 2 */ 1916 1917 if (tTd(38, 2)) 1918 sm_dprintf("hash_map_open(%s, %s, %d)\n", 1919 map->map_mname, map->map_file, mode); 1920 1921 # if DB_VERSION_MAJOR < 3 1922 memset(&hinfo, '\0', sizeof hinfo); 1923 # ifdef DB_HASH_NELEM 1924 hinfo.h_nelem = DB_HASH_NELEM; 1925 # endif /* DB_HASH_NELEM */ 1926 # ifdef DB_CACHE_SIZE 1927 hinfo.db_cachesize = DB_CACHE_SIZE; 1928 # endif /* DB_CACHE_SIZE */ 1929 # endif /* DB_VERSION_MAJOR < 3 */ 1930 1931 return db_map_open(map, mode, "hash", DB_HASH, &hinfo); 1932 } 1933 1934 static bool 1935 db_map_open(map, mode, mapclassname, dbtype, openinfo) 1936 MAP *map; 1937 int mode; 1938 char *mapclassname; 1939 DBTYPE dbtype; 1940 # if DB_VERSION_MAJOR < 2 1941 const void *openinfo; 1942 # endif /* DB_VERSION_MAJOR < 2 */ 1943 # if DB_VERSION_MAJOR == 2 1944 DB_INFO *openinfo; 1945 # endif /* DB_VERSION_MAJOR == 2 */ 1946 # if DB_VERSION_MAJOR > 2 1947 void **openinfo; 1948 # endif /* DB_VERSION_MAJOR > 2 */ 1949 { 1950 DB *db = NULL; 1951 int i; 1952 int omode; 1953 int smode = S_IREAD; 1954 int fd; 1955 long sff; 1956 int save_errno; 1957 struct stat st; 1958 char buf[MAXPATHLEN]; 1959 1960 /* do initial file and directory checks */ 1961 if (sm_strlcpy(buf, map->map_file, sizeof buf) >= sizeof buf) 1962 { 1963 errno = 0; 1964 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1965 syserr("map \"%s\": map file %s name too long", 1966 map->map_mname, map->map_file); 1967 return false; 1968 } 1969 i = strlen(buf); 1970 if (i < 3 || strcmp(&buf[i - 3], ".db") != 0) 1971 { 1972 if (sm_strlcat(buf, ".db", sizeof buf) >= sizeof buf) 1973 { 1974 errno = 0; 1975 if (!bitset(MF_OPTIONAL, map->map_mflags)) 1976 syserr("map \"%s\": map file %s name too long", 1977 map->map_mname, map->map_file); 1978 return false; 1979 } 1980 } 1981 1982 mode &= O_ACCMODE; 1983 omode = mode; 1984 1985 sff = SFF_ROOTOK|SFF_REGONLY; 1986 if (mode == O_RDWR) 1987 { 1988 sff |= SFF_CREAT; 1989 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail)) 1990 sff |= SFF_NOSLINK; 1991 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail)) 1992 sff |= SFF_NOHLINK; 1993 smode = S_IWRITE; 1994 } 1995 else 1996 { 1997 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail)) 1998 sff |= SFF_NOWLINK; 1999 } 2000 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail)) 2001 sff |= SFF_SAFEDIRPATH; 2002 i = safefile(buf, RunAsUid, RunAsGid, RunAsUserName, sff, smode, &st); 2003 2004 if (i != 0) 2005 { 2006 char *prob = "unsafe"; 2007 2008 /* cannot open this map */ 2009 if (i == ENOENT) 2010 prob = "missing"; 2011 if (tTd(38, 2)) 2012 sm_dprintf("\t%s map file: %s\n", prob, sm_errstring(i)); 2013 errno = i; 2014 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2015 syserr("%s map \"%s\": %s map file %s", 2016 mapclassname, map->map_mname, prob, buf); 2017 return false; 2018 } 2019 if (st.st_mode == ST_MODE_NOFILE) 2020 omode |= O_CREAT|O_EXCL; 2021 2022 map->map_lockfd = -1; 2023 2024 # if LOCK_ON_OPEN 2025 if (mode == O_RDWR) 2026 omode |= O_TRUNC|O_EXLOCK; 2027 else 2028 omode |= O_SHLOCK; 2029 # else /* LOCK_ON_OPEN */ 2030 /* 2031 ** Pre-lock the file to avoid race conditions. In particular, 2032 ** since dbopen returns NULL if the file is zero length, we 2033 ** must have a locked instance around the dbopen. 2034 */ 2035 2036 fd = open(buf, omode, DBMMODE); 2037 if (fd < 0) 2038 { 2039 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2040 syserr("db_map_open: cannot pre-open database %s", buf); 2041 return false; 2042 } 2043 2044 /* make sure no baddies slipped in just before the open... */ 2045 if (filechanged(buf, fd, &st)) 2046 { 2047 save_errno = errno; 2048 (void) close(fd); 2049 errno = save_errno; 2050 syserr("db_map_open(%s): file changed after pre-open", buf); 2051 return false; 2052 } 2053 2054 /* if new file, get the "before" bits for later filechanged check */ 2055 if (st.st_mode == ST_MODE_NOFILE && fstat(fd, &st) < 0) 2056 { 2057 save_errno = errno; 2058 (void) close(fd); 2059 errno = save_errno; 2060 syserr("db_map_open(%s): cannot fstat pre-opened file", 2061 buf); 2062 return false; 2063 } 2064 2065 /* actually lock the pre-opened file */ 2066 if (!lockfile(fd, buf, NULL, mode == O_RDONLY ? LOCK_SH : LOCK_EX)) 2067 syserr("db_map_open: cannot lock %s", buf); 2068 2069 /* set up mode bits for dbopen */ 2070 if (mode == O_RDWR) 2071 omode |= O_TRUNC; 2072 omode &= ~(O_EXCL|O_CREAT); 2073 # endif /* LOCK_ON_OPEN */ 2074 2075 # if DB_VERSION_MAJOR < 2 2076 db = dbopen(buf, omode, DBMMODE, dbtype, openinfo); 2077 # else /* DB_VERSION_MAJOR < 2 */ 2078 { 2079 int flags = 0; 2080 # if DB_VERSION_MAJOR > 2 2081 int ret; 2082 # endif /* DB_VERSION_MAJOR > 2 */ 2083 2084 if (mode == O_RDONLY) 2085 flags |= DB_RDONLY; 2086 if (bitset(O_CREAT, omode)) 2087 flags |= DB_CREATE; 2088 if (bitset(O_TRUNC, omode)) 2089 flags |= DB_TRUNCATE; 2090 SM_DB_FLAG_ADD(flags); 2091 2092 # if DB_VERSION_MAJOR > 2 2093 ret = db_create(&db, NULL, 0); 2094 # ifdef DB_CACHE_SIZE 2095 if (ret == 0 && db != NULL) 2096 { 2097 ret = db->set_cachesize(db, 0, DB_CACHE_SIZE, 0); 2098 if (ret != 0) 2099 { 2100 (void) db->close(db, 0); 2101 db = NULL; 2102 } 2103 } 2104 # endif /* DB_CACHE_SIZE */ 2105 # ifdef DB_HASH_NELEM 2106 if (dbtype == DB_HASH && ret == 0 && db != NULL) 2107 { 2108 ret = db->set_h_nelem(db, DB_HASH_NELEM); 2109 if (ret != 0) 2110 { 2111 (void) db->close(db, 0); 2112 db = NULL; 2113 } 2114 } 2115 # endif /* DB_HASH_NELEM */ 2116 if (ret == 0 && db != NULL) 2117 { 2118 ret = db->open(db, 2119 DBTXN /* transaction for DB 4.1 */ 2120 buf, NULL, dbtype, flags, DBMMODE); 2121 if (ret != 0) 2122 { 2123 #ifdef DB_OLD_VERSION 2124 if (ret == DB_OLD_VERSION) 2125 ret = EINVAL; 2126 #endif /* DB_OLD_VERSION */ 2127 (void) db->close(db, 0); 2128 db = NULL; 2129 } 2130 } 2131 errno = ret; 2132 # else /* DB_VERSION_MAJOR > 2 */ 2133 errno = db_open(buf, dbtype, flags, DBMMODE, 2134 NULL, openinfo, &db); 2135 # endif /* DB_VERSION_MAJOR > 2 */ 2136 } 2137 # endif /* DB_VERSION_MAJOR < 2 */ 2138 save_errno = errno; 2139 2140 # if !LOCK_ON_OPEN 2141 if (mode == O_RDWR) 2142 map->map_lockfd = fd; 2143 else 2144 (void) close(fd); 2145 # endif /* !LOCK_ON_OPEN */ 2146 2147 if (db == NULL) 2148 { 2149 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) && 2150 aliaswait(map, ".db", false)) 2151 return true; 2152 # if !LOCK_ON_OPEN 2153 if (map->map_lockfd >= 0) 2154 (void) close(map->map_lockfd); 2155 # endif /* !LOCK_ON_OPEN */ 2156 errno = save_errno; 2157 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2158 syserr("Cannot open %s database %s", 2159 mapclassname, buf); 2160 return false; 2161 } 2162 2163 # if DB_VERSION_MAJOR < 2 2164 fd = db->fd(db); 2165 # else /* DB_VERSION_MAJOR < 2 */ 2166 fd = -1; 2167 errno = db->fd(db, &fd); 2168 # endif /* DB_VERSION_MAJOR < 2 */ 2169 if (filechanged(buf, fd, &st)) 2170 { 2171 save_errno = errno; 2172 # if DB_VERSION_MAJOR < 2 2173 (void) db->close(db); 2174 # else /* DB_VERSION_MAJOR < 2 */ 2175 errno = db->close(db, 0); 2176 # endif /* DB_VERSION_MAJOR < 2 */ 2177 # if !LOCK_ON_OPEN 2178 if (map->map_lockfd >= 0) 2179 (void) close(map->map_lockfd); 2180 # endif /* !LOCK_ON_OPEN */ 2181 errno = save_errno; 2182 syserr("db_map_open(%s): file changed after open", buf); 2183 return false; 2184 } 2185 2186 if (mode == O_RDWR) 2187 map->map_mflags |= MF_LOCKED; 2188 # if LOCK_ON_OPEN 2189 if (fd >= 0 && mode == O_RDONLY) 2190 { 2191 (void) lockfile(fd, buf, NULL, LOCK_UN); 2192 } 2193 # endif /* LOCK_ON_OPEN */ 2194 2195 /* try to make sure that at least the database header is on disk */ 2196 if (mode == O_RDWR) 2197 { 2198 (void) db->sync(db, 0); 2199 if (geteuid() == 0 && TrustedUid != 0) 2200 { 2201 # if HASFCHOWN 2202 if (fchown(fd, TrustedUid, -1) < 0) 2203 { 2204 int err = errno; 2205 2206 sm_syslog(LOG_ALERT, NOQID, 2207 "ownership change on %s failed: %s", 2208 buf, sm_errstring(err)); 2209 message("050 ownership change on %s failed: %s", 2210 buf, sm_errstring(err)); 2211 } 2212 # else /* HASFCHOWN */ 2213 sm_syslog(LOG_ALERT, NOQID, 2214 "no fchown(): cannot change ownership on %s", 2215 map->map_file); 2216 message("050 no fchown(): cannot change ownership on %s", 2217 map->map_file); 2218 # endif /* HASFCHOWN */ 2219 } 2220 } 2221 2222 map->map_db2 = (ARBPTR_T) db; 2223 2224 /* 2225 ** Need to set map_mtime before the call to aliaswait() 2226 ** as aliaswait() will call map_lookup() which requires 2227 ** map_mtime to be set 2228 */ 2229 2230 if (fd >= 0 && fstat(fd, &st) >= 0) 2231 map->map_mtime = st.st_mtime; 2232 2233 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) && 2234 !aliaswait(map, ".db", true)) 2235 return false; 2236 return true; 2237 } 2238 2239 2240 /* 2241 ** DB_MAP_LOOKUP -- look up a datum in a BTREE- or HASH-type map 2242 */ 2243 2244 char * 2245 db_map_lookup(map, name, av, statp) 2246 MAP *map; 2247 char *name; 2248 char **av; 2249 int *statp; 2250 { 2251 DBT key, val; 2252 register DB *db = (DB *) map->map_db2; 2253 int i; 2254 int st; 2255 int save_errno; 2256 int fd; 2257 struct stat stbuf; 2258 char keybuf[MAXNAME + 1]; 2259 char buf[MAXPATHLEN]; 2260 2261 memset(&key, '\0', sizeof key); 2262 memset(&val, '\0', sizeof val); 2263 2264 if (tTd(38, 20)) 2265 sm_dprintf("db_map_lookup(%s, %s)\n", 2266 map->map_mname, name); 2267 2268 if (sm_strlcpy(buf, map->map_file, sizeof buf) >= sizeof buf) 2269 { 2270 errno = 0; 2271 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2272 syserr("map \"%s\": map file %s name too long", 2273 map->map_mname, map->map_file); 2274 return NULL; 2275 } 2276 i = strlen(buf); 2277 if (i > 3 && strcmp(&buf[i - 3], ".db") == 0) 2278 buf[i - 3] = '\0'; 2279 2280 key.size = strlen(name); 2281 if (key.size > sizeof keybuf - 1) 2282 key.size = sizeof keybuf - 1; 2283 key.data = keybuf; 2284 memmove(keybuf, name, key.size); 2285 keybuf[key.size] = '\0'; 2286 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 2287 makelower(keybuf); 2288 lockdb: 2289 # if DB_VERSION_MAJOR < 2 2290 fd = db->fd(db); 2291 # else /* DB_VERSION_MAJOR < 2 */ 2292 fd = -1; 2293 errno = db->fd(db, &fd); 2294 # endif /* DB_VERSION_MAJOR < 2 */ 2295 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 2296 (void) lockfile(fd, buf, ".db", LOCK_SH); 2297 if (fd < 0 || fstat(fd, &stbuf) < 0 || stbuf.st_mtime > map->map_mtime) 2298 { 2299 /* Reopen the database to sync the cache */ 2300 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR 2301 : O_RDONLY; 2302 2303 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 2304 (void) lockfile(fd, buf, ".db", LOCK_UN); 2305 map->map_mflags |= MF_CLOSING; 2306 map->map_class->map_close(map); 2307 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING); 2308 if (map->map_class->map_open(map, omode)) 2309 { 2310 map->map_mflags |= MF_OPEN; 2311 map->map_pid = CurrentPid; 2312 if ((omode && O_ACCMODE) == O_RDWR) 2313 map->map_mflags |= MF_WRITABLE; 2314 db = (DB *) map->map_db2; 2315 goto lockdb; 2316 } 2317 else 2318 { 2319 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2320 { 2321 extern MAPCLASS BogusMapClass; 2322 2323 *statp = EX_TEMPFAIL; 2324 map->map_orgclass = map->map_class; 2325 map->map_class = &BogusMapClass; 2326 map->map_mflags |= MF_OPEN; 2327 map->map_pid = CurrentPid; 2328 syserr("Cannot reopen DB database %s", 2329 map->map_file); 2330 } 2331 return NULL; 2332 } 2333 } 2334 2335 st = 1; 2336 if (bitset(MF_TRY0NULL, map->map_mflags)) 2337 { 2338 # if DB_VERSION_MAJOR < 2 2339 st = db->get(db, &key, &val, 0); 2340 # else /* DB_VERSION_MAJOR < 2 */ 2341 errno = db->get(db, NULL, &key, &val, 0); 2342 switch (errno) 2343 { 2344 case DB_NOTFOUND: 2345 case DB_KEYEMPTY: 2346 st = 1; 2347 break; 2348 2349 case 0: 2350 st = 0; 2351 break; 2352 2353 default: 2354 st = -1; 2355 break; 2356 } 2357 # endif /* DB_VERSION_MAJOR < 2 */ 2358 if (st == 0) 2359 map->map_mflags &= ~MF_TRY1NULL; 2360 } 2361 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags)) 2362 { 2363 key.size++; 2364 # if DB_VERSION_MAJOR < 2 2365 st = db->get(db, &key, &val, 0); 2366 # else /* DB_VERSION_MAJOR < 2 */ 2367 errno = db->get(db, NULL, &key, &val, 0); 2368 switch (errno) 2369 { 2370 case DB_NOTFOUND: 2371 case DB_KEYEMPTY: 2372 st = 1; 2373 break; 2374 2375 case 0: 2376 st = 0; 2377 break; 2378 2379 default: 2380 st = -1; 2381 break; 2382 } 2383 # endif /* DB_VERSION_MAJOR < 2 */ 2384 if (st == 0) 2385 map->map_mflags &= ~MF_TRY0NULL; 2386 } 2387 save_errno = errno; 2388 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags)) 2389 (void) lockfile(fd, buf, ".db", LOCK_UN); 2390 if (st != 0) 2391 { 2392 errno = save_errno; 2393 if (st < 0) 2394 syserr("db_map_lookup: get (%s)", name); 2395 return NULL; 2396 } 2397 if (bitset(MF_MATCHONLY, map->map_mflags)) 2398 return map_rewrite(map, name, strlen(name), NULL); 2399 else 2400 return map_rewrite(map, val.data, val.size, av); 2401 } 2402 2403 2404 /* 2405 ** DB_MAP_STORE -- store a datum in the NEWDB database 2406 */ 2407 2408 void 2409 db_map_store(map, lhs, rhs) 2410 register MAP *map; 2411 char *lhs; 2412 char *rhs; 2413 { 2414 int status; 2415 DBT key; 2416 DBT data; 2417 register DB *db = map->map_db2; 2418 char keybuf[MAXNAME + 1]; 2419 2420 memset(&key, '\0', sizeof key); 2421 memset(&data, '\0', sizeof data); 2422 2423 if (tTd(38, 12)) 2424 sm_dprintf("db_map_store(%s, %s, %s)\n", 2425 map->map_mname, lhs, rhs); 2426 2427 key.size = strlen(lhs); 2428 key.data = lhs; 2429 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 2430 { 2431 if (key.size > sizeof keybuf - 1) 2432 key.size = sizeof keybuf - 1; 2433 memmove(keybuf, key.data, key.size); 2434 keybuf[key.size] = '\0'; 2435 makelower(keybuf); 2436 key.data = keybuf; 2437 } 2438 2439 data.size = strlen(rhs); 2440 data.data = rhs; 2441 2442 if (bitset(MF_INCLNULL, map->map_mflags)) 2443 { 2444 key.size++; 2445 data.size++; 2446 } 2447 2448 # if DB_VERSION_MAJOR < 2 2449 status = db->put(db, &key, &data, R_NOOVERWRITE); 2450 # else /* DB_VERSION_MAJOR < 2 */ 2451 errno = db->put(db, NULL, &key, &data, DB_NOOVERWRITE); 2452 switch (errno) 2453 { 2454 case DB_KEYEXIST: 2455 status = 1; 2456 break; 2457 2458 case 0: 2459 status = 0; 2460 break; 2461 2462 default: 2463 status = -1; 2464 break; 2465 } 2466 # endif /* DB_VERSION_MAJOR < 2 */ 2467 if (status > 0) 2468 { 2469 if (!bitset(MF_APPEND, map->map_mflags)) 2470 message("050 Warning: duplicate alias name %s", lhs); 2471 else 2472 { 2473 static char *buf = NULL; 2474 static int bufsiz = 0; 2475 DBT old; 2476 2477 memset(&old, '\0', sizeof old); 2478 2479 old.data = db_map_lookup(map, key.data, 2480 (char **) NULL, &status); 2481 if (old.data != NULL) 2482 { 2483 old.size = strlen(old.data); 2484 if (data.size + old.size + 2 > (size_t) bufsiz) 2485 { 2486 if (buf != NULL) 2487 sm_free(buf); 2488 bufsiz = data.size + old.size + 2; 2489 buf = sm_pmalloc_x(bufsiz); 2490 } 2491 (void) sm_strlcpyn(buf, bufsiz, 3, 2492 (char *) data.data, ",", 2493 (char *) old.data); 2494 data.size = data.size + old.size + 1; 2495 data.data = buf; 2496 if (tTd(38, 9)) 2497 sm_dprintf("db_map_store append=%s\n", 2498 (char *) data.data); 2499 } 2500 } 2501 # if DB_VERSION_MAJOR < 2 2502 status = db->put(db, &key, &data, 0); 2503 # else /* DB_VERSION_MAJOR < 2 */ 2504 status = errno = db->put(db, NULL, &key, &data, 0); 2505 # endif /* DB_VERSION_MAJOR < 2 */ 2506 } 2507 if (status != 0) 2508 syserr("readaliases: db put (%s)", lhs); 2509 } 2510 2511 2512 /* 2513 ** DB_MAP_CLOSE -- add distinguished entries and close the database 2514 */ 2515 2516 void 2517 db_map_close(map) 2518 MAP *map; 2519 { 2520 register DB *db = map->map_db2; 2521 2522 if (tTd(38, 9)) 2523 sm_dprintf("db_map_close(%s, %s, %lx)\n", 2524 map->map_mname, map->map_file, map->map_mflags); 2525 2526 if (bitset(MF_WRITABLE, map->map_mflags)) 2527 { 2528 /* write out the distinguished alias */ 2529 db_map_store(map, "@", "@"); 2530 } 2531 2532 (void) db->sync(db, 0); 2533 2534 # if !LOCK_ON_OPEN 2535 if (map->map_lockfd >= 0) 2536 (void) close(map->map_lockfd); 2537 # endif /* !LOCK_ON_OPEN */ 2538 2539 # if DB_VERSION_MAJOR < 2 2540 if (db->close(db) != 0) 2541 # else /* DB_VERSION_MAJOR < 2 */ 2542 /* 2543 ** Berkeley DB can use internal shared memory 2544 ** locking for its memory pool. Closing a map 2545 ** opened by another process will interfere 2546 ** with the shared memory and locks of the parent 2547 ** process leaving things in a bad state. 2548 */ 2549 2550 /* 2551 ** If this map was not opened by the current 2552 ** process, do not close the map but recover 2553 ** the file descriptor. 2554 */ 2555 2556 if (map->map_pid != CurrentPid) 2557 { 2558 int fd = -1; 2559 2560 errno = db->fd(db, &fd); 2561 if (fd >= 0) 2562 (void) close(fd); 2563 return; 2564 } 2565 2566 if ((errno = db->close(db, 0)) != 0) 2567 # endif /* DB_VERSION_MAJOR < 2 */ 2568 syserr("db_map_close(%s, %s, %lx): db close failure", 2569 map->map_mname, map->map_file, map->map_mflags); 2570 } 2571 #endif /* NEWDB */ 2572 /* 2573 ** NIS Modules 2574 */ 2575 2576 #if NIS 2577 2578 # ifndef YPERR_BUSY 2579 # define YPERR_BUSY 16 2580 # endif /* ! YPERR_BUSY */ 2581 2582 /* 2583 ** NIS_MAP_OPEN -- open DBM map 2584 */ 2585 2586 bool 2587 nis_map_open(map, mode) 2588 MAP *map; 2589 int mode; 2590 { 2591 int yperr; 2592 register char *p; 2593 auto char *vp; 2594 auto int vsize; 2595 2596 if (tTd(38, 2)) 2597 sm_dprintf("nis_map_open(%s, %s, %d)\n", 2598 map->map_mname, map->map_file, mode); 2599 2600 mode &= O_ACCMODE; 2601 if (mode != O_RDONLY) 2602 { 2603 /* issue a pseudo-error message */ 2604 errno = SM_EMAPCANTWRITE; 2605 return false; 2606 } 2607 2608 p = strchr(map->map_file, '@'); 2609 if (p != NULL) 2610 { 2611 *p++ = '\0'; 2612 if (*p != '\0') 2613 map->map_domain = p; 2614 } 2615 2616 if (*map->map_file == '\0') 2617 map->map_file = "mail.aliases"; 2618 2619 if (map->map_domain == NULL) 2620 { 2621 yperr = yp_get_default_domain(&map->map_domain); 2622 if (yperr != 0) 2623 { 2624 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2625 syserr("451 4.3.5 NIS map %s specified, but NIS not running", 2626 map->map_file); 2627 return false; 2628 } 2629 } 2630 2631 /* check to see if this map actually exists */ 2632 vp = NULL; 2633 yperr = yp_match(map->map_domain, map->map_file, "@", 1, 2634 &vp, &vsize); 2635 if (tTd(38, 10)) 2636 sm_dprintf("nis_map_open: yp_match(@, %s, %s) => %s\n", 2637 map->map_domain, map->map_file, yperr_string(yperr)); 2638 if (vp != NULL) 2639 sm_free(vp); 2640 2641 if (yperr == 0 || yperr == YPERR_KEY || yperr == YPERR_BUSY) 2642 { 2643 /* 2644 ** We ought to be calling aliaswait() here if this is an 2645 ** alias file, but powerful HP-UX NIS servers apparently 2646 ** don't insert the @:@ token into the alias map when it 2647 ** is rebuilt, so aliaswait() just hangs. I hate HP-UX. 2648 */ 2649 2650 # if 0 2651 if (!bitset(MF_ALIAS, map->map_mflags) || 2652 aliaswait(map, NULL, true)) 2653 # endif /* 0 */ 2654 return true; 2655 } 2656 2657 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2658 { 2659 syserr("451 4.3.5 Cannot bind to map %s in domain %s: %s", 2660 map->map_file, map->map_domain, yperr_string(yperr)); 2661 } 2662 2663 return false; 2664 } 2665 2666 2667 /* 2668 ** NIS_MAP_LOOKUP -- look up a datum in a NIS map 2669 */ 2670 2671 /* ARGSUSED3 */ 2672 char * 2673 nis_map_lookup(map, name, av, statp) 2674 MAP *map; 2675 char *name; 2676 char **av; 2677 int *statp; 2678 { 2679 char *vp; 2680 auto int vsize; 2681 int buflen; 2682 int yperr; 2683 char keybuf[MAXNAME + 1]; 2684 char *SM_NONVOLATILE result = NULL; 2685 2686 if (tTd(38, 20)) 2687 sm_dprintf("nis_map_lookup(%s, %s)\n", 2688 map->map_mname, name); 2689 2690 buflen = strlen(name); 2691 if (buflen > sizeof keybuf - 1) 2692 buflen = sizeof keybuf - 1; 2693 memmove(keybuf, name, buflen); 2694 keybuf[buflen] = '\0'; 2695 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 2696 makelower(keybuf); 2697 yperr = YPERR_KEY; 2698 vp = NULL; 2699 if (bitset(MF_TRY0NULL, map->map_mflags)) 2700 { 2701 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen, 2702 &vp, &vsize); 2703 if (yperr == 0) 2704 map->map_mflags &= ~MF_TRY1NULL; 2705 } 2706 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags)) 2707 { 2708 SM_FREE_CLR(vp); 2709 buflen++; 2710 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen, 2711 &vp, &vsize); 2712 if (yperr == 0) 2713 map->map_mflags &= ~MF_TRY0NULL; 2714 } 2715 if (yperr != 0) 2716 { 2717 if (yperr != YPERR_KEY && yperr != YPERR_BUSY) 2718 map->map_mflags &= ~(MF_VALID|MF_OPEN); 2719 if (vp != NULL) 2720 sm_free(vp); 2721 return NULL; 2722 } 2723 SM_TRY 2724 if (bitset(MF_MATCHONLY, map->map_mflags)) 2725 result = map_rewrite(map, name, strlen(name), NULL); 2726 else 2727 result = map_rewrite(map, vp, vsize, av); 2728 SM_FINALLY 2729 if (vp != NULL) 2730 sm_free(vp); 2731 SM_END_TRY 2732 return result; 2733 } 2734 2735 2736 /* 2737 ** NIS_GETCANONNAME -- look up canonical name in NIS 2738 */ 2739 2740 static bool 2741 nis_getcanonname(name, hbsize, statp) 2742 char *name; 2743 int hbsize; 2744 int *statp; 2745 { 2746 char *vp; 2747 auto int vsize; 2748 int keylen; 2749 int yperr; 2750 static bool try0null = true; 2751 static bool try1null = true; 2752 static char *yp_domain = NULL; 2753 char host_record[MAXLINE]; 2754 char cbuf[MAXNAME]; 2755 char nbuf[MAXNAME + 1]; 2756 2757 if (tTd(38, 20)) 2758 sm_dprintf("nis_getcanonname(%s)\n", name); 2759 2760 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf) 2761 { 2762 *statp = EX_UNAVAILABLE; 2763 return false; 2764 } 2765 (void) shorten_hostname(nbuf); 2766 keylen = strlen(nbuf); 2767 2768 if (yp_domain == NULL) 2769 (void) yp_get_default_domain(&yp_domain); 2770 makelower(nbuf); 2771 yperr = YPERR_KEY; 2772 vp = NULL; 2773 if (try0null) 2774 { 2775 yperr = yp_match(yp_domain, "hosts.byname", nbuf, keylen, 2776 &vp, &vsize); 2777 if (yperr == 0) 2778 try1null = false; 2779 } 2780 if (yperr == YPERR_KEY && try1null) 2781 { 2782 SM_FREE_CLR(vp); 2783 keylen++; 2784 yperr = yp_match(yp_domain, "hosts.byname", nbuf, keylen, 2785 &vp, &vsize); 2786 if (yperr == 0) 2787 try0null = false; 2788 } 2789 if (yperr != 0) 2790 { 2791 if (yperr == YPERR_KEY) 2792 *statp = EX_NOHOST; 2793 else if (yperr == YPERR_BUSY) 2794 *statp = EX_TEMPFAIL; 2795 else 2796 *statp = EX_UNAVAILABLE; 2797 if (vp != NULL) 2798 sm_free(vp); 2799 return false; 2800 } 2801 (void) sm_strlcpy(host_record, vp, sizeof host_record); 2802 sm_free(vp); 2803 if (tTd(38, 44)) 2804 sm_dprintf("got record `%s'\n", host_record); 2805 vp = strpbrk(host_record, "#\n"); 2806 if (vp != NULL) 2807 *vp = '\0'; 2808 if (!extract_canonname(nbuf, NULL, host_record, cbuf, sizeof cbuf)) 2809 { 2810 /* this should not happen, but.... */ 2811 *statp = EX_NOHOST; 2812 return false; 2813 } 2814 if (sm_strlcpy(name, cbuf, hbsize) >= hbsize) 2815 { 2816 *statp = EX_UNAVAILABLE; 2817 return false; 2818 } 2819 *statp = EX_OK; 2820 return true; 2821 } 2822 2823 #endif /* NIS */ 2824 /* 2825 ** NISPLUS Modules 2826 ** 2827 ** This code donated by Sun Microsystems. 2828 */ 2829 2830 #if NISPLUS 2831 2832 # undef NIS /* symbol conflict in nis.h */ 2833 # undef T_UNSPEC /* symbol conflict in nis.h -> ... -> sys/tiuser.h */ 2834 # include <rpcsvc/nis.h> 2835 # include <rpcsvc/nislib.h> 2836 2837 # define EN_col(col) zo_data.objdata_u.en_data.en_cols.en_cols_val[(col)].ec_value.ec_value_val 2838 # define COL_NAME(res,i) ((res->objects.objects_val)->TA_data.ta_cols.ta_cols_val)[i].tc_name 2839 # define COL_MAX(res) ((res->objects.objects_val)->TA_data.ta_cols.ta_cols_len) 2840 # define PARTIAL_NAME(x) ((x)[strlen(x) - 1] != '.') 2841 2842 /* 2843 ** NISPLUS_MAP_OPEN -- open nisplus table 2844 */ 2845 2846 bool 2847 nisplus_map_open(map, mode) 2848 MAP *map; 2849 int mode; 2850 { 2851 nis_result *res = NULL; 2852 int retry_cnt, max_col, i; 2853 char qbuf[MAXLINE + NIS_MAXNAMELEN]; 2854 2855 if (tTd(38, 2)) 2856 sm_dprintf("nisplus_map_open(%s, %s, %d)\n", 2857 map->map_mname, map->map_file, mode); 2858 2859 mode &= O_ACCMODE; 2860 if (mode != O_RDONLY) 2861 { 2862 errno = EPERM; 2863 return false; 2864 } 2865 2866 if (*map->map_file == '\0') 2867 map->map_file = "mail_aliases.org_dir"; 2868 2869 if (PARTIAL_NAME(map->map_file) && map->map_domain == NULL) 2870 { 2871 /* set default NISPLUS Domain to $m */ 2872 map->map_domain = newstr(nisplus_default_domain()); 2873 if (tTd(38, 2)) 2874 sm_dprintf("nisplus_map_open(%s): using domain %s\n", 2875 map->map_file, map->map_domain); 2876 } 2877 if (!PARTIAL_NAME(map->map_file)) 2878 { 2879 map->map_domain = newstr(""); 2880 (void) sm_strlcpy(qbuf, map->map_file, sizeof qbuf); 2881 } 2882 else 2883 { 2884 /* check to see if this map actually exists */ 2885 (void) sm_strlcpyn(qbuf, sizeof qbuf, 3, 2886 map->map_file, ".", map->map_domain); 2887 } 2888 2889 retry_cnt = 0; 2890 while (res == NULL || res->status != NIS_SUCCESS) 2891 { 2892 res = nis_lookup(qbuf, FOLLOW_LINKS); 2893 switch (res->status) 2894 { 2895 case NIS_SUCCESS: 2896 break; 2897 2898 case NIS_TRYAGAIN: 2899 case NIS_RPCERROR: 2900 case NIS_NAMEUNREACHABLE: 2901 if (retry_cnt++ > 4) 2902 { 2903 errno = EAGAIN; 2904 return false; 2905 } 2906 /* try not to overwhelm hosed server */ 2907 sleep(2); 2908 break; 2909 2910 default: /* all other nisplus errors */ 2911 # if 0 2912 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2913 syserr("451 4.3.5 Cannot find table %s.%s: %s", 2914 map->map_file, map->map_domain, 2915 nis_sperrno(res->status)); 2916 # endif /* 0 */ 2917 errno = EAGAIN; 2918 return false; 2919 } 2920 } 2921 2922 if (NIS_RES_NUMOBJ(res) != 1 || 2923 (NIS_RES_OBJECT(res)->zo_data.zo_type != TABLE_OBJ)) 2924 { 2925 if (tTd(38, 10)) 2926 sm_dprintf("nisplus_map_open: %s is not a table\n", qbuf); 2927 # if 0 2928 if (!bitset(MF_OPTIONAL, map->map_mflags)) 2929 syserr("451 4.3.5 %s.%s: %s is not a table", 2930 map->map_file, map->map_domain, 2931 nis_sperrno(res->status)); 2932 # endif /* 0 */ 2933 errno = EBADF; 2934 return false; 2935 } 2936 /* default key column is column 0 */ 2937 if (map->map_keycolnm == NULL) 2938 map->map_keycolnm = newstr(COL_NAME(res,0)); 2939 2940 max_col = COL_MAX(res); 2941 2942 /* verify the key column exist */ 2943 for (i = 0; i < max_col; i++) 2944 { 2945 if (strcmp(map->map_keycolnm, COL_NAME(res,i)) == 0) 2946 break; 2947 } 2948 if (i == max_col) 2949 { 2950 if (tTd(38, 2)) 2951 sm_dprintf("nisplus_map_open(%s): can not find key column %s\n", 2952 map->map_file, map->map_keycolnm); 2953 errno = ENOENT; 2954 return false; 2955 } 2956 2957 /* default value column is the last column */ 2958 if (map->map_valcolnm == NULL) 2959 { 2960 map->map_valcolno = max_col - 1; 2961 return true; 2962 } 2963 2964 for (i = 0; i< max_col; i++) 2965 { 2966 if (strcmp(map->map_valcolnm, COL_NAME(res,i)) == 0) 2967 { 2968 map->map_valcolno = i; 2969 return true; 2970 } 2971 } 2972 2973 if (tTd(38, 2)) 2974 sm_dprintf("nisplus_map_open(%s): can not find column %s\n", 2975 map->map_file, map->map_keycolnm); 2976 errno = ENOENT; 2977 return false; 2978 } 2979 2980 2981 /* 2982 ** NISPLUS_MAP_LOOKUP -- look up a datum in a NISPLUS table 2983 */ 2984 2985 char * 2986 nisplus_map_lookup(map, name, av, statp) 2987 MAP *map; 2988 char *name; 2989 char **av; 2990 int *statp; 2991 { 2992 char *p; 2993 auto int vsize; 2994 char *skp; 2995 int skleft; 2996 char search_key[MAXNAME + 4]; 2997 char qbuf[MAXLINE + NIS_MAXNAMELEN]; 2998 nis_result *result; 2999 3000 if (tTd(38, 20)) 3001 sm_dprintf("nisplus_map_lookup(%s, %s)\n", 3002 map->map_mname, name); 3003 3004 if (!bitset(MF_OPEN, map->map_mflags)) 3005 { 3006 if (nisplus_map_open(map, O_RDONLY)) 3007 { 3008 map->map_mflags |= MF_OPEN; 3009 map->map_pid = CurrentPid; 3010 } 3011 else 3012 { 3013 *statp = EX_UNAVAILABLE; 3014 return NULL; 3015 } 3016 } 3017 3018 /* 3019 ** Copy the name to the key buffer, escaping double quote characters 3020 ** by doubling them and quoting "]" and "," to avoid having the 3021 ** NIS+ parser choke on them. 3022 */ 3023 3024 skleft = sizeof search_key - 4; 3025 skp = search_key; 3026 for (p = name; *p != '\0' && skleft > 0; p++) 3027 { 3028 switch (*p) 3029 { 3030 case ']': 3031 case ',': 3032 /* quote the character */ 3033 *skp++ = '"'; 3034 *skp++ = *p; 3035 *skp++ = '"'; 3036 skleft -= 3; 3037 break; 3038 3039 case '"': 3040 /* double the quote */ 3041 *skp++ = '"'; 3042 skleft--; 3043 /* FALLTHROUGH */ 3044 3045 default: 3046 *skp++ = *p; 3047 skleft--; 3048 break; 3049 } 3050 } 3051 *skp = '\0'; 3052 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 3053 makelower(search_key); 3054 3055 /* construct the query */ 3056 if (PARTIAL_NAME(map->map_file)) 3057 (void) sm_snprintf(qbuf, sizeof qbuf, "[%s=%s],%s.%s", 3058 map->map_keycolnm, search_key, map->map_file, 3059 map->map_domain); 3060 else 3061 (void) sm_snprintf(qbuf, sizeof qbuf, "[%s=%s],%s", 3062 map->map_keycolnm, search_key, map->map_file); 3063 3064 if (tTd(38, 20)) 3065 sm_dprintf("qbuf=%s\n", qbuf); 3066 result = nis_list(qbuf, FOLLOW_LINKS | FOLLOW_PATH, NULL, NULL); 3067 if (result->status == NIS_SUCCESS) 3068 { 3069 int count; 3070 char *str; 3071 3072 if ((count = NIS_RES_NUMOBJ(result)) != 1) 3073 { 3074 if (LogLevel > 10) 3075 sm_syslog(LOG_WARNING, CurEnv->e_id, 3076 "%s: lookup error, expected 1 entry, got %d", 3077 map->map_file, count); 3078 3079 /* ignore second entry */ 3080 if (tTd(38, 20)) 3081 sm_dprintf("nisplus_map_lookup(%s), got %d entries, additional entries ignored\n", 3082 name, count); 3083 } 3084 3085 p = ((NIS_RES_OBJECT(result))->EN_col(map->map_valcolno)); 3086 /* set the length of the result */ 3087 if (p == NULL) 3088 p = ""; 3089 vsize = strlen(p); 3090 if (tTd(38, 20)) 3091 sm_dprintf("nisplus_map_lookup(%s), found %s\n", 3092 name, p); 3093 if (bitset(MF_MATCHONLY, map->map_mflags)) 3094 str = map_rewrite(map, name, strlen(name), NULL); 3095 else 3096 str = map_rewrite(map, p, vsize, av); 3097 nis_freeresult(result); 3098 *statp = EX_OK; 3099 return str; 3100 } 3101 else 3102 { 3103 if (result->status == NIS_NOTFOUND) 3104 *statp = EX_NOTFOUND; 3105 else if (result->status == NIS_TRYAGAIN) 3106 *statp = EX_TEMPFAIL; 3107 else 3108 { 3109 *statp = EX_UNAVAILABLE; 3110 map->map_mflags &= ~(MF_VALID|MF_OPEN); 3111 } 3112 } 3113 if (tTd(38, 20)) 3114 sm_dprintf("nisplus_map_lookup(%s), failed\n", name); 3115 nis_freeresult(result); 3116 return NULL; 3117 } 3118 3119 3120 3121 /* 3122 ** NISPLUS_GETCANONNAME -- look up canonical name in NIS+ 3123 */ 3124 3125 static bool 3126 nisplus_getcanonname(name, hbsize, statp) 3127 char *name; 3128 int hbsize; 3129 int *statp; 3130 { 3131 char *vp; 3132 auto int vsize; 3133 nis_result *result; 3134 char *p; 3135 char nbuf[MAXNAME + 1]; 3136 char qbuf[MAXLINE + NIS_MAXNAMELEN]; 3137 3138 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf) 3139 { 3140 *statp = EX_UNAVAILABLE; 3141 return false; 3142 } 3143 (void) shorten_hostname(nbuf); 3144 3145 p = strchr(nbuf, '.'); 3146 if (p == NULL) 3147 { 3148 /* single token */ 3149 (void) sm_snprintf(qbuf, sizeof qbuf, 3150 "[name=%s],hosts.org_dir", nbuf); 3151 } 3152 else if (p[1] != '\0') 3153 { 3154 /* multi token -- take only first token in nbuf */ 3155 *p = '\0'; 3156 (void) sm_snprintf(qbuf, sizeof qbuf, 3157 "[name=%s],hosts.org_dir.%s", nbuf, &p[1]); 3158 } 3159 else 3160 { 3161 *statp = EX_NOHOST; 3162 return false; 3163 } 3164 3165 if (tTd(38, 20)) 3166 sm_dprintf("\nnisplus_getcanonname(%s), qbuf=%s\n", 3167 name, qbuf); 3168 3169 result = nis_list(qbuf, EXPAND_NAME|FOLLOW_LINKS|FOLLOW_PATH, 3170 NULL, NULL); 3171 3172 if (result->status == NIS_SUCCESS) 3173 { 3174 int count; 3175 char *domain; 3176 3177 if ((count = NIS_RES_NUMOBJ(result)) != 1) 3178 { 3179 if (LogLevel > 10) 3180 sm_syslog(LOG_WARNING, CurEnv->e_id, 3181 "nisplus_getcanonname: lookup error, expected 1 entry, got %d", 3182 count); 3183 3184 /* ignore second entry */ 3185 if (tTd(38, 20)) 3186 sm_dprintf("nisplus_getcanonname(%s), got %d entries, all but first ignored\n", 3187 name, count); 3188 } 3189 3190 if (tTd(38, 20)) 3191 sm_dprintf("nisplus_getcanonname(%s), found in directory \"%s\"\n", 3192 name, (NIS_RES_OBJECT(result))->zo_domain); 3193 3194 3195 vp = ((NIS_RES_OBJECT(result))->EN_col(0)); 3196 vsize = strlen(vp); 3197 if (tTd(38, 20)) 3198 sm_dprintf("nisplus_getcanonname(%s), found %s\n", 3199 name, vp); 3200 if (strchr(vp, '.') != NULL) 3201 { 3202 domain = ""; 3203 } 3204 else 3205 { 3206 domain = macvalue('m', CurEnv); 3207 if (domain == NULL) 3208 domain = ""; 3209 } 3210 if (hbsize > vsize + (int) strlen(domain) + 1) 3211 { 3212 if (domain[0] == '\0') 3213 (void) sm_strlcpy(name, vp, hbsize); 3214 else 3215 (void) sm_snprintf(name, hbsize, 3216 "%s.%s", vp, domain); 3217 *statp = EX_OK; 3218 } 3219 else 3220 *statp = EX_NOHOST; 3221 nis_freeresult(result); 3222 return true; 3223 } 3224 else 3225 { 3226 if (result->status == NIS_NOTFOUND) 3227 *statp = EX_NOHOST; 3228 else if (result->status == NIS_TRYAGAIN) 3229 *statp = EX_TEMPFAIL; 3230 else 3231 *statp = EX_UNAVAILABLE; 3232 } 3233 if (tTd(38, 20)) 3234 sm_dprintf("nisplus_getcanonname(%s), failed, status=%d, nsw_stat=%d\n", 3235 name, result->status, *statp); 3236 nis_freeresult(result); 3237 return false; 3238 } 3239 3240 char * 3241 nisplus_default_domain() 3242 { 3243 static char default_domain[MAXNAME + 1] = ""; 3244 char *p; 3245 3246 if (default_domain[0] != '\0') 3247 return default_domain; 3248 3249 p = nis_local_directory(); 3250 (void) sm_strlcpy(default_domain, p, sizeof default_domain); 3251 return default_domain; 3252 } 3253 3254 #endif /* NISPLUS */ 3255 /* 3256 ** LDAP Modules 3257 */ 3258 3259 /* 3260 ** LDAPMAP_DEQUOTE - helper routine for ldapmap_parseargs 3261 */ 3262 3263 #if defined(LDAPMAP) || defined(PH_MAP) 3264 3265 # if PH_MAP 3266 # define ph_map_dequote ldapmap_dequote 3267 # endif /* PH_MAP */ 3268 3269 static char *ldapmap_dequote __P((char *)); 3270 3271 static char * 3272 ldapmap_dequote(str) 3273 char *str; 3274 { 3275 char *p; 3276 char *start; 3277 3278 if (str == NULL) 3279 return NULL; 3280 3281 p = str; 3282 if (*p == '"') 3283 { 3284 /* Should probably swallow initial whitespace here */ 3285 start = ++p; 3286 } 3287 else 3288 return str; 3289 while (*p != '"' && *p != '\0') 3290 p++; 3291 if (*p != '\0') 3292 *p = '\0'; 3293 return start; 3294 } 3295 #endif /* defined(LDAPMAP) || defined(PH_MAP) */ 3296 3297 #if LDAPMAP 3298 3299 static SM_LDAP_STRUCT *LDAPDefaults = NULL; 3300 3301 /* 3302 ** LDAPMAP_OPEN -- open LDAP map 3303 ** 3304 ** Connect to the LDAP server. Re-use existing connections since a 3305 ** single server connection to a host (with the same host, port, 3306 ** bind DN, and secret) can answer queries for multiple maps. 3307 */ 3308 3309 bool 3310 ldapmap_open(map, mode) 3311 MAP *map; 3312 int mode; 3313 { 3314 SM_LDAP_STRUCT *lmap; 3315 STAB *s; 3316 char *id; 3317 3318 if (tTd(38, 2)) 3319 sm_dprintf("ldapmap_open(%s, %d): ", map->map_mname, mode); 3320 3321 mode &= O_ACCMODE; 3322 3323 /* sendmail doesn't have the ability to write to LDAP (yet) */ 3324 if (mode != O_RDONLY) 3325 { 3326 /* issue a pseudo-error message */ 3327 errno = SM_EMAPCANTWRITE; 3328 return false; 3329 } 3330 3331 lmap = (SM_LDAP_STRUCT *) map->map_db1; 3332 3333 s = ldapmap_findconn(lmap); 3334 if (s->s_lmap != NULL) 3335 { 3336 /* Already have a connection open to this LDAP server */ 3337 lmap->ldap_ld = ((SM_LDAP_STRUCT *)s->s_lmap->map_db1)->ldap_ld; 3338 lmap->ldap_pid = ((SM_LDAP_STRUCT *)s->s_lmap->map_db1)->ldap_pid; 3339 3340 /* Add this map as head of linked list */ 3341 lmap->ldap_next = s->s_lmap; 3342 s->s_lmap = map; 3343 3344 if (tTd(38, 2)) 3345 sm_dprintf("using cached connection\n"); 3346 return true; 3347 } 3348 3349 if (tTd(38, 2)) 3350 sm_dprintf("opening new connection\n"); 3351 3352 if (lmap->ldap_host != NULL) 3353 id = lmap->ldap_host; 3354 else if (lmap->ldap_uri != NULL) 3355 id = lmap->ldap_uri; 3356 else 3357 id = "localhost"; 3358 3359 /* No connection yet, connect */ 3360 if (!sm_ldap_start(map->map_mname, lmap)) 3361 { 3362 if (errno == ETIMEDOUT) 3363 { 3364 if (LogLevel > 1) 3365 sm_syslog(LOG_NOTICE, CurEnv->e_id, 3366 "timeout conning to LDAP server %.100s", 3367 id); 3368 } 3369 3370 if (!bitset(MF_OPTIONAL, map->map_mflags)) 3371 { 3372 if (bitset(MF_NODEFER, map->map_mflags)) 3373 { 3374 syserr("%s failed to %s in map %s", 3375 # if USE_LDAP_INIT 3376 "ldap_init/ldap_bind", 3377 # else /* USE_LDAP_INIT */ 3378 "ldap_open", 3379 # endif /* USE_LDAP_INIT */ 3380 id, map->map_mname); 3381 } 3382 else 3383 { 3384 syserr("451 4.3.5 %s failed to %s in map %s", 3385 # if USE_LDAP_INIT 3386 "ldap_init/ldap_bind", 3387 # else /* USE_LDAP_INIT */ 3388 "ldap_open", 3389 # endif /* USE_LDAP_INIT */ 3390 id, map->map_mname); 3391 } 3392 } 3393 return false; 3394 } 3395 3396 /* Save connection for reuse */ 3397 s->s_lmap = map; 3398 return true; 3399 } 3400 3401 /* 3402 ** LDAPMAP_CLOSE -- close ldap map 3403 */ 3404 3405 void 3406 ldapmap_close(map) 3407 MAP *map; 3408 { 3409 SM_LDAP_STRUCT *lmap; 3410 STAB *s; 3411 3412 if (tTd(38, 2)) 3413 sm_dprintf("ldapmap_close(%s)\n", map->map_mname); 3414 3415 lmap = (SM_LDAP_STRUCT *) map->map_db1; 3416 3417 /* Check if already closed */ 3418 if (lmap->ldap_ld == NULL) 3419 return; 3420 3421 /* Close the LDAP connection */ 3422 sm_ldap_close(lmap); 3423 3424 /* Mark all the maps that share the connection as closed */ 3425 s = ldapmap_findconn(lmap); 3426 3427 while (s->s_lmap != NULL) 3428 { 3429 MAP *smap = s->s_lmap; 3430 3431 if (tTd(38, 2) && smap != map) 3432 sm_dprintf("ldapmap_close(%s): closed %s (shared LDAP connection)\n", 3433 map->map_mname, smap->map_mname); 3434 smap->map_mflags &= ~(MF_OPEN|MF_WRITABLE); 3435 lmap = (SM_LDAP_STRUCT *) smap->map_db1; 3436 lmap->ldap_ld = NULL; 3437 s->s_lmap = lmap->ldap_next; 3438 lmap->ldap_next = NULL; 3439 } 3440 } 3441 3442 # ifdef SUNET_ID 3443 /* 3444 ** SUNET_ID_HASH -- Convert a string to its Sunet_id canonical form 3445 ** This only makes sense at Stanford University. 3446 */ 3447 3448 static char * 3449 sunet_id_hash(str) 3450 char *str; 3451 { 3452 char *p, *p_last; 3453 3454 p = str; 3455 p_last = p; 3456 while (*p != '\0') 3457 { 3458 if (islower(*p) || isdigit(*p)) 3459 { 3460 *p_last = *p; 3461 p_last++; 3462 } 3463 else if (isupper(*p)) 3464 { 3465 *p_last = tolower(*p); 3466 p_last++; 3467 } 3468 ++p; 3469 } 3470 if (*p_last != '\0') 3471 *p_last = '\0'; 3472 return str; 3473 } 3474 # endif /* SUNET_ID */ 3475 3476 /* 3477 ** LDAPMAP_LOOKUP -- look up a datum in a LDAP map 3478 */ 3479 3480 char * 3481 ldapmap_lookup(map, name, av, statp) 3482 MAP *map; 3483 char *name; 3484 char **av; 3485 int *statp; 3486 { 3487 int flags; 3488 int plen = 0; 3489 int psize = 0; 3490 int msgid; 3491 int save_errno; 3492 char *vp, *p; 3493 char *result = NULL; 3494 SM_RPOOL_T *rpool; 3495 SM_LDAP_STRUCT *lmap = NULL; 3496 char keybuf[MAXNAME + 1]; 3497 3498 if (tTd(38, 20)) 3499 sm_dprintf("ldapmap_lookup(%s, %s)\n", map->map_mname, name); 3500 3501 /* Get ldap struct pointer from map */ 3502 lmap = (SM_LDAP_STRUCT *) map->map_db1; 3503 sm_ldap_setopts(lmap->ldap_ld, lmap); 3504 3505 (void) sm_strlcpy(keybuf, name, sizeof keybuf); 3506 3507 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 3508 { 3509 # ifdef SUNET_ID 3510 sunet_id_hash(keybuf); 3511 # else /* SUNET_ID */ 3512 makelower(keybuf); 3513 # endif /* SUNET_ID */ 3514 } 3515 3516 msgid = sm_ldap_search(lmap, keybuf); 3517 if (msgid == -1) 3518 { 3519 errno = sm_ldap_geterrno(lmap->ldap_ld) + E_LDAPBASE; 3520 save_errno = errno; 3521 if (!bitset(MF_OPTIONAL, map->map_mflags)) 3522 { 3523 if (bitset(MF_NODEFER, map->map_mflags)) 3524 syserr("Error in ldap_search using %s in map %s", 3525 keybuf, map->map_mname); 3526 else 3527 syserr("451 4.3.5 Error in ldap_search using %s in map %s", 3528 keybuf, map->map_mname); 3529 } 3530 *statp = EX_TEMPFAIL; 3531 switch (save_errno - E_LDAPBASE) 3532 { 3533 # ifdef LDAP_SERVER_DOWN 3534 case LDAP_SERVER_DOWN: 3535 # endif /* LDAP_SERVER_DOWN */ 3536 case LDAP_TIMEOUT: 3537 case LDAP_UNAVAILABLE: 3538 /* server disappeared, try reopen on next search */ 3539 ldapmap_close(map); 3540 break; 3541 } 3542 errno = save_errno; 3543 return NULL; 3544 } 3545 3546 *statp = EX_NOTFOUND; 3547 vp = NULL; 3548 3549 flags = 0; 3550 if (bitset(MF_SINGLEMATCH, map->map_mflags)) 3551 flags |= SM_LDAP_SINGLEMATCH; 3552 if (bitset(MF_MATCHONLY, map->map_mflags)) 3553 flags |= SM_LDAP_MATCHONLY; 3554 3555 /* Create an rpool for search related memory usage */ 3556 rpool = sm_rpool_new_x(NULL); 3557 3558 p = NULL; 3559 *statp = sm_ldap_results(lmap, msgid, flags, map->map_coldelim, 3560 rpool, &p, &plen, &psize, NULL); 3561 save_errno = errno; 3562 3563 /* Copy result so rpool can be freed */ 3564 if (*statp == EX_OK && p != NULL) 3565 vp = newstr(p); 3566 sm_rpool_free(rpool); 3567 3568 /* need to restart LDAP connection? */ 3569 if (*statp == EX_RESTART) 3570 { 3571 *statp = EX_TEMPFAIL; 3572 ldapmap_close(map); 3573 } 3574 3575 errno = save_errno; 3576 if (*statp != EX_OK && *statp != EX_NOTFOUND) 3577 { 3578 if (!bitset(MF_OPTIONAL, map->map_mflags)) 3579 { 3580 if (bitset(MF_NODEFER, map->map_mflags)) 3581 syserr("Error getting LDAP results in map %s", 3582 map->map_mname); 3583 else 3584 syserr("451 4.3.5 Error getting LDAP results in map %s", 3585 map->map_mname); 3586 } 3587 errno = save_errno; 3588 return NULL; 3589 } 3590 3591 /* Did we match anything? */ 3592 if (vp == NULL && !bitset(MF_MATCHONLY, map->map_mflags)) 3593 return NULL; 3594 3595 if (*statp == EX_OK) 3596 { 3597 if (LogLevel > 9) 3598 sm_syslog(LOG_INFO, CurEnv->e_id, 3599 "ldap %.100s => %s", name, 3600 vp == NULL ? "<NULL>" : vp); 3601 if (bitset(MF_MATCHONLY, map->map_mflags)) 3602 result = map_rewrite(map, name, strlen(name), NULL); 3603 else 3604 { 3605 /* vp != NULL according to test above */ 3606 result = map_rewrite(map, vp, strlen(vp), av); 3607 } 3608 if (vp != NULL) 3609 sm_free(vp); /* XXX */ 3610 } 3611 return result; 3612 } 3613 3614 /* 3615 ** LDAPMAP_FINDCONN -- find an LDAP connection to the server 3616 ** 3617 ** Cache LDAP connections based on the host, port, bind DN, 3618 ** secret, and PID so we don't have multiple connections open to 3619 ** the same server for different maps. Need a separate connection 3620 ** per PID since a parent process may close the map before the 3621 ** child is done with it. 3622 ** 3623 ** Parameters: 3624 ** lmap -- LDAP map information 3625 ** 3626 ** Returns: 3627 ** Symbol table entry for the LDAP connection. 3628 */ 3629 3630 static STAB * 3631 ldapmap_findconn(lmap) 3632 SM_LDAP_STRUCT *lmap; 3633 { 3634 char *format; 3635 char *nbuf; 3636 char *id; 3637 STAB *SM_NONVOLATILE s = NULL; 3638 3639 if (lmap->ldap_host != NULL) 3640 id = lmap->ldap_host; 3641 else if (lmap->ldap_uri != NULL) 3642 id = lmap->ldap_uri; 3643 else 3644 id = "localhost"; 3645 3646 format = "%s%c%d%c%d%c%s%c%s%d"; 3647 nbuf = sm_stringf_x(format, 3648 id, 3649 CONDELSE, 3650 lmap->ldap_port, 3651 CONDELSE, 3652 lmap->ldap_version, 3653 CONDELSE, 3654 (lmap->ldap_binddn == NULL ? "" 3655 : lmap->ldap_binddn), 3656 CONDELSE, 3657 (lmap->ldap_secret == NULL ? "" 3658 : lmap->ldap_secret), 3659 (int) CurrentPid); 3660 SM_TRY 3661 s = stab(nbuf, ST_LMAP, ST_ENTER); 3662 SM_FINALLY 3663 sm_free(nbuf); 3664 SM_END_TRY 3665 return s; 3666 } 3667 /* 3668 ** LDAPMAP_PARSEARGS -- parse ldap map definition args. 3669 */ 3670 3671 static struct lamvalues LDAPAuthMethods[] = 3672 { 3673 { "none", LDAP_AUTH_NONE }, 3674 { "simple", LDAP_AUTH_SIMPLE }, 3675 # ifdef LDAP_AUTH_KRBV4 3676 { "krbv4", LDAP_AUTH_KRBV4 }, 3677 # endif /* LDAP_AUTH_KRBV4 */ 3678 { NULL, 0 } 3679 }; 3680 3681 static struct ladvalues LDAPAliasDereference[] = 3682 { 3683 { "never", LDAP_DEREF_NEVER }, 3684 { "always", LDAP_DEREF_ALWAYS }, 3685 { "search", LDAP_DEREF_SEARCHING }, 3686 { "find", LDAP_DEREF_FINDING }, 3687 { NULL, 0 } 3688 }; 3689 3690 static struct lssvalues LDAPSearchScope[] = 3691 { 3692 { "base", LDAP_SCOPE_BASE }, 3693 { "one", LDAP_SCOPE_ONELEVEL }, 3694 { "sub", LDAP_SCOPE_SUBTREE }, 3695 { NULL, 0 } 3696 }; 3697 3698 bool 3699 ldapmap_parseargs(map, args) 3700 MAP *map; 3701 char *args; 3702 { 3703 bool secretread = true; 3704 bool attrssetup = false; 3705 int i; 3706 register char *p = args; 3707 SM_LDAP_STRUCT *lmap; 3708 struct lamvalues *lam; 3709 struct ladvalues *lad; 3710 struct lssvalues *lss; 3711 char ldapfilt[MAXLINE]; 3712 char m_tmp[MAXPATHLEN + LDAPMAP_MAX_PASSWD]; 3713 3714 /* Get ldap struct pointer from map */ 3715 lmap = (SM_LDAP_STRUCT *) map->map_db1; 3716 3717 /* Check if setting the initial LDAP defaults */ 3718 if (lmap == NULL || lmap != LDAPDefaults) 3719 { 3720 /* We need to alloc an SM_LDAP_STRUCT struct */ 3721 lmap = (SM_LDAP_STRUCT *) xalloc(sizeof *lmap); 3722 if (LDAPDefaults == NULL) 3723 sm_ldap_clear(lmap); 3724 else 3725 STRUCTCOPY(*LDAPDefaults, *lmap); 3726 } 3727 3728 /* there is no check whether there is really an argument */ 3729 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL; 3730 map->map_spacesub = SpaceSub; /* default value */ 3731 3732 /* Check if setting up an alias or file class LDAP map */ 3733 if (bitset(MF_ALIAS, map->map_mflags)) 3734 { 3735 /* Comma separate if used as an alias file */ 3736 map->map_coldelim = ','; 3737 if (*args == '\0') 3738 { 3739 int n; 3740 char *lc; 3741 char jbuf[MAXHOSTNAMELEN]; 3742 char lcbuf[MAXLINE]; 3743 3744 /* Get $j */ 3745 expand("\201j", jbuf, sizeof jbuf, &BlankEnvelope); 3746 if (jbuf[0] == '\0') 3747 { 3748 (void) sm_strlcpy(jbuf, "localhost", 3749 sizeof jbuf); 3750 } 3751 3752 lc = macvalue(macid("{sendmailMTACluster}"), CurEnv); 3753 if (lc == NULL) 3754 lc = ""; 3755 else 3756 { 3757 expand(lc, lcbuf, sizeof lcbuf, CurEnv); 3758 lc = lcbuf; 3759 } 3760 3761 n = sm_snprintf(ldapfilt, sizeof ldapfilt, 3762 "(&(objectClass=sendmailMTAAliasObject)(sendmailMTAAliasGrouping=aliases)(|(sendmailMTACluster=%s)(sendmailMTAHost=%s))(sendmailMTAKey=%%0))", 3763 lc, jbuf); 3764 if (n >= sizeof ldapfilt) 3765 { 3766 syserr("%s: Default LDAP string too long", 3767 map->map_mname); 3768 return false; 3769 } 3770 3771 /* default args for an alias LDAP entry */ 3772 lmap->ldap_filter = ldapfilt; 3773 lmap->ldap_attr[0] = "objectClass"; 3774 lmap->ldap_attr_type[0] = SM_LDAP_ATTR_OBJCLASS; 3775 lmap->ldap_attr_needobjclass[0] = NULL; 3776 lmap->ldap_attr[1] = "sendmailMTAAliasValue"; 3777 lmap->ldap_attr_type[1] = SM_LDAP_ATTR_NORMAL; 3778 lmap->ldap_attr_needobjclass[1] = NULL; 3779 lmap->ldap_attr[2] = "sendmailMTAAliasSearch"; 3780 lmap->ldap_attr_type[2] = SM_LDAP_ATTR_FILTER; 3781 lmap->ldap_attr_needobjclass[2] = "sendmailMTAMapObject"; 3782 lmap->ldap_attr[3] = "sendmailMTAAliasURL"; 3783 lmap->ldap_attr_type[3] = SM_LDAP_ATTR_URL; 3784 lmap->ldap_attr_needobjclass[3] = "sendmailMTAMapObject"; 3785 lmap->ldap_attr[4] = NULL; 3786 lmap->ldap_attr_type[4] = SM_LDAP_ATTR_NONE; 3787 lmap->ldap_attr_needobjclass[4] = NULL; 3788 attrssetup = true; 3789 } 3790 } 3791 else if (bitset(MF_FILECLASS, map->map_mflags)) 3792 { 3793 /* Space separate if used as a file class file */ 3794 map->map_coldelim = ' '; 3795 } 3796 3797 for (;;) 3798 { 3799 while (isascii(*p) && isspace(*p)) 3800 p++; 3801 if (*p != '-') 3802 break; 3803 switch (*++p) 3804 { 3805 case 'N': 3806 map->map_mflags |= MF_INCLNULL; 3807 map->map_mflags &= ~MF_TRY0NULL; 3808 break; 3809 3810 case 'O': 3811 map->map_mflags &= ~MF_TRY1NULL; 3812 break; 3813 3814 case 'o': 3815 map->map_mflags |= MF_OPTIONAL; 3816 break; 3817 3818 case 'f': 3819 map->map_mflags |= MF_NOFOLDCASE; 3820 break; 3821 3822 case 'm': 3823 map->map_mflags |= MF_MATCHONLY; 3824 break; 3825 3826 case 'A': 3827 map->map_mflags |= MF_APPEND; 3828 break; 3829 3830 case 'q': 3831 map->map_mflags |= MF_KEEPQUOTES; 3832 break; 3833 3834 case 'a': 3835 map->map_app = ++p; 3836 break; 3837 3838 case 'T': 3839 map->map_tapp = ++p; 3840 break; 3841 3842 case 't': 3843 map->map_mflags |= MF_NODEFER; 3844 break; 3845 3846 case 'S': 3847 map->map_spacesub = *++p; 3848 break; 3849 3850 case 'D': 3851 map->map_mflags |= MF_DEFER; 3852 break; 3853 3854 case 'z': 3855 if (*++p != '\\') 3856 map->map_coldelim = *p; 3857 else 3858 { 3859 switch (*++p) 3860 { 3861 case 'n': 3862 map->map_coldelim = '\n'; 3863 break; 3864 3865 case 't': 3866 map->map_coldelim = '\t'; 3867 break; 3868 3869 default: 3870 map->map_coldelim = '\\'; 3871 } 3872 } 3873 break; 3874 3875 /* Start of ldapmap specific args */ 3876 case 'V': 3877 if (*++p != '\\') 3878 lmap->ldap_attrsep = *p; 3879 else 3880 { 3881 switch (*++p) 3882 { 3883 case 'n': 3884 lmap->ldap_attrsep = '\n'; 3885 break; 3886 3887 case 't': 3888 lmap->ldap_attrsep = '\t'; 3889 break; 3890 3891 default: 3892 lmap->ldap_attrsep = '\\'; 3893 } 3894 } 3895 break; 3896 3897 case 'k': /* search field */ 3898 while (isascii(*++p) && isspace(*p)) 3899 continue; 3900 lmap->ldap_filter = p; 3901 break; 3902 3903 case 'v': /* attr to return */ 3904 while (isascii(*++p) && isspace(*p)) 3905 continue; 3906 lmap->ldap_attr[0] = p; 3907 lmap->ldap_attr[1] = NULL; 3908 break; 3909 3910 case '1': 3911 map->map_mflags |= MF_SINGLEMATCH; 3912 break; 3913 3914 /* args stolen from ldapsearch.c */ 3915 case 'R': /* don't auto chase referrals */ 3916 # ifdef LDAP_REFERRALS 3917 lmap->ldap_options &= ~LDAP_OPT_REFERRALS; 3918 # else /* LDAP_REFERRALS */ 3919 syserr("compile with -DLDAP_REFERRALS for referral support"); 3920 # endif /* LDAP_REFERRALS */ 3921 break; 3922 3923 case 'n': /* retrieve attribute names only */ 3924 lmap->ldap_attrsonly = LDAPMAP_TRUE; 3925 break; 3926 3927 case 'r': /* alias dereferencing */ 3928 while (isascii(*++p) && isspace(*p)) 3929 continue; 3930 3931 if (sm_strncasecmp(p, "LDAP_DEREF_", 11) == 0) 3932 p += 11; 3933 3934 for (lad = LDAPAliasDereference; 3935 lad != NULL && lad->lad_name != NULL; lad++) 3936 { 3937 if (sm_strncasecmp(p, lad->lad_name, 3938 strlen(lad->lad_name)) == 0) 3939 break; 3940 } 3941 if (lad->lad_name != NULL) 3942 lmap->ldap_deref = lad->lad_code; 3943 else 3944 { 3945 /* bad config line */ 3946 if (!bitset(MCF_OPTFILE, 3947 map->map_class->map_cflags)) 3948 { 3949 char *ptr; 3950 3951 if ((ptr = strchr(p, ' ')) != NULL) 3952 *ptr = '\0'; 3953 syserr("Deref must be [never|always|search|find] (not %s) in map %s", 3954 p, map->map_mname); 3955 if (ptr != NULL) 3956 *ptr = ' '; 3957 return false; 3958 } 3959 } 3960 break; 3961 3962 case 's': /* search scope */ 3963 while (isascii(*++p) && isspace(*p)) 3964 continue; 3965 3966 if (sm_strncasecmp(p, "LDAP_SCOPE_", 11) == 0) 3967 p += 11; 3968 3969 for (lss = LDAPSearchScope; 3970 lss != NULL && lss->lss_name != NULL; lss++) 3971 { 3972 if (sm_strncasecmp(p, lss->lss_name, 3973 strlen(lss->lss_name)) == 0) 3974 break; 3975 } 3976 if (lss->lss_name != NULL) 3977 lmap->ldap_scope = lss->lss_code; 3978 else 3979 { 3980 /* bad config line */ 3981 if (!bitset(MCF_OPTFILE, 3982 map->map_class->map_cflags)) 3983 { 3984 char *ptr; 3985 3986 if ((ptr = strchr(p, ' ')) != NULL) 3987 *ptr = '\0'; 3988 syserr("Scope must be [base|one|sub] (not %s) in map %s", 3989 p, map->map_mname); 3990 if (ptr != NULL) 3991 *ptr = ' '; 3992 return false; 3993 } 3994 } 3995 break; 3996 3997 case 'h': /* ldap host */ 3998 while (isascii(*++p) && isspace(*p)) 3999 continue; 4000 if (lmap->ldap_uri != NULL) 4001 { 4002 syserr("Can not specify both an LDAP host and an LDAP URI in map %s", 4003 map->map_mname); 4004 return false; 4005 } 4006 lmap->ldap_host = p; 4007 break; 4008 4009 case 'b': /* search base */ 4010 while (isascii(*++p) && isspace(*p)) 4011 continue; 4012 lmap->ldap_base = p; 4013 break; 4014 4015 case 'p': /* ldap port */ 4016 while (isascii(*++p) && isspace(*p)) 4017 continue; 4018 lmap->ldap_port = atoi(p); 4019 break; 4020 4021 case 'l': /* time limit */ 4022 while (isascii(*++p) && isspace(*p)) 4023 continue; 4024 lmap->ldap_timelimit = atoi(p); 4025 lmap->ldap_timeout.tv_sec = lmap->ldap_timelimit; 4026 break; 4027 4028 case 'Z': 4029 while (isascii(*++p) && isspace(*p)) 4030 continue; 4031 lmap->ldap_sizelimit = atoi(p); 4032 break; 4033 4034 case 'd': /* Dn to bind to server as */ 4035 while (isascii(*++p) && isspace(*p)) 4036 continue; 4037 lmap->ldap_binddn = p; 4038 break; 4039 4040 case 'M': /* Method for binding */ 4041 while (isascii(*++p) && isspace(*p)) 4042 continue; 4043 4044 if (sm_strncasecmp(p, "LDAP_AUTH_", 10) == 0) 4045 p += 10; 4046 4047 for (lam = LDAPAuthMethods; 4048 lam != NULL && lam->lam_name != NULL; lam++) 4049 { 4050 if (sm_strncasecmp(p, lam->lam_name, 4051 strlen(lam->lam_name)) == 0) 4052 break; 4053 } 4054 if (lam->lam_name != NULL) 4055 lmap->ldap_method = lam->lam_code; 4056 else 4057 { 4058 /* bad config line */ 4059 if (!bitset(MCF_OPTFILE, 4060 map->map_class->map_cflags)) 4061 { 4062 char *ptr; 4063 4064 if ((ptr = strchr(p, ' ')) != NULL) 4065 *ptr = '\0'; 4066 syserr("Method for binding must be [none|simple|krbv4] (not %s) in map %s", 4067 p, map->map_mname); 4068 if (ptr != NULL) 4069 *ptr = ' '; 4070 return false; 4071 } 4072 } 4073 4074 break; 4075 4076 /* 4077 ** This is a string that is dependent on the 4078 ** method used defined above. 4079 */ 4080 4081 case 'P': /* Secret password for binding */ 4082 while (isascii(*++p) && isspace(*p)) 4083 continue; 4084 lmap->ldap_secret = p; 4085 secretread = false; 4086 break; 4087 4088 case 'H': /* Use LDAP URI */ 4089 # if !USE_LDAP_INIT 4090 syserr("Must compile with -DUSE_LDAP_INIT to use LDAP URIs (-H) in map %s", 4091 map->map_mname); 4092 return false; 4093 # else /* !USE_LDAP_INIT */ 4094 if (lmap->ldap_host != NULL) 4095 { 4096 syserr("Can not specify both an LDAP host and an LDAP URI in map %s", 4097 map->map_mname); 4098 return false; 4099 } 4100 while (isascii(*++p) && isspace(*p)) 4101 continue; 4102 lmap->ldap_uri = p; 4103 break; 4104 # endif /* !USE_LDAP_INIT */ 4105 4106 case 'w': 4107 /* -w should be for passwd, -P should be for version */ 4108 while (isascii(*++p) && isspace(*p)) 4109 continue; 4110 lmap->ldap_version = atoi(p); 4111 # ifdef LDAP_VERSION_MAX 4112 if (lmap->ldap_version > LDAP_VERSION_MAX) 4113 { 4114 syserr("LDAP version %d exceeds max of %d in map %s", 4115 lmap->ldap_version, LDAP_VERSION_MAX, 4116 map->map_mname); 4117 return false; 4118 } 4119 # endif /* LDAP_VERSION_MAX */ 4120 # ifdef LDAP_VERSION_MIN 4121 if (lmap->ldap_version < LDAP_VERSION_MIN) 4122 { 4123 syserr("LDAP version %d is lower than min of %d in map %s", 4124 lmap->ldap_version, LDAP_VERSION_MIN, 4125 map->map_mname); 4126 return false; 4127 } 4128 # endif /* LDAP_VERSION_MIN */ 4129 break; 4130 4131 default: 4132 syserr("Illegal option %c map %s", *p, map->map_mname); 4133 break; 4134 } 4135 4136 /* need to account for quoted strings here */ 4137 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 4138 { 4139 if (*p == '"') 4140 { 4141 while (*++p != '"' && *p != '\0') 4142 continue; 4143 if (*p != '\0') 4144 p++; 4145 } 4146 else 4147 p++; 4148 } 4149 4150 if (*p != '\0') 4151 *p++ = '\0'; 4152 } 4153 4154 if (map->map_app != NULL) 4155 map->map_app = newstr(ldapmap_dequote(map->map_app)); 4156 if (map->map_tapp != NULL) 4157 map->map_tapp = newstr(ldapmap_dequote(map->map_tapp)); 4158 4159 /* 4160 ** We need to swallow up all the stuff into a struct 4161 ** and dump it into map->map_dbptr1 4162 */ 4163 4164 if (lmap->ldap_host != NULL && 4165 (LDAPDefaults == NULL || 4166 LDAPDefaults == lmap || 4167 LDAPDefaults->ldap_host != lmap->ldap_host)) 4168 lmap->ldap_host = newstr(ldapmap_dequote(lmap->ldap_host)); 4169 map->map_domain = lmap->ldap_host; 4170 4171 if (lmap->ldap_uri != NULL && 4172 (LDAPDefaults == NULL || 4173 LDAPDefaults == lmap || 4174 LDAPDefaults->ldap_uri != lmap->ldap_uri)) 4175 lmap->ldap_uri = newstr(ldapmap_dequote(lmap->ldap_uri)); 4176 map->map_domain = lmap->ldap_uri; 4177 4178 if (lmap->ldap_binddn != NULL && 4179 (LDAPDefaults == NULL || 4180 LDAPDefaults == lmap || 4181 LDAPDefaults->ldap_binddn != lmap->ldap_binddn)) 4182 lmap->ldap_binddn = newstr(ldapmap_dequote(lmap->ldap_binddn)); 4183 4184 if (lmap->ldap_secret != NULL && 4185 (LDAPDefaults == NULL || 4186 LDAPDefaults == lmap || 4187 LDAPDefaults->ldap_secret != lmap->ldap_secret)) 4188 { 4189 SM_FILE_T *sfd; 4190 long sff = SFF_OPENASROOT|SFF_ROOTOK|SFF_NOWLINK|SFF_NOWWFILES|SFF_NOGWFILES; 4191 4192 if (DontLockReadFiles) 4193 sff |= SFF_NOLOCK; 4194 4195 /* need to use method to map secret to passwd string */ 4196 switch (lmap->ldap_method) 4197 { 4198 case LDAP_AUTH_NONE: 4199 /* Do nothing */ 4200 break; 4201 4202 case LDAP_AUTH_SIMPLE: 4203 4204 /* 4205 ** Secret is the name of a file with 4206 ** the first line as the password. 4207 */ 4208 4209 /* Already read in the secret? */ 4210 if (secretread) 4211 break; 4212 4213 sfd = safefopen(ldapmap_dequote(lmap->ldap_secret), 4214 O_RDONLY, 0, sff); 4215 if (sfd == NULL) 4216 { 4217 syserr("LDAP map: cannot open secret %s", 4218 ldapmap_dequote(lmap->ldap_secret)); 4219 return false; 4220 } 4221 lmap->ldap_secret = sfgets(m_tmp, sizeof m_tmp, 4222 sfd, TimeOuts.to_fileopen, 4223 "ldapmap_parseargs"); 4224 (void) sm_io_close(sfd, SM_TIME_DEFAULT); 4225 if (strlen(m_tmp) > LDAPMAP_MAX_PASSWD) 4226 { 4227 syserr("LDAP map: secret in %s too long", 4228 ldapmap_dequote(lmap->ldap_secret)); 4229 return false; 4230 } 4231 if (lmap->ldap_secret != NULL && 4232 strlen(m_tmp) > 0) 4233 { 4234 /* chomp newline */ 4235 if (m_tmp[strlen(m_tmp) - 1] == '\n') 4236 m_tmp[strlen(m_tmp) - 1] = '\0'; 4237 4238 lmap->ldap_secret = m_tmp; 4239 } 4240 break; 4241 4242 # ifdef LDAP_AUTH_KRBV4 4243 case LDAP_AUTH_KRBV4: 4244 4245 /* 4246 ** Secret is where the ticket file is 4247 ** stashed 4248 */ 4249 4250 (void) sm_snprintf(m_tmp, sizeof m_tmp, 4251 "KRBTKFILE=%s", 4252 ldapmap_dequote(lmap->ldap_secret)); 4253 lmap->ldap_secret = m_tmp; 4254 break; 4255 # endif /* LDAP_AUTH_KRBV4 */ 4256 4257 default: /* Should NEVER get here */ 4258 syserr("LDAP map: Illegal value in lmap method"); 4259 return false; 4260 /* NOTREACHED */ 4261 break; 4262 } 4263 } 4264 4265 if (lmap->ldap_secret != NULL && 4266 (LDAPDefaults == NULL || 4267 LDAPDefaults == lmap || 4268 LDAPDefaults->ldap_secret != lmap->ldap_secret)) 4269 lmap->ldap_secret = newstr(ldapmap_dequote(lmap->ldap_secret)); 4270 4271 if (lmap->ldap_base != NULL && 4272 (LDAPDefaults == NULL || 4273 LDAPDefaults == lmap || 4274 LDAPDefaults->ldap_base != lmap->ldap_base)) 4275 lmap->ldap_base = newstr(ldapmap_dequote(lmap->ldap_base)); 4276 4277 /* 4278 ** Save the server from extra work. If request is for a single 4279 ** match, tell the server to only return enough records to 4280 ** determine if there is a single match or not. This can not 4281 ** be one since the server would only return one and we wouldn't 4282 ** know if there were others available. 4283 */ 4284 4285 if (bitset(MF_SINGLEMATCH, map->map_mflags)) 4286 lmap->ldap_sizelimit = 2; 4287 4288 /* If setting defaults, don't process ldap_filter and ldap_attr */ 4289 if (lmap == LDAPDefaults) 4290 return true; 4291 4292 if (lmap->ldap_filter != NULL) 4293 lmap->ldap_filter = newstr(ldapmap_dequote(lmap->ldap_filter)); 4294 else 4295 { 4296 if (!bitset(MCF_OPTFILE, map->map_class->map_cflags)) 4297 { 4298 syserr("No filter given in map %s", map->map_mname); 4299 return false; 4300 } 4301 } 4302 4303 if (!attrssetup && lmap->ldap_attr[0] != NULL) 4304 { 4305 bool recurse = false; 4306 bool normalseen = false; 4307 4308 i = 0; 4309 p = ldapmap_dequote(lmap->ldap_attr[0]); 4310 lmap->ldap_attr[0] = NULL; 4311 4312 /* Prime the attr list with the objectClass attribute */ 4313 lmap->ldap_attr[i] = "objectClass"; 4314 lmap->ldap_attr_type[i] = SM_LDAP_ATTR_OBJCLASS; 4315 lmap->ldap_attr_needobjclass[i] = NULL; 4316 i++; 4317 4318 while (p != NULL) 4319 { 4320 char *v; 4321 4322 while (isascii(*p) && isspace(*p)) 4323 p++; 4324 if (*p == '\0') 4325 break; 4326 v = p; 4327 p = strchr(v, ','); 4328 if (p != NULL) 4329 *p++ = '\0'; 4330 4331 if (i >= LDAPMAP_MAX_ATTR) 4332 { 4333 syserr("Too many return attributes in %s (max %d)", 4334 map->map_mname, LDAPMAP_MAX_ATTR); 4335 return false; 4336 } 4337 if (*v != '\0') 4338 { 4339 int j; 4340 int use; 4341 char *type; 4342 char *needobjclass; 4343 4344 type = strchr(v, ':'); 4345 if (type != NULL) 4346 { 4347 *type++ = '\0'; 4348 needobjclass = strchr(type, ':'); 4349 if (needobjclass != NULL) 4350 *needobjclass++ = '\0'; 4351 } 4352 else 4353 { 4354 needobjclass = NULL; 4355 } 4356 4357 use = i; 4358 4359 /* allow override on "objectClass" type */ 4360 if (sm_strcasecmp(v, "objectClass") == 0 && 4361 lmap->ldap_attr_type[0] == SM_LDAP_ATTR_OBJCLASS) 4362 { 4363 use = 0; 4364 } 4365 else 4366 { 4367 /* 4368 ** Don't add something to attribute 4369 ** list twice. 4370 */ 4371 4372 for (j = 1; j < i; j++) 4373 { 4374 if (sm_strcasecmp(v, lmap->ldap_attr[j]) == 0) 4375 { 4376 syserr("Duplicate attribute (%s) in %s", 4377 v, map->map_mname); 4378 return false; 4379 } 4380 } 4381 4382 lmap->ldap_attr[use] = newstr(v); 4383 if (needobjclass != NULL && 4384 *needobjclass != '\0' && 4385 *needobjclass != '*') 4386 { 4387 lmap->ldap_attr_needobjclass[use] = newstr(needobjclass); 4388 } 4389 else 4390 { 4391 lmap->ldap_attr_needobjclass[use] = NULL; 4392 } 4393 4394 } 4395 4396 if (type != NULL && *type != '\0') 4397 { 4398 if (sm_strcasecmp(type, "dn") == 0) 4399 { 4400 recurse = true; 4401 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_DN; 4402 } 4403 else if (sm_strcasecmp(type, "filter") == 0) 4404 { 4405 recurse = true; 4406 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_FILTER; 4407 } 4408 else if (sm_strcasecmp(type, "url") == 0) 4409 { 4410 recurse = true; 4411 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_URL; 4412 } 4413 else if (sm_strcasecmp(type, "normal") == 0) 4414 { 4415 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_NORMAL; 4416 normalseen = true; 4417 } 4418 else 4419 { 4420 syserr("Unknown attribute type (%s) in %s", 4421 type, map->map_mname); 4422 return false; 4423 } 4424 } 4425 else 4426 { 4427 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_NORMAL; 4428 normalseen = true; 4429 } 4430 i++; 4431 } 4432 } 4433 lmap->ldap_attr[i] = NULL; 4434 4435 /* Set in case needed in future code */ 4436 attrssetup = true; 4437 4438 if (recurse && !normalseen) 4439 { 4440 syserr("LDAP recursion requested in %s but no returnable attribute given", 4441 map->map_mname); 4442 return false; 4443 } 4444 if (recurse && lmap->ldap_attrsonly == LDAPMAP_TRUE) 4445 { 4446 syserr("LDAP recursion requested in %s can not be used with -n", 4447 map->map_mname); 4448 return false; 4449 } 4450 } 4451 map->map_db1 = (ARBPTR_T) lmap; 4452 return true; 4453 } 4454 4455 /* 4456 ** LDAPMAP_SET_DEFAULTS -- Read default map spec from LDAPDefaults in .cf 4457 ** 4458 ** Parameters: 4459 ** spec -- map argument string from LDAPDefaults option 4460 ** 4461 ** Returns: 4462 ** None. 4463 */ 4464 4465 void 4466 ldapmap_set_defaults(spec) 4467 char *spec; 4468 { 4469 STAB *class; 4470 MAP map; 4471 4472 /* Allocate and set the default values */ 4473 if (LDAPDefaults == NULL) 4474 LDAPDefaults = (SM_LDAP_STRUCT *) xalloc(sizeof *LDAPDefaults); 4475 sm_ldap_clear(LDAPDefaults); 4476 4477 memset(&map, '\0', sizeof map); 4478 4479 /* look up the class */ 4480 class = stab("ldap", ST_MAPCLASS, ST_FIND); 4481 if (class == NULL) 4482 { 4483 syserr("readcf: LDAPDefaultSpec: class ldap not available"); 4484 return; 4485 } 4486 map.map_class = &class->s_mapclass; 4487 map.map_db1 = (ARBPTR_T) LDAPDefaults; 4488 map.map_mname = "O LDAPDefaultSpec"; 4489 4490 (void) ldapmap_parseargs(&map, spec); 4491 4492 /* These should never be set in LDAPDefaults */ 4493 if (map.map_mflags != (MF_TRY0NULL|MF_TRY1NULL) || 4494 map.map_spacesub != SpaceSub || 4495 map.map_app != NULL || 4496 map.map_tapp != NULL) 4497 { 4498 syserr("readcf: option LDAPDefaultSpec: Do not set non-LDAP specific flags"); 4499 SM_FREE_CLR(map.map_app); 4500 SM_FREE_CLR(map.map_tapp); 4501 } 4502 4503 if (LDAPDefaults->ldap_filter != NULL) 4504 { 4505 syserr("readcf: option LDAPDefaultSpec: Do not set the LDAP search filter"); 4506 4507 /* don't free, it isn't malloc'ed in parseargs */ 4508 LDAPDefaults->ldap_filter = NULL; 4509 } 4510 4511 if (LDAPDefaults->ldap_attr[0] != NULL) 4512 { 4513 syserr("readcf: option LDAPDefaultSpec: Do not set the requested LDAP attributes"); 4514 /* don't free, they aren't malloc'ed in parseargs */ 4515 LDAPDefaults->ldap_attr[0] = NULL; 4516 } 4517 } 4518 #endif /* LDAPMAP */ 4519 /* 4520 ** PH map 4521 */ 4522 4523 #if PH_MAP 4524 4525 /* 4526 ** Support for the CCSO Nameserver (ph/qi). 4527 ** This code is intended to replace the so-called "ph mailer". 4528 ** Contributed by Mark D. Roth <roth@uiuc.edu>. Contact him for support. 4529 */ 4530 4531 /* what version of the ph map code we're running */ 4532 static char phmap_id[128]; 4533 4534 /* sendmail version for phmap id string */ 4535 extern const char Version[]; 4536 4537 /* assume we're using nph-1.2.x if not specified */ 4538 # ifndef NPH_VERSION 4539 # define NPH_VERSION 10200 4540 # endif 4541 4542 /* compatibility for versions older than nph-1.2.0 */ 4543 # if NPH_VERSION < 10200 4544 # define PH_OPEN_ROUNDROBIN PH_ROUNDROBIN 4545 # define PH_OPEN_DONTID PH_DONTID 4546 # define PH_CLOSE_FAST PH_FASTCLOSE 4547 # define PH_ERR_DATAERR PH_DATAERR 4548 # define PH_ERR_NOMATCH PH_NOMATCH 4549 # endif /* NPH_VERSION < 10200 */ 4550 4551 /* 4552 ** PH_MAP_PARSEARGS -- parse ph map definition args. 4553 */ 4554 4555 bool 4556 ph_map_parseargs(map, args) 4557 MAP *map; 4558 char *args; 4559 { 4560 register bool done; 4561 register char *p = args; 4562 PH_MAP_STRUCT *pmap = NULL; 4563 4564 /* initialize version string */ 4565 (void) sm_snprintf(phmap_id, sizeof phmap_id, 4566 "sendmail-%s phmap-20010529 libphclient-%s", 4567 Version, libphclient_version); 4568 4569 pmap = (PH_MAP_STRUCT *) xalloc(sizeof *pmap); 4570 4571 /* defaults */ 4572 pmap->ph_servers = NULL; 4573 pmap->ph_field_list = NULL; 4574 pmap->ph = NULL; 4575 pmap->ph_timeout = 0; 4576 pmap->ph_fastclose = 0; 4577 4578 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL; 4579 for (;;) 4580 { 4581 while (isascii(*p) && isspace(*p)) 4582 p++; 4583 if (*p != '-') 4584 break; 4585 switch (*++p) 4586 { 4587 case 'N': 4588 map->map_mflags |= MF_INCLNULL; 4589 map->map_mflags &= ~MF_TRY0NULL; 4590 break; 4591 4592 case 'O': 4593 map->map_mflags &= ~MF_TRY1NULL; 4594 break; 4595 4596 case 'o': 4597 map->map_mflags |= MF_OPTIONAL; 4598 break; 4599 4600 case 'f': 4601 map->map_mflags |= MF_NOFOLDCASE; 4602 break; 4603 4604 case 'm': 4605 map->map_mflags |= MF_MATCHONLY; 4606 break; 4607 4608 case 'A': 4609 map->map_mflags |= MF_APPEND; 4610 break; 4611 4612 case 'q': 4613 map->map_mflags |= MF_KEEPQUOTES; 4614 break; 4615 4616 case 't': 4617 map->map_mflags |= MF_NODEFER; 4618 break; 4619 4620 case 'a': 4621 map->map_app = ++p; 4622 break; 4623 4624 case 'T': 4625 map->map_tapp = ++p; 4626 break; 4627 4628 case 'l': 4629 while (isascii(*++p) && isspace(*p)) 4630 continue; 4631 pmap->ph_timeout = atoi(p); 4632 break; 4633 4634 case 'S': 4635 map->map_spacesub = *++p; 4636 break; 4637 4638 case 'D': 4639 map->map_mflags |= MF_DEFER; 4640 break; 4641 4642 case 'h': /* PH server list */ 4643 while (isascii(*++p) && isspace(*p)) 4644 continue; 4645 pmap->ph_servers = p; 4646 break; 4647 4648 case 'k': /* fields to search for */ 4649 while (isascii(*++p) && isspace(*p)) 4650 continue; 4651 pmap->ph_field_list = p; 4652 break; 4653 4654 default: 4655 syserr("ph_map_parseargs: unknown option -%c", *p); 4656 } 4657 4658 /* try to account for quoted strings */ 4659 done = isascii(*p) && isspace(*p); 4660 while (*p != '\0' && !done) 4661 { 4662 if (*p == '"') 4663 { 4664 while (*++p != '"' && *p != '\0') 4665 continue; 4666 if (*p != '\0') 4667 p++; 4668 } 4669 else 4670 p++; 4671 done = isascii(*p) && isspace(*p); 4672 } 4673 4674 if (*p != '\0') 4675 *p++ = '\0'; 4676 } 4677 4678 if (map->map_app != NULL) 4679 map->map_app = newstr(ph_map_dequote(map->map_app)); 4680 if (map->map_tapp != NULL) 4681 map->map_tapp = newstr(ph_map_dequote(map->map_tapp)); 4682 4683 if (pmap->ph_field_list != NULL) 4684 pmap->ph_field_list = newstr(ph_map_dequote(pmap->ph_field_list)); 4685 4686 if (pmap->ph_servers != NULL) 4687 pmap->ph_servers = newstr(ph_map_dequote(pmap->ph_servers)); 4688 else 4689 { 4690 syserr("ph_map_parseargs: -h flag is required"); 4691 return false; 4692 } 4693 4694 map->map_db1 = (ARBPTR_T) pmap; 4695 return true; 4696 } 4697 4698 /* 4699 ** PH_MAP_CLOSE -- close the connection to the ph server 4700 */ 4701 4702 void 4703 ph_map_close(map) 4704 MAP *map; 4705 { 4706 PH_MAP_STRUCT *pmap; 4707 4708 pmap = (PH_MAP_STRUCT *)map->map_db1; 4709 if (tTd(38, 9)) 4710 sm_dprintf("ph_map_close(%s): pmap->ph_fastclose=%d\n", 4711 map->map_mname, pmap->ph_fastclose); 4712 4713 4714 if (pmap->ph != NULL) 4715 { 4716 ph_set_sendhook(pmap->ph, NULL); 4717 ph_set_recvhook(pmap->ph, NULL); 4718 ph_close(pmap->ph, pmap->ph_fastclose); 4719 } 4720 4721 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE); 4722 } 4723 4724 static jmp_buf PHTimeout; 4725 4726 /* ARGSUSED */ 4727 static void 4728 ph_timeout(unused) 4729 int unused; 4730 { 4731 /* 4732 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 4733 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 4734 ** DOING. 4735 */ 4736 4737 errno = ETIMEDOUT; 4738 longjmp(PHTimeout, 1); 4739 } 4740 4741 static void 4742 #if NPH_VERSION >= 10200 4743 ph_map_send_debug(appdata, text) 4744 void *appdata; 4745 #else 4746 ph_map_send_debug(text) 4747 #endif 4748 char *text; 4749 { 4750 if (LogLevel > 9) 4751 sm_syslog(LOG_NOTICE, CurEnv->e_id, 4752 "ph_map_send_debug: ==> %s", text); 4753 if (tTd(38, 20)) 4754 sm_dprintf("ph_map_send_debug: ==> %s\n", text); 4755 } 4756 4757 static void 4758 #if NPH_VERSION >= 10200 4759 ph_map_recv_debug(appdata, text) 4760 void *appdata; 4761 #else 4762 ph_map_recv_debug(text) 4763 #endif 4764 char *text; 4765 { 4766 if (LogLevel > 10) 4767 sm_syslog(LOG_NOTICE, CurEnv->e_id, 4768 "ph_map_recv_debug: <== %s", text); 4769 if (tTd(38, 21)) 4770 sm_dprintf("ph_map_recv_debug: <== %s\n", text); 4771 } 4772 4773 /* 4774 ** PH_MAP_OPEN -- sub for opening PH map 4775 */ 4776 bool 4777 ph_map_open(map, mode) 4778 MAP *map; 4779 int mode; 4780 { 4781 PH_MAP_STRUCT *pmap; 4782 register SM_EVENT *ev = NULL; 4783 int save_errno = 0; 4784 char *hostlist, *host; 4785 4786 if (tTd(38, 2)) 4787 sm_dprintf("ph_map_open(%s)\n", map->map_mname); 4788 4789 mode &= O_ACCMODE; 4790 if (mode != O_RDONLY) 4791 { 4792 /* issue a pseudo-error message */ 4793 errno = SM_EMAPCANTWRITE; 4794 return false; 4795 } 4796 4797 if (CurEnv != NULL && CurEnv->e_sendmode == SM_DEFER && 4798 bitset(MF_DEFER, map->map_mflags)) 4799 { 4800 if (tTd(9, 1)) 4801 sm_dprintf("ph_map_open(%s) => DEFERRED\n", 4802 map->map_mname); 4803 4804 /* 4805 ** Unset MF_DEFER here so that map_lookup() returns 4806 ** a temporary failure using the bogus map and 4807 ** map->map_tapp instead of the default permanent error. 4808 */ 4809 4810 map->map_mflags &= ~MF_DEFER; 4811 return false; 4812 } 4813 4814 pmap = (PH_MAP_STRUCT *)map->map_db1; 4815 pmap->ph_fastclose = 0; /* refresh field for reopen */ 4816 4817 /* try each host in the list */ 4818 hostlist = newstr(pmap->ph_servers); 4819 for (host = strtok(hostlist, " "); 4820 host != NULL; 4821 host = strtok(NULL, " ")) 4822 { 4823 /* set timeout */ 4824 if (pmap->ph_timeout != 0) 4825 { 4826 if (setjmp(PHTimeout) != 0) 4827 { 4828 ev = NULL; 4829 if (LogLevel > 1) 4830 sm_syslog(LOG_NOTICE, CurEnv->e_id, 4831 "timeout connecting to PH server %.100s", 4832 host); 4833 errno = ETIMEDOUT; 4834 goto ph_map_open_abort; 4835 } 4836 ev = sm_setevent(pmap->ph_timeout, ph_timeout, 0); 4837 } 4838 4839 /* open connection to server */ 4840 if (ph_open(&(pmap->ph), host, 4841 PH_OPEN_ROUNDROBIN|PH_OPEN_DONTID, 4842 ph_map_send_debug, ph_map_recv_debug 4843 #if NPH_VERSION >= 10200 4844 , NULL 4845 #endif 4846 ) == 0 4847 && ph_id(pmap->ph, phmap_id) == 0) 4848 { 4849 if (ev != NULL) 4850 sm_clrevent(ev); 4851 sm_free(hostlist); /* XXX */ 4852 return true; 4853 } 4854 4855 ph_map_open_abort: 4856 save_errno = errno; 4857 if (ev != NULL) 4858 sm_clrevent(ev); 4859 pmap->ph_fastclose = PH_CLOSE_FAST; 4860 ph_map_close(map); 4861 errno = save_errno; 4862 } 4863 4864 if (bitset(MF_NODEFER, map->map_mflags)) 4865 { 4866 if (errno == 0) 4867 errno = EAGAIN; 4868 syserr("ph_map_open: %s: cannot connect to PH server", 4869 map->map_mname); 4870 } 4871 else if (!bitset(MF_OPTIONAL, map->map_mflags) && LogLevel > 1) 4872 sm_syslog(LOG_NOTICE, CurEnv->e_id, 4873 "ph_map_open: %s: cannot connect to PH server", 4874 map->map_mname); 4875 sm_free(hostlist); /* XXX */ 4876 return false; 4877 } 4878 4879 /* 4880 ** PH_MAP_LOOKUP -- look up key from ph server 4881 */ 4882 4883 char * 4884 ph_map_lookup(map, key, args, pstat) 4885 MAP *map; 4886 char *key; 4887 char **args; 4888 int *pstat; 4889 { 4890 int i, save_errno = 0; 4891 register SM_EVENT *ev = NULL; 4892 PH_MAP_STRUCT *pmap; 4893 char *value = NULL; 4894 4895 pmap = (PH_MAP_STRUCT *)map->map_db1; 4896 4897 *pstat = EX_OK; 4898 4899 /* set timeout */ 4900 if (pmap->ph_timeout != 0) 4901 { 4902 if (setjmp(PHTimeout) != 0) 4903 { 4904 ev = NULL; 4905 if (LogLevel > 1) 4906 sm_syslog(LOG_NOTICE, CurEnv->e_id, 4907 "timeout during PH lookup of %.100s", 4908 key); 4909 errno = ETIMEDOUT; 4910 *pstat = EX_TEMPFAIL; 4911 goto ph_map_lookup_abort; 4912 } 4913 ev = sm_setevent(pmap->ph_timeout, ph_timeout, 0); 4914 } 4915 4916 /* perform lookup */ 4917 i = ph_email_resolve(pmap->ph, key, pmap->ph_field_list, &value); 4918 if (i == -1) 4919 *pstat = EX_TEMPFAIL; 4920 else if (i == PH_ERR_NOMATCH || i == PH_ERR_DATAERR) 4921 *pstat = EX_UNAVAILABLE; 4922 4923 ph_map_lookup_abort: 4924 if (ev != NULL) 4925 sm_clrevent(ev); 4926 4927 /* 4928 ** Close the connection if the timer popped 4929 ** or we got a temporary PH error 4930 */ 4931 4932 if (*pstat == EX_TEMPFAIL) 4933 { 4934 save_errno = errno; 4935 pmap->ph_fastclose = PH_CLOSE_FAST; 4936 ph_map_close(map); 4937 errno = save_errno; 4938 } 4939 4940 if (*pstat == EX_OK) 4941 { 4942 if (tTd(38,20)) 4943 sm_dprintf("ph_map_lookup: %s => %s\n", key, value); 4944 4945 if (bitset(MF_MATCHONLY, map->map_mflags)) 4946 return map_rewrite(map, key, strlen(key), NULL); 4947 else 4948 return map_rewrite(map, value, strlen(value), args); 4949 } 4950 4951 return NULL; 4952 } 4953 #endif /* PH_MAP */ 4954 /* 4955 ** syslog map 4956 */ 4957 4958 #define map_prio map_lockfd /* overload field */ 4959 4960 /* 4961 ** SYSLOG_MAP_PARSEARGS -- check for priority level to syslog messages. 4962 */ 4963 4964 bool 4965 syslog_map_parseargs(map, args) 4966 MAP *map; 4967 char *args; 4968 { 4969 char *p = args; 4970 char *priority = NULL; 4971 4972 /* there is no check whether there is really an argument */ 4973 while (*p != '\0') 4974 { 4975 while (isascii(*p) && isspace(*p)) 4976 p++; 4977 if (*p != '-') 4978 break; 4979 ++p; 4980 if (*p == 'D') 4981 { 4982 map->map_mflags |= MF_DEFER; 4983 ++p; 4984 } 4985 else if (*p == 'S') 4986 { 4987 map->map_spacesub = *++p; 4988 if (*p != '\0') 4989 p++; 4990 } 4991 else if (*p == 'L') 4992 { 4993 while (*++p != '\0' && isascii(*p) && isspace(*p)) 4994 continue; 4995 if (*p == '\0') 4996 break; 4997 priority = p; 4998 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 4999 p++; 5000 if (*p != '\0') 5001 *p++ = '\0'; 5002 } 5003 else 5004 { 5005 syserr("Illegal option %c map syslog", *p); 5006 ++p; 5007 } 5008 } 5009 5010 if (priority == NULL) 5011 map->map_prio = LOG_INFO; 5012 else 5013 { 5014 if (sm_strncasecmp("LOG_", priority, 4) == 0) 5015 priority += 4; 5016 5017 #ifdef LOG_EMERG 5018 if (sm_strcasecmp("EMERG", priority) == 0) 5019 map->map_prio = LOG_EMERG; 5020 else 5021 #endif /* LOG_EMERG */ 5022 #ifdef LOG_ALERT 5023 if (sm_strcasecmp("ALERT", priority) == 0) 5024 map->map_prio = LOG_ALERT; 5025 else 5026 #endif /* LOG_ALERT */ 5027 #ifdef LOG_CRIT 5028 if (sm_strcasecmp("CRIT", priority) == 0) 5029 map->map_prio = LOG_CRIT; 5030 else 5031 #endif /* LOG_CRIT */ 5032 #ifdef LOG_ERR 5033 if (sm_strcasecmp("ERR", priority) == 0) 5034 map->map_prio = LOG_ERR; 5035 else 5036 #endif /* LOG_ERR */ 5037 #ifdef LOG_WARNING 5038 if (sm_strcasecmp("WARNING", priority) == 0) 5039 map->map_prio = LOG_WARNING; 5040 else 5041 #endif /* LOG_WARNING */ 5042 #ifdef LOG_NOTICE 5043 if (sm_strcasecmp("NOTICE", priority) == 0) 5044 map->map_prio = LOG_NOTICE; 5045 else 5046 #endif /* LOG_NOTICE */ 5047 #ifdef LOG_INFO 5048 if (sm_strcasecmp("INFO", priority) == 0) 5049 map->map_prio = LOG_INFO; 5050 else 5051 #endif /* LOG_INFO */ 5052 #ifdef LOG_DEBUG 5053 if (sm_strcasecmp("DEBUG", priority) == 0) 5054 map->map_prio = LOG_DEBUG; 5055 else 5056 #endif /* LOG_DEBUG */ 5057 { 5058 syserr("syslog_map_parseargs: Unknown priority %s", 5059 priority); 5060 return false; 5061 } 5062 } 5063 return true; 5064 } 5065 5066 /* 5067 ** SYSLOG_MAP_LOOKUP -- rewrite and syslog message. Always return empty string 5068 */ 5069 5070 char * 5071 syslog_map_lookup(map, string, args, statp) 5072 MAP *map; 5073 char *string; 5074 char **args; 5075 int *statp; 5076 { 5077 char *ptr = map_rewrite(map, string, strlen(string), args); 5078 5079 if (ptr != NULL) 5080 { 5081 if (tTd(38, 20)) 5082 sm_dprintf("syslog_map_lookup(%s (priority %d): %s\n", 5083 map->map_mname, map->map_prio, ptr); 5084 5085 sm_syslog(map->map_prio, CurEnv->e_id, "%s", ptr); 5086 } 5087 5088 *statp = EX_OK; 5089 return ""; 5090 } 5091 5092 /* 5093 ** HESIOD Modules 5094 */ 5095 5096 #if HESIOD 5097 5098 bool 5099 hes_map_open(map, mode) 5100 MAP *map; 5101 int mode; 5102 { 5103 if (tTd(38, 2)) 5104 sm_dprintf("hes_map_open(%s, %s, %d)\n", 5105 map->map_mname, map->map_file, mode); 5106 5107 if (mode != O_RDONLY) 5108 { 5109 /* issue a pseudo-error message */ 5110 errno = SM_EMAPCANTWRITE; 5111 return false; 5112 } 5113 5114 # ifdef HESIOD_INIT 5115 if (HesiodContext != NULL || hesiod_init(&HesiodContext) == 0) 5116 return true; 5117 5118 if (!bitset(MF_OPTIONAL, map->map_mflags)) 5119 syserr("451 4.3.5 cannot initialize Hesiod map (%s)", 5120 sm_errstring(errno)); 5121 return false; 5122 # else /* HESIOD_INIT */ 5123 if (hes_error() == HES_ER_UNINIT) 5124 hes_init(); 5125 switch (hes_error()) 5126 { 5127 case HES_ER_OK: 5128 case HES_ER_NOTFOUND: 5129 return true; 5130 } 5131 5132 if (!bitset(MF_OPTIONAL, map->map_mflags)) 5133 syserr("451 4.3.5 cannot initialize Hesiod map (%d)", hes_error()); 5134 5135 return false; 5136 # endif /* HESIOD_INIT */ 5137 } 5138 5139 char * 5140 hes_map_lookup(map, name, av, statp) 5141 MAP *map; 5142 char *name; 5143 char **av; 5144 int *statp; 5145 { 5146 char **hp; 5147 5148 if (tTd(38, 20)) 5149 sm_dprintf("hes_map_lookup(%s, %s)\n", map->map_file, name); 5150 5151 if (name[0] == '\\') 5152 { 5153 char *np; 5154 int nl; 5155 int save_errno; 5156 char nbuf[MAXNAME]; 5157 5158 nl = strlen(name); 5159 if (nl < sizeof nbuf - 1) 5160 np = nbuf; 5161 else 5162 np = xalloc(strlen(name) + 2); 5163 np[0] = '\\'; 5164 (void) sm_strlcpy(&np[1], name, (sizeof nbuf) - 1); 5165 # ifdef HESIOD_INIT 5166 hp = hesiod_resolve(HesiodContext, np, map->map_file); 5167 # else /* HESIOD_INIT */ 5168 hp = hes_resolve(np, map->map_file); 5169 # endif /* HESIOD_INIT */ 5170 save_errno = errno; 5171 if (np != nbuf) 5172 sm_free(np); /* XXX */ 5173 errno = save_errno; 5174 } 5175 else 5176 { 5177 # ifdef HESIOD_INIT 5178 hp = hesiod_resolve(HesiodContext, name, map->map_file); 5179 # else /* HESIOD_INIT */ 5180 hp = hes_resolve(name, map->map_file); 5181 # endif /* HESIOD_INIT */ 5182 } 5183 # ifdef HESIOD_INIT 5184 if (hp == NULL || *hp == NULL) 5185 { 5186 switch (errno) 5187 { 5188 case ENOENT: 5189 *statp = EX_NOTFOUND; 5190 break; 5191 case ECONNREFUSED: 5192 *statp = EX_TEMPFAIL; 5193 break; 5194 case EMSGSIZE: 5195 case ENOMEM: 5196 default: 5197 *statp = EX_UNAVAILABLE; 5198 break; 5199 } 5200 if (hp != NULL) 5201 hesiod_free_list(HesiodContext, hp); 5202 return NULL; 5203 } 5204 # else /* HESIOD_INIT */ 5205 if (hp == NULL || hp[0] == NULL) 5206 { 5207 switch (hes_error()) 5208 { 5209 case HES_ER_OK: 5210 *statp = EX_OK; 5211 break; 5212 5213 case HES_ER_NOTFOUND: 5214 *statp = EX_NOTFOUND; 5215 break; 5216 5217 case HES_ER_CONFIG: 5218 *statp = EX_UNAVAILABLE; 5219 break; 5220 5221 case HES_ER_NET: 5222 *statp = EX_TEMPFAIL; 5223 break; 5224 } 5225 return NULL; 5226 } 5227 # endif /* HESIOD_INIT */ 5228 5229 if (bitset(MF_MATCHONLY, map->map_mflags)) 5230 return map_rewrite(map, name, strlen(name), NULL); 5231 else 5232 return map_rewrite(map, hp[0], strlen(hp[0]), av); 5233 } 5234 5235 /* 5236 ** HES_MAP_CLOSE -- free the Hesiod context 5237 */ 5238 5239 void 5240 hes_map_close(map) 5241 MAP *map; 5242 { 5243 if (tTd(38, 20)) 5244 sm_dprintf("hes_map_close(%s)\n", map->map_file); 5245 5246 # ifdef HESIOD_INIT 5247 /* Free the hesiod context */ 5248 if (HesiodContext != NULL) 5249 { 5250 hesiod_end(HesiodContext); 5251 HesiodContext = NULL; 5252 } 5253 # endif /* HESIOD_INIT */ 5254 } 5255 5256 #endif /* HESIOD */ 5257 /* 5258 ** NeXT NETINFO Modules 5259 */ 5260 5261 #if NETINFO 5262 5263 # define NETINFO_DEFAULT_DIR "/aliases" 5264 # define NETINFO_DEFAULT_PROPERTY "members" 5265 5266 /* 5267 ** NI_MAP_OPEN -- open NetInfo Aliases 5268 */ 5269 5270 bool 5271 ni_map_open(map, mode) 5272 MAP *map; 5273 int mode; 5274 { 5275 if (tTd(38, 2)) 5276 sm_dprintf("ni_map_open(%s, %s, %d)\n", 5277 map->map_mname, map->map_file, mode); 5278 mode &= O_ACCMODE; 5279 5280 if (*map->map_file == '\0') 5281 map->map_file = NETINFO_DEFAULT_DIR; 5282 5283 if (map->map_valcolnm == NULL) 5284 map->map_valcolnm = NETINFO_DEFAULT_PROPERTY; 5285 5286 if (map->map_coldelim == '\0') 5287 { 5288 if (bitset(MF_ALIAS, map->map_mflags)) 5289 map->map_coldelim = ','; 5290 else if (bitset(MF_FILECLASS, map->map_mflags)) 5291 map->map_coldelim = ' '; 5292 } 5293 return true; 5294 } 5295 5296 5297 /* 5298 ** NI_MAP_LOOKUP -- look up a datum in NetInfo 5299 */ 5300 5301 char * 5302 ni_map_lookup(map, name, av, statp) 5303 MAP *map; 5304 char *name; 5305 char **av; 5306 int *statp; 5307 { 5308 char *res; 5309 char *propval; 5310 5311 if (tTd(38, 20)) 5312 sm_dprintf("ni_map_lookup(%s, %s)\n", map->map_mname, name); 5313 5314 propval = ni_propval(map->map_file, map->map_keycolnm, name, 5315 map->map_valcolnm, map->map_coldelim); 5316 5317 if (propval == NULL) 5318 return NULL; 5319 5320 SM_TRY 5321 if (bitset(MF_MATCHONLY, map->map_mflags)) 5322 res = map_rewrite(map, name, strlen(name), NULL); 5323 else 5324 res = map_rewrite(map, propval, strlen(propval), av); 5325 SM_FINALLY 5326 sm_free(propval); 5327 SM_END_TRY 5328 return res; 5329 } 5330 5331 5332 static bool 5333 ni_getcanonname(name, hbsize, statp) 5334 char *name; 5335 int hbsize; 5336 int *statp; 5337 { 5338 char *vptr; 5339 char *ptr; 5340 char nbuf[MAXNAME + 1]; 5341 5342 if (tTd(38, 20)) 5343 sm_dprintf("ni_getcanonname(%s)\n", name); 5344 5345 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf) 5346 { 5347 *statp = EX_UNAVAILABLE; 5348 return false; 5349 } 5350 (void) shorten_hostname(nbuf); 5351 5352 /* we only accept single token search key */ 5353 if (strchr(nbuf, '.')) 5354 { 5355 *statp = EX_NOHOST; 5356 return false; 5357 } 5358 5359 /* Do the search */ 5360 vptr = ni_propval("/machines", NULL, nbuf, "name", '\n'); 5361 5362 if (vptr == NULL) 5363 { 5364 *statp = EX_NOHOST; 5365 return false; 5366 } 5367 5368 /* Only want the first machine name */ 5369 if ((ptr = strchr(vptr, '\n')) != NULL) 5370 *ptr = '\0'; 5371 5372 if (sm_strlcpy(name, vptr, hbsize) >= hbsize) 5373 { 5374 sm_free(vptr); 5375 *statp = EX_UNAVAILABLE; 5376 return true; 5377 } 5378 sm_free(vptr); 5379 *statp = EX_OK; 5380 return false; 5381 } 5382 #endif /* NETINFO */ 5383 /* 5384 ** TEXT (unindexed text file) Modules 5385 ** 5386 ** This code donated by Sun Microsystems. 5387 */ 5388 5389 #define map_sff map_lockfd /* overload field */ 5390 5391 5392 /* 5393 ** TEXT_MAP_OPEN -- open text table 5394 */ 5395 5396 bool 5397 text_map_open(map, mode) 5398 MAP *map; 5399 int mode; 5400 { 5401 long sff; 5402 int i; 5403 5404 if (tTd(38, 2)) 5405 sm_dprintf("text_map_open(%s, %s, %d)\n", 5406 map->map_mname, map->map_file, mode); 5407 5408 mode &= O_ACCMODE; 5409 if (mode != O_RDONLY) 5410 { 5411 errno = EPERM; 5412 return false; 5413 } 5414 5415 if (*map->map_file == '\0') 5416 { 5417 syserr("text map \"%s\": file name required", 5418 map->map_mname); 5419 return false; 5420 } 5421 5422 if (map->map_file[0] != '/') 5423 { 5424 syserr("text map \"%s\": file name must be fully qualified", 5425 map->map_mname); 5426 return false; 5427 } 5428 5429 sff = SFF_ROOTOK|SFF_REGONLY; 5430 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail)) 5431 sff |= SFF_NOWLINK; 5432 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail)) 5433 sff |= SFF_SAFEDIRPATH; 5434 if ((i = safefile(map->map_file, RunAsUid, RunAsGid, RunAsUserName, 5435 sff, S_IRUSR, NULL)) != 0) 5436 { 5437 int save_errno = errno; 5438 5439 /* cannot open this map */ 5440 if (tTd(38, 2)) 5441 sm_dprintf("\tunsafe map file: %d\n", i); 5442 errno = save_errno; 5443 if (!bitset(MF_OPTIONAL, map->map_mflags)) 5444 syserr("text map \"%s\": unsafe map file %s", 5445 map->map_mname, map->map_file); 5446 return false; 5447 } 5448 5449 if (map->map_keycolnm == NULL) 5450 map->map_keycolno = 0; 5451 else 5452 { 5453 if (!(isascii(*map->map_keycolnm) && isdigit(*map->map_keycolnm))) 5454 { 5455 syserr("text map \"%s\", file %s: -k should specify a number, not %s", 5456 map->map_mname, map->map_file, 5457 map->map_keycolnm); 5458 return false; 5459 } 5460 map->map_keycolno = atoi(map->map_keycolnm); 5461 } 5462 5463 if (map->map_valcolnm == NULL) 5464 map->map_valcolno = 0; 5465 else 5466 { 5467 if (!(isascii(*map->map_valcolnm) && isdigit(*map->map_valcolnm))) 5468 { 5469 syserr("text map \"%s\", file %s: -v should specify a number, not %s", 5470 map->map_mname, map->map_file, 5471 map->map_valcolnm); 5472 return false; 5473 } 5474 map->map_valcolno = atoi(map->map_valcolnm); 5475 } 5476 5477 if (tTd(38, 2)) 5478 { 5479 sm_dprintf("text_map_open(%s, %s): delimiter = ", 5480 map->map_mname, map->map_file); 5481 if (map->map_coldelim == '\0') 5482 sm_dprintf("(white space)\n"); 5483 else 5484 sm_dprintf("%c\n", map->map_coldelim); 5485 } 5486 5487 map->map_sff = sff; 5488 return true; 5489 } 5490 5491 5492 /* 5493 ** TEXT_MAP_LOOKUP -- look up a datum in a TEXT table 5494 */ 5495 5496 char * 5497 text_map_lookup(map, name, av, statp) 5498 MAP *map; 5499 char *name; 5500 char **av; 5501 int *statp; 5502 { 5503 char *vp; 5504 auto int vsize; 5505 int buflen; 5506 SM_FILE_T *f; 5507 char delim; 5508 int key_idx; 5509 bool found_it; 5510 long sff = map->map_sff; 5511 char search_key[MAXNAME + 1]; 5512 char linebuf[MAXLINE]; 5513 char buf[MAXNAME + 1]; 5514 5515 found_it = false; 5516 if (tTd(38, 20)) 5517 sm_dprintf("text_map_lookup(%s, %s)\n", map->map_mname, name); 5518 5519 buflen = strlen(name); 5520 if (buflen > sizeof search_key - 1) 5521 buflen = sizeof search_key - 1; /* XXX just cut if off? */ 5522 memmove(search_key, name, buflen); 5523 search_key[buflen] = '\0'; 5524 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 5525 makelower(search_key); 5526 5527 f = safefopen(map->map_file, O_RDONLY, FileMode, sff); 5528 if (f == NULL) 5529 { 5530 map->map_mflags &= ~(MF_VALID|MF_OPEN); 5531 *statp = EX_UNAVAILABLE; 5532 return NULL; 5533 } 5534 key_idx = map->map_keycolno; 5535 delim = map->map_coldelim; 5536 while (sm_io_fgets(f, SM_TIME_DEFAULT, 5537 linebuf, sizeof linebuf) != NULL) 5538 { 5539 char *p; 5540 5541 /* skip comment line */ 5542 if (linebuf[0] == '#') 5543 continue; 5544 p = strchr(linebuf, '\n'); 5545 if (p != NULL) 5546 *p = '\0'; 5547 p = get_column(linebuf, key_idx, delim, buf, sizeof buf); 5548 if (p != NULL && sm_strcasecmp(search_key, p) == 0) 5549 { 5550 found_it = true; 5551 break; 5552 } 5553 } 5554 (void) sm_io_close(f, SM_TIME_DEFAULT); 5555 if (!found_it) 5556 { 5557 *statp = EX_NOTFOUND; 5558 return NULL; 5559 } 5560 vp = get_column(linebuf, map->map_valcolno, delim, buf, sizeof buf); 5561 if (vp == NULL) 5562 { 5563 *statp = EX_NOTFOUND; 5564 return NULL; 5565 } 5566 vsize = strlen(vp); 5567 *statp = EX_OK; 5568 if (bitset(MF_MATCHONLY, map->map_mflags)) 5569 return map_rewrite(map, name, strlen(name), NULL); 5570 else 5571 return map_rewrite(map, vp, vsize, av); 5572 } 5573 5574 /* 5575 ** TEXT_GETCANONNAME -- look up canonical name in hosts file 5576 */ 5577 5578 static bool 5579 text_getcanonname(name, hbsize, statp) 5580 char *name; 5581 int hbsize; 5582 int *statp; 5583 { 5584 bool found; 5585 char *dot; 5586 SM_FILE_T *f; 5587 char linebuf[MAXLINE]; 5588 char cbuf[MAXNAME + 1]; 5589 char nbuf[MAXNAME + 1]; 5590 5591 if (tTd(38, 20)) 5592 sm_dprintf("text_getcanonname(%s)\n", name); 5593 5594 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf) 5595 { 5596 *statp = EX_UNAVAILABLE; 5597 return false; 5598 } 5599 dot = shorten_hostname(nbuf); 5600 5601 f = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, HostsFile, SM_IO_RDONLY, 5602 NULL); 5603 if (f == NULL) 5604 { 5605 *statp = EX_UNAVAILABLE; 5606 return false; 5607 } 5608 found = false; 5609 while (!found && 5610 sm_io_fgets(f, SM_TIME_DEFAULT, 5611 linebuf, sizeof linebuf) != NULL) 5612 { 5613 char *p = strpbrk(linebuf, "#\n"); 5614 5615 if (p != NULL) 5616 *p = '\0'; 5617 if (linebuf[0] != '\0') 5618 found = extract_canonname(nbuf, dot, linebuf, 5619 cbuf, sizeof cbuf); 5620 } 5621 (void) sm_io_close(f, SM_TIME_DEFAULT); 5622 if (!found) 5623 { 5624 *statp = EX_NOHOST; 5625 return false; 5626 } 5627 5628 if (sm_strlcpy(name, cbuf, hbsize) >= hbsize) 5629 { 5630 *statp = EX_UNAVAILABLE; 5631 return false; 5632 } 5633 *statp = EX_OK; 5634 return true; 5635 } 5636 /* 5637 ** STAB (Symbol Table) Modules 5638 */ 5639 5640 5641 /* 5642 ** STAB_MAP_LOOKUP -- look up alias in symbol table 5643 */ 5644 5645 /* ARGSUSED2 */ 5646 char * 5647 stab_map_lookup(map, name, av, pstat) 5648 register MAP *map; 5649 char *name; 5650 char **av; 5651 int *pstat; 5652 { 5653 register STAB *s; 5654 5655 if (tTd(38, 20)) 5656 sm_dprintf("stab_lookup(%s, %s)\n", 5657 map->map_mname, name); 5658 5659 s = stab(name, ST_ALIAS, ST_FIND); 5660 if (s == NULL) 5661 return NULL; 5662 if (bitset(MF_MATCHONLY, map->map_mflags)) 5663 return map_rewrite(map, name, strlen(name), NULL); 5664 else 5665 return map_rewrite(map, s->s_alias, strlen(s->s_alias), av); 5666 } 5667 5668 /* 5669 ** STAB_MAP_STORE -- store in symtab (actually using during init, not rebuild) 5670 */ 5671 5672 void 5673 stab_map_store(map, lhs, rhs) 5674 register MAP *map; 5675 char *lhs; 5676 char *rhs; 5677 { 5678 register STAB *s; 5679 5680 s = stab(lhs, ST_ALIAS, ST_ENTER); 5681 s->s_alias = newstr(rhs); 5682 } 5683 5684 5685 /* 5686 ** STAB_MAP_OPEN -- initialize (reads data file) 5687 ** 5688 ** This is a wierd case -- it is only intended as a fallback for 5689 ** aliases. For this reason, opens for write (only during a 5690 ** "newaliases") always fails, and opens for read open the 5691 ** actual underlying text file instead of the database. 5692 */ 5693 5694 bool 5695 stab_map_open(map, mode) 5696 register MAP *map; 5697 int mode; 5698 { 5699 SM_FILE_T *af; 5700 long sff; 5701 struct stat st; 5702 5703 if (tTd(38, 2)) 5704 sm_dprintf("stab_map_open(%s, %s, %d)\n", 5705 map->map_mname, map->map_file, mode); 5706 5707 mode &= O_ACCMODE; 5708 if (mode != O_RDONLY) 5709 { 5710 errno = EPERM; 5711 return false; 5712 } 5713 5714 sff = SFF_ROOTOK|SFF_REGONLY; 5715 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail)) 5716 sff |= SFF_NOWLINK; 5717 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail)) 5718 sff |= SFF_SAFEDIRPATH; 5719 af = safefopen(map->map_file, O_RDONLY, 0444, sff); 5720 if (af == NULL) 5721 return false; 5722 readaliases(map, af, false, false); 5723 5724 if (fstat(sm_io_getinfo(af, SM_IO_WHAT_FD, NULL), &st) >= 0) 5725 map->map_mtime = st.st_mtime; 5726 (void) sm_io_close(af, SM_TIME_DEFAULT); 5727 5728 return true; 5729 } 5730 /* 5731 ** Implicit Modules 5732 ** 5733 ** Tries several types. For back compatibility of aliases. 5734 */ 5735 5736 5737 /* 5738 ** IMPL_MAP_LOOKUP -- lookup in best open database 5739 */ 5740 5741 char * 5742 impl_map_lookup(map, name, av, pstat) 5743 MAP *map; 5744 char *name; 5745 char **av; 5746 int *pstat; 5747 { 5748 if (tTd(38, 20)) 5749 sm_dprintf("impl_map_lookup(%s, %s)\n", 5750 map->map_mname, name); 5751 5752 #if NEWDB 5753 if (bitset(MF_IMPL_HASH, map->map_mflags)) 5754 return db_map_lookup(map, name, av, pstat); 5755 #endif /* NEWDB */ 5756 #if NDBM 5757 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 5758 return ndbm_map_lookup(map, name, av, pstat); 5759 #endif /* NDBM */ 5760 return stab_map_lookup(map, name, av, pstat); 5761 } 5762 5763 /* 5764 ** IMPL_MAP_STORE -- store in open databases 5765 */ 5766 5767 void 5768 impl_map_store(map, lhs, rhs) 5769 MAP *map; 5770 char *lhs; 5771 char *rhs; 5772 { 5773 if (tTd(38, 12)) 5774 sm_dprintf("impl_map_store(%s, %s, %s)\n", 5775 map->map_mname, lhs, rhs); 5776 #if NEWDB 5777 if (bitset(MF_IMPL_HASH, map->map_mflags)) 5778 db_map_store(map, lhs, rhs); 5779 #endif /* NEWDB */ 5780 #if NDBM 5781 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 5782 ndbm_map_store(map, lhs, rhs); 5783 #endif /* NDBM */ 5784 stab_map_store(map, lhs, rhs); 5785 } 5786 5787 /* 5788 ** IMPL_MAP_OPEN -- implicit database open 5789 */ 5790 5791 bool 5792 impl_map_open(map, mode) 5793 MAP *map; 5794 int mode; 5795 { 5796 if (tTd(38, 2)) 5797 sm_dprintf("impl_map_open(%s, %s, %d)\n", 5798 map->map_mname, map->map_file, mode); 5799 5800 mode &= O_ACCMODE; 5801 #if NEWDB 5802 map->map_mflags |= MF_IMPL_HASH; 5803 if (hash_map_open(map, mode)) 5804 { 5805 # ifdef NDBM_YP_COMPAT 5806 if (mode == O_RDONLY || strstr(map->map_file, "/yp/") == NULL) 5807 # endif /* NDBM_YP_COMPAT */ 5808 return true; 5809 } 5810 else 5811 map->map_mflags &= ~MF_IMPL_HASH; 5812 #endif /* NEWDB */ 5813 #if NDBM 5814 map->map_mflags |= MF_IMPL_NDBM; 5815 if (ndbm_map_open(map, mode)) 5816 { 5817 return true; 5818 } 5819 else 5820 map->map_mflags &= ~MF_IMPL_NDBM; 5821 #endif /* NDBM */ 5822 5823 #if defined(NEWDB) || defined(NDBM) 5824 if (Verbose) 5825 message("WARNING: cannot open alias database %s%s", 5826 map->map_file, 5827 mode == O_RDONLY ? "; reading text version" : ""); 5828 #else /* defined(NEWDB) || defined(NDBM) */ 5829 if (mode != O_RDONLY) 5830 usrerr("Cannot rebuild aliases: no database format defined"); 5831 #endif /* defined(NEWDB) || defined(NDBM) */ 5832 5833 if (mode == O_RDONLY) 5834 return stab_map_open(map, mode); 5835 else 5836 return false; 5837 } 5838 5839 5840 /* 5841 ** IMPL_MAP_CLOSE -- close any open database(s) 5842 */ 5843 5844 void 5845 impl_map_close(map) 5846 MAP *map; 5847 { 5848 if (tTd(38, 9)) 5849 sm_dprintf("impl_map_close(%s, %s, %lx)\n", 5850 map->map_mname, map->map_file, map->map_mflags); 5851 #if NEWDB 5852 if (bitset(MF_IMPL_HASH, map->map_mflags)) 5853 { 5854 db_map_close(map); 5855 map->map_mflags &= ~MF_IMPL_HASH; 5856 } 5857 #endif /* NEWDB */ 5858 5859 #if NDBM 5860 if (bitset(MF_IMPL_NDBM, map->map_mflags)) 5861 { 5862 ndbm_map_close(map); 5863 map->map_mflags &= ~MF_IMPL_NDBM; 5864 } 5865 #endif /* NDBM */ 5866 } 5867 /* 5868 ** User map class. 5869 ** 5870 ** Provides access to the system password file. 5871 */ 5872 5873 /* 5874 ** USER_MAP_OPEN -- open user map 5875 ** 5876 ** Really just binds field names to field numbers. 5877 */ 5878 5879 bool 5880 user_map_open(map, mode) 5881 MAP *map; 5882 int mode; 5883 { 5884 if (tTd(38, 2)) 5885 sm_dprintf("user_map_open(%s, %d)\n", 5886 map->map_mname, mode); 5887 5888 mode &= O_ACCMODE; 5889 if (mode != O_RDONLY) 5890 { 5891 /* issue a pseudo-error message */ 5892 errno = SM_EMAPCANTWRITE; 5893 return false; 5894 } 5895 if (map->map_valcolnm == NULL) 5896 /* EMPTY */ 5897 /* nothing */ ; 5898 else if (sm_strcasecmp(map->map_valcolnm, "name") == 0) 5899 map->map_valcolno = 1; 5900 else if (sm_strcasecmp(map->map_valcolnm, "passwd") == 0) 5901 map->map_valcolno = 2; 5902 else if (sm_strcasecmp(map->map_valcolnm, "uid") == 0) 5903 map->map_valcolno = 3; 5904 else if (sm_strcasecmp(map->map_valcolnm, "gid") == 0) 5905 map->map_valcolno = 4; 5906 else if (sm_strcasecmp(map->map_valcolnm, "gecos") == 0) 5907 map->map_valcolno = 5; 5908 else if (sm_strcasecmp(map->map_valcolnm, "dir") == 0) 5909 map->map_valcolno = 6; 5910 else if (sm_strcasecmp(map->map_valcolnm, "shell") == 0) 5911 map->map_valcolno = 7; 5912 else 5913 { 5914 syserr("User map %s: unknown column name %s", 5915 map->map_mname, map->map_valcolnm); 5916 return false; 5917 } 5918 return true; 5919 } 5920 5921 5922 /* 5923 ** USER_MAP_LOOKUP -- look up a user in the passwd file. 5924 */ 5925 5926 /* ARGSUSED3 */ 5927 char * 5928 user_map_lookup(map, key, av, statp) 5929 MAP *map; 5930 char *key; 5931 char **av; 5932 int *statp; 5933 { 5934 auto bool fuzzy; 5935 SM_MBDB_T user; 5936 5937 if (tTd(38, 20)) 5938 sm_dprintf("user_map_lookup(%s, %s)\n", 5939 map->map_mname, key); 5940 5941 *statp = finduser(key, &fuzzy, &user); 5942 if (*statp != EX_OK) 5943 return NULL; 5944 if (bitset(MF_MATCHONLY, map->map_mflags)) 5945 return map_rewrite(map, key, strlen(key), NULL); 5946 else 5947 { 5948 char *rwval = NULL; 5949 char buf[30]; 5950 5951 switch (map->map_valcolno) 5952 { 5953 case 0: 5954 case 1: 5955 rwval = user.mbdb_name; 5956 break; 5957 5958 case 2: 5959 rwval = "x"; /* passwd no longer supported */ 5960 break; 5961 5962 case 3: 5963 (void) sm_snprintf(buf, sizeof buf, "%d", 5964 (int) user.mbdb_uid); 5965 rwval = buf; 5966 break; 5967 5968 case 4: 5969 (void) sm_snprintf(buf, sizeof buf, "%d", 5970 (int) user.mbdb_gid); 5971 rwval = buf; 5972 break; 5973 5974 case 5: 5975 rwval = user.mbdb_fullname; 5976 break; 5977 5978 case 6: 5979 rwval = user.mbdb_homedir; 5980 break; 5981 5982 case 7: 5983 rwval = user.mbdb_shell; 5984 break; 5985 } 5986 return map_rewrite(map, rwval, strlen(rwval), av); 5987 } 5988 } 5989 /* 5990 ** Program map type. 5991 ** 5992 ** This provides access to arbitrary programs. It should be used 5993 ** only very sparingly, since there is no way to bound the cost 5994 ** of invoking an arbitrary program. 5995 */ 5996 5997 char * 5998 prog_map_lookup(map, name, av, statp) 5999 MAP *map; 6000 char *name; 6001 char **av; 6002 int *statp; 6003 { 6004 int i; 6005 int save_errno; 6006 int fd; 6007 int status; 6008 auto pid_t pid; 6009 register char *p; 6010 char *rval; 6011 char *argv[MAXPV + 1]; 6012 char buf[MAXLINE]; 6013 6014 if (tTd(38, 20)) 6015 sm_dprintf("prog_map_lookup(%s, %s) %s\n", 6016 map->map_mname, name, map->map_file); 6017 6018 i = 0; 6019 argv[i++] = map->map_file; 6020 if (map->map_rebuild != NULL) 6021 { 6022 (void) sm_strlcpy(buf, map->map_rebuild, sizeof buf); 6023 for (p = strtok(buf, " \t"); p != NULL; p = strtok(NULL, " \t")) 6024 { 6025 if (i >= MAXPV - 1) 6026 break; 6027 argv[i++] = p; 6028 } 6029 } 6030 argv[i++] = name; 6031 argv[i] = NULL; 6032 if (tTd(38, 21)) 6033 { 6034 sm_dprintf("prog_open:"); 6035 for (i = 0; argv[i] != NULL; i++) 6036 sm_dprintf(" %s", argv[i]); 6037 sm_dprintf("\n"); 6038 } 6039 (void) sm_blocksignal(SIGCHLD); 6040 pid = prog_open(argv, &fd, CurEnv); 6041 if (pid < 0) 6042 { 6043 if (!bitset(MF_OPTIONAL, map->map_mflags)) 6044 syserr("prog_map_lookup(%s) failed (%s) -- closing", 6045 map->map_mname, sm_errstring(errno)); 6046 else if (tTd(38, 9)) 6047 sm_dprintf("prog_map_lookup(%s) failed (%s) -- closing", 6048 map->map_mname, sm_errstring(errno)); 6049 map->map_mflags &= ~(MF_VALID|MF_OPEN); 6050 *statp = EX_OSFILE; 6051 return NULL; 6052 } 6053 i = read(fd, buf, sizeof buf - 1); 6054 if (i < 0) 6055 { 6056 syserr("prog_map_lookup(%s): read error %s", 6057 map->map_mname, sm_errstring(errno)); 6058 rval = NULL; 6059 } 6060 else if (i == 0) 6061 { 6062 if (tTd(38, 20)) 6063 sm_dprintf("prog_map_lookup(%s): empty answer\n", 6064 map->map_mname); 6065 rval = NULL; 6066 } 6067 else 6068 { 6069 buf[i] = '\0'; 6070 p = strchr(buf, '\n'); 6071 if (p != NULL) 6072 *p = '\0'; 6073 6074 /* collect the return value */ 6075 if (bitset(MF_MATCHONLY, map->map_mflags)) 6076 rval = map_rewrite(map, name, strlen(name), NULL); 6077 else 6078 rval = map_rewrite(map, buf, strlen(buf), av); 6079 6080 /* now flush any additional output */ 6081 while ((i = read(fd, buf, sizeof buf)) > 0) 6082 continue; 6083 } 6084 6085 /* wait for the process to terminate */ 6086 (void) close(fd); 6087 status = waitfor(pid); 6088 save_errno = errno; 6089 (void) sm_releasesignal(SIGCHLD); 6090 errno = save_errno; 6091 6092 if (status == -1) 6093 { 6094 syserr("prog_map_lookup(%s): wait error %s", 6095 map->map_mname, sm_errstring(errno)); 6096 *statp = EX_SOFTWARE; 6097 rval = NULL; 6098 } 6099 else if (WIFEXITED(status)) 6100 { 6101 if ((*statp = WEXITSTATUS(status)) != EX_OK) 6102 rval = NULL; 6103 } 6104 else 6105 { 6106 syserr("prog_map_lookup(%s): child died on signal %d", 6107 map->map_mname, status); 6108 *statp = EX_UNAVAILABLE; 6109 rval = NULL; 6110 } 6111 return rval; 6112 } 6113 /* 6114 ** Sequenced map type. 6115 ** 6116 ** Tries each map in order until something matches, much like 6117 ** implicit. Stores go to the first map in the list that can 6118 ** support storing. 6119 ** 6120 ** This is slightly unusual in that there are two interfaces. 6121 ** The "sequence" interface lets you stack maps arbitrarily. 6122 ** The "switch" interface builds a sequence map by looking 6123 ** at a system-dependent configuration file such as 6124 ** /etc/nsswitch.conf on Solaris or /etc/svc.conf on Ultrix. 6125 ** 6126 ** We don't need an explicit open, since all maps are 6127 ** opened on demand. 6128 */ 6129 6130 /* 6131 ** SEQ_MAP_PARSE -- Sequenced map parsing 6132 */ 6133 6134 bool 6135 seq_map_parse(map, ap) 6136 MAP *map; 6137 char *ap; 6138 { 6139 int maxmap; 6140 6141 if (tTd(38, 2)) 6142 sm_dprintf("seq_map_parse(%s, %s)\n", map->map_mname, ap); 6143 maxmap = 0; 6144 while (*ap != '\0') 6145 { 6146 register char *p; 6147 STAB *s; 6148 6149 /* find beginning of map name */ 6150 while (isascii(*ap) && isspace(*ap)) 6151 ap++; 6152 for (p = ap; 6153 (isascii(*p) && isalnum(*p)) || *p == '_' || *p == '.'; 6154 p++) 6155 continue; 6156 if (*p != '\0') 6157 *p++ = '\0'; 6158 while (*p != '\0' && (!isascii(*p) || !isalnum(*p))) 6159 p++; 6160 if (*ap == '\0') 6161 { 6162 ap = p; 6163 continue; 6164 } 6165 s = stab(ap, ST_MAP, ST_FIND); 6166 if (s == NULL) 6167 { 6168 syserr("Sequence map %s: unknown member map %s", 6169 map->map_mname, ap); 6170 } 6171 else if (maxmap >= MAXMAPSTACK) 6172 { 6173 syserr("Sequence map %s: too many member maps (%d max)", 6174 map->map_mname, MAXMAPSTACK); 6175 maxmap++; 6176 } 6177 else if (maxmap < MAXMAPSTACK) 6178 { 6179 map->map_stack[maxmap++] = &s->s_map; 6180 } 6181 ap = p; 6182 } 6183 return true; 6184 } 6185 6186 /* 6187 ** SWITCH_MAP_OPEN -- open a switched map 6188 ** 6189 ** This looks at the system-dependent configuration and builds 6190 ** a sequence map that does the same thing. 6191 ** 6192 ** Every system must define a switch_map_find routine in conf.c 6193 ** that will return the list of service types associated with a 6194 ** given service class. 6195 */ 6196 6197 bool 6198 switch_map_open(map, mode) 6199 MAP *map; 6200 int mode; 6201 { 6202 int mapno; 6203 int nmaps; 6204 char *maptype[MAXMAPSTACK]; 6205 6206 if (tTd(38, 2)) 6207 sm_dprintf("switch_map_open(%s, %s, %d)\n", 6208 map->map_mname, map->map_file, mode); 6209 6210 mode &= O_ACCMODE; 6211 nmaps = switch_map_find(map->map_file, maptype, map->map_return); 6212 if (tTd(38, 19)) 6213 { 6214 sm_dprintf("\tswitch_map_find => %d\n", nmaps); 6215 for (mapno = 0; mapno < nmaps; mapno++) 6216 sm_dprintf("\t\t%s\n", maptype[mapno]); 6217 } 6218 if (nmaps <= 0 || nmaps > MAXMAPSTACK) 6219 return false; 6220 6221 for (mapno = 0; mapno < nmaps; mapno++) 6222 { 6223 register STAB *s; 6224 char nbuf[MAXNAME + 1]; 6225 6226 if (maptype[mapno] == NULL) 6227 continue; 6228 (void) sm_strlcpyn(nbuf, sizeof nbuf, 3, 6229 map->map_mname, ".", maptype[mapno]); 6230 s = stab(nbuf, ST_MAP, ST_FIND); 6231 if (s == NULL) 6232 { 6233 syserr("Switch map %s: unknown member map %s", 6234 map->map_mname, nbuf); 6235 } 6236 else 6237 { 6238 map->map_stack[mapno] = &s->s_map; 6239 if (tTd(38, 4)) 6240 sm_dprintf("\tmap_stack[%d] = %s:%s\n", 6241 mapno, 6242 s->s_map.map_class->map_cname, 6243 nbuf); 6244 } 6245 } 6246 return true; 6247 } 6248 6249 #if 0 6250 /* 6251 ** SEQ_MAP_CLOSE -- close all underlying maps 6252 */ 6253 6254 void 6255 seq_map_close(map) 6256 MAP *map; 6257 { 6258 int mapno; 6259 6260 if (tTd(38, 9)) 6261 sm_dprintf("seq_map_close(%s)\n", map->map_mname); 6262 6263 for (mapno = 0; mapno < MAXMAPSTACK; mapno++) 6264 { 6265 MAP *mm = map->map_stack[mapno]; 6266 6267 if (mm == NULL || !bitset(MF_OPEN, mm->map_mflags)) 6268 continue; 6269 mm->map_mflags |= MF_CLOSING; 6270 mm->map_class->map_close(mm); 6271 mm->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING); 6272 } 6273 } 6274 #endif /* 0 */ 6275 6276 /* 6277 ** SEQ_MAP_LOOKUP -- sequenced map lookup 6278 */ 6279 6280 char * 6281 seq_map_lookup(map, key, args, pstat) 6282 MAP *map; 6283 char *key; 6284 char **args; 6285 int *pstat; 6286 { 6287 int mapno; 6288 int mapbit = 0x01; 6289 bool tempfail = false; 6290 6291 if (tTd(38, 20)) 6292 sm_dprintf("seq_map_lookup(%s, %s)\n", map->map_mname, key); 6293 6294 for (mapno = 0; mapno < MAXMAPSTACK; mapbit <<= 1, mapno++) 6295 { 6296 MAP *mm = map->map_stack[mapno]; 6297 char *rv; 6298 6299 if (mm == NULL) 6300 continue; 6301 if (!bitset(MF_OPEN, mm->map_mflags) && 6302 !openmap(mm)) 6303 { 6304 if (bitset(mapbit, map->map_return[MA_UNAVAIL])) 6305 { 6306 *pstat = EX_UNAVAILABLE; 6307 return NULL; 6308 } 6309 continue; 6310 } 6311 *pstat = EX_OK; 6312 rv = mm->map_class->map_lookup(mm, key, args, pstat); 6313 if (rv != NULL) 6314 return rv; 6315 if (*pstat == EX_TEMPFAIL) 6316 { 6317 if (bitset(mapbit, map->map_return[MA_TRYAGAIN])) 6318 return NULL; 6319 tempfail = true; 6320 } 6321 else if (bitset(mapbit, map->map_return[MA_NOTFOUND])) 6322 break; 6323 } 6324 if (tempfail) 6325 *pstat = EX_TEMPFAIL; 6326 else if (*pstat == EX_OK) 6327 *pstat = EX_NOTFOUND; 6328 return NULL; 6329 } 6330 6331 /* 6332 ** SEQ_MAP_STORE -- sequenced map store 6333 */ 6334 6335 void 6336 seq_map_store(map, key, val) 6337 MAP *map; 6338 char *key; 6339 char *val; 6340 { 6341 int mapno; 6342 6343 if (tTd(38, 12)) 6344 sm_dprintf("seq_map_store(%s, %s, %s)\n", 6345 map->map_mname, key, val); 6346 6347 for (mapno = 0; mapno < MAXMAPSTACK; mapno++) 6348 { 6349 MAP *mm = map->map_stack[mapno]; 6350 6351 if (mm == NULL || !bitset(MF_WRITABLE, mm->map_mflags)) 6352 continue; 6353 6354 mm->map_class->map_store(mm, key, val); 6355 return; 6356 } 6357 syserr("seq_map_store(%s, %s, %s): no writable map", 6358 map->map_mname, key, val); 6359 } 6360 /* 6361 ** NULL stubs 6362 */ 6363 6364 /* ARGSUSED */ 6365 bool 6366 null_map_open(map, mode) 6367 MAP *map; 6368 int mode; 6369 { 6370 return true; 6371 } 6372 6373 /* ARGSUSED */ 6374 void 6375 null_map_close(map) 6376 MAP *map; 6377 { 6378 return; 6379 } 6380 6381 char * 6382 null_map_lookup(map, key, args, pstat) 6383 MAP *map; 6384 char *key; 6385 char **args; 6386 int *pstat; 6387 { 6388 *pstat = EX_NOTFOUND; 6389 return NULL; 6390 } 6391 6392 /* ARGSUSED */ 6393 void 6394 null_map_store(map, key, val) 6395 MAP *map; 6396 char *key; 6397 char *val; 6398 { 6399 return; 6400 } 6401 6402 /* 6403 ** BOGUS stubs 6404 */ 6405 6406 char * 6407 bogus_map_lookup(map, key, args, pstat) 6408 MAP *map; 6409 char *key; 6410 char **args; 6411 int *pstat; 6412 { 6413 *pstat = EX_TEMPFAIL; 6414 return NULL; 6415 } 6416 6417 MAPCLASS BogusMapClass = 6418 { 6419 "bogus-map", NULL, 0, 6420 NULL, bogus_map_lookup, null_map_store, 6421 null_map_open, null_map_close, 6422 }; 6423 /* 6424 ** MACRO modules 6425 */ 6426 6427 char * 6428 macro_map_lookup(map, name, av, statp) 6429 MAP *map; 6430 char *name; 6431 char **av; 6432 int *statp; 6433 { 6434 int mid; 6435 6436 if (tTd(38, 20)) 6437 sm_dprintf("macro_map_lookup(%s, %s)\n", map->map_mname, 6438 name == NULL ? "NULL" : name); 6439 6440 if (name == NULL || 6441 *name == '\0' || 6442 (mid = macid(name)) == 0) 6443 { 6444 *statp = EX_CONFIG; 6445 return NULL; 6446 } 6447 6448 if (av[1] == NULL) 6449 macdefine(&CurEnv->e_macro, A_PERM, mid, NULL); 6450 else 6451 macdefine(&CurEnv->e_macro, A_TEMP, mid, av[1]); 6452 6453 *statp = EX_OK; 6454 return ""; 6455 } 6456 /* 6457 ** REGEX modules 6458 */ 6459 6460 #if MAP_REGEX 6461 6462 # include <regex.h> 6463 6464 # define DEFAULT_DELIM CONDELSE 6465 # define END_OF_FIELDS -1 6466 # define ERRBUF_SIZE 80 6467 # define MAX_MATCH 32 6468 6469 # define xnalloc(s) memset(xalloc(s), '\0', s); 6470 6471 struct regex_map 6472 { 6473 regex_t *regex_pattern_buf; /* xalloc it */ 6474 int *regex_subfields; /* move to type MAP */ 6475 char *regex_delim; /* move to type MAP */ 6476 }; 6477 6478 static int parse_fields __P((char *, int *, int, int)); 6479 static char *regex_map_rewrite __P((MAP *, const char*, size_t, char **)); 6480 6481 static int 6482 parse_fields(s, ibuf, blen, nr_substrings) 6483 char *s; 6484 int *ibuf; /* array */ 6485 int blen; /* number of elements in ibuf */ 6486 int nr_substrings; /* number of substrings in the pattern */ 6487 { 6488 register char *cp; 6489 int i = 0; 6490 bool lastone = false; 6491 6492 blen--; /* for terminating END_OF_FIELDS */ 6493 cp = s; 6494 do 6495 { 6496 for (;; cp++) 6497 { 6498 if (*cp == ',') 6499 { 6500 *cp = '\0'; 6501 break; 6502 } 6503 if (*cp == '\0') 6504 { 6505 lastone = true; 6506 break; 6507 } 6508 } 6509 if (i < blen) 6510 { 6511 int val = atoi(s); 6512 6513 if (val < 0 || val >= nr_substrings) 6514 { 6515 syserr("field (%d) out of range, only %d substrings in pattern", 6516 val, nr_substrings); 6517 return -1; 6518 } 6519 ibuf[i++] = val; 6520 } 6521 else 6522 { 6523 syserr("too many fields, %d max", blen); 6524 return -1; 6525 } 6526 s = ++cp; 6527 } while (!lastone); 6528 ibuf[i] = END_OF_FIELDS; 6529 return i; 6530 } 6531 6532 bool 6533 regex_map_init(map, ap) 6534 MAP *map; 6535 char *ap; 6536 { 6537 int regerr; 6538 struct regex_map *map_p; 6539 register char *p; 6540 char *sub_param = NULL; 6541 int pflags; 6542 static char defdstr[] = { (char) DEFAULT_DELIM, '\0' }; 6543 6544 if (tTd(38, 2)) 6545 sm_dprintf("regex_map_init: mapname '%s', args '%s'\n", 6546 map->map_mname, ap); 6547 6548 pflags = REG_ICASE | REG_EXTENDED | REG_NOSUB; 6549 p = ap; 6550 map_p = (struct regex_map *) xnalloc(sizeof *map_p); 6551 map_p->regex_pattern_buf = (regex_t *)xnalloc(sizeof(regex_t)); 6552 6553 for (;;) 6554 { 6555 while (isascii(*p) && isspace(*p)) 6556 p++; 6557 if (*p != '-') 6558 break; 6559 switch (*++p) 6560 { 6561 case 'n': /* not */ 6562 map->map_mflags |= MF_REGEX_NOT; 6563 break; 6564 6565 case 'f': /* case sensitive */ 6566 map->map_mflags |= MF_NOFOLDCASE; 6567 pflags &= ~REG_ICASE; 6568 break; 6569 6570 case 'b': /* basic regular expressions */ 6571 pflags &= ~REG_EXTENDED; 6572 break; 6573 6574 case 's': /* substring match () syntax */ 6575 sub_param = ++p; 6576 pflags &= ~REG_NOSUB; 6577 break; 6578 6579 case 'd': /* delimiter */ 6580 map_p->regex_delim = ++p; 6581 break; 6582 6583 case 'a': /* map append */ 6584 map->map_app = ++p; 6585 break; 6586 6587 case 'm': /* matchonly */ 6588 map->map_mflags |= MF_MATCHONLY; 6589 break; 6590 6591 case 'q': 6592 map->map_mflags |= MF_KEEPQUOTES; 6593 break; 6594 6595 case 'S': 6596 map->map_spacesub = *++p; 6597 break; 6598 6599 case 'D': 6600 map->map_mflags |= MF_DEFER; 6601 break; 6602 6603 } 6604 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 6605 p++; 6606 if (*p != '\0') 6607 *p++ = '\0'; 6608 } 6609 if (tTd(38, 3)) 6610 sm_dprintf("regex_map_init: compile '%s' 0x%x\n", p, pflags); 6611 6612 if ((regerr = regcomp(map_p->regex_pattern_buf, p, pflags)) != 0) 6613 { 6614 /* Errorhandling */ 6615 char errbuf[ERRBUF_SIZE]; 6616 6617 (void) regerror(regerr, map_p->regex_pattern_buf, 6618 errbuf, sizeof errbuf); 6619 syserr("pattern-compile-error: %s", errbuf); 6620 sm_free(map_p->regex_pattern_buf); /* XXX */ 6621 sm_free(map_p); /* XXX */ 6622 return false; 6623 } 6624 6625 if (map->map_app != NULL) 6626 map->map_app = newstr(map->map_app); 6627 if (map_p->regex_delim != NULL) 6628 map_p->regex_delim = newstr(map_p->regex_delim); 6629 else 6630 map_p->regex_delim = defdstr; 6631 6632 if (!bitset(REG_NOSUB, pflags)) 6633 { 6634 /* substring matching */ 6635 int substrings; 6636 int *fields = (int *) xalloc(sizeof(int) * (MAX_MATCH + 1)); 6637 6638 substrings = map_p->regex_pattern_buf->re_nsub + 1; 6639 6640 if (tTd(38, 3)) 6641 sm_dprintf("regex_map_init: nr of substrings %d\n", 6642 substrings); 6643 6644 if (substrings >= MAX_MATCH) 6645 { 6646 syserr("too many substrings, %d max", MAX_MATCH); 6647 sm_free(map_p->regex_pattern_buf); /* XXX */ 6648 sm_free(map_p); /* XXX */ 6649 return false; 6650 } 6651 if (sub_param != NULL && sub_param[0] != '\0') 6652 { 6653 /* optional parameter -sfields */ 6654 if (parse_fields(sub_param, fields, 6655 MAX_MATCH + 1, substrings) == -1) 6656 return false; 6657 } 6658 else 6659 { 6660 int i; 6661 6662 /* set default fields */ 6663 for (i = 0; i < substrings; i++) 6664 fields[i] = i; 6665 fields[i] = END_OF_FIELDS; 6666 } 6667 map_p->regex_subfields = fields; 6668 if (tTd(38, 3)) 6669 { 6670 int *ip; 6671 6672 sm_dprintf("regex_map_init: subfields"); 6673 for (ip = fields; *ip != END_OF_FIELDS; ip++) 6674 sm_dprintf(" %d", *ip); 6675 sm_dprintf("\n"); 6676 } 6677 } 6678 map->map_db1 = (ARBPTR_T) map_p; /* dirty hack */ 6679 return true; 6680 } 6681 6682 static char * 6683 regex_map_rewrite(map, s, slen, av) 6684 MAP *map; 6685 const char *s; 6686 size_t slen; 6687 char **av; 6688 { 6689 if (bitset(MF_MATCHONLY, map->map_mflags)) 6690 return map_rewrite(map, av[0], strlen(av[0]), NULL); 6691 else 6692 return map_rewrite(map, s, slen, av); 6693 } 6694 6695 char * 6696 regex_map_lookup(map, name, av, statp) 6697 MAP *map; 6698 char *name; 6699 char **av; 6700 int *statp; 6701 { 6702 int reg_res; 6703 struct regex_map *map_p; 6704 regmatch_t pmatch[MAX_MATCH]; 6705 6706 if (tTd(38, 20)) 6707 { 6708 char **cpp; 6709 6710 sm_dprintf("regex_map_lookup: key '%s'\n", name); 6711 for (cpp = av; cpp != NULL && *cpp != NULL; cpp++) 6712 sm_dprintf("regex_map_lookup: arg '%s'\n", *cpp); 6713 } 6714 6715 map_p = (struct regex_map *)(map->map_db1); 6716 reg_res = regexec(map_p->regex_pattern_buf, 6717 name, MAX_MATCH, pmatch, 0); 6718 6719 if (bitset(MF_REGEX_NOT, map->map_mflags)) 6720 { 6721 /* option -n */ 6722 if (reg_res == REG_NOMATCH) 6723 return regex_map_rewrite(map, "", (size_t) 0, av); 6724 else 6725 return NULL; 6726 } 6727 if (reg_res == REG_NOMATCH) 6728 return NULL; 6729 6730 if (map_p->regex_subfields != NULL) 6731 { 6732 /* option -s */ 6733 static char retbuf[MAXNAME]; 6734 int fields[MAX_MATCH + 1]; 6735 bool first = true; 6736 int anglecnt = 0, cmntcnt = 0, spacecnt = 0; 6737 bool quotemode = false, bslashmode = false; 6738 register char *dp, *sp; 6739 char *endp, *ldp; 6740 int *ip; 6741 6742 dp = retbuf; 6743 ldp = retbuf + sizeof(retbuf) - 1; 6744 6745 if (av[1] != NULL) 6746 { 6747 if (parse_fields(av[1], fields, MAX_MATCH + 1, 6748 (int) map_p->regex_pattern_buf->re_nsub + 1) == -1) 6749 { 6750 *statp = EX_CONFIG; 6751 return NULL; 6752 } 6753 ip = fields; 6754 } 6755 else 6756 ip = map_p->regex_subfields; 6757 6758 for ( ; *ip != END_OF_FIELDS; ip++) 6759 { 6760 if (!first) 6761 { 6762 for (sp = map_p->regex_delim; *sp; sp++) 6763 { 6764 if (dp < ldp) 6765 *dp++ = *sp; 6766 } 6767 } 6768 else 6769 first = false; 6770 6771 if (*ip >= MAX_MATCH || 6772 pmatch[*ip].rm_so < 0 || pmatch[*ip].rm_eo < 0) 6773 continue; 6774 6775 sp = name + pmatch[*ip].rm_so; 6776 endp = name + pmatch[*ip].rm_eo; 6777 for (; endp > sp; sp++) 6778 { 6779 if (dp < ldp) 6780 { 6781 if (bslashmode) 6782 { 6783 *dp++ = *sp; 6784 bslashmode = false; 6785 } 6786 else if (quotemode && *sp != '"' && 6787 *sp != '\\') 6788 { 6789 *dp++ = *sp; 6790 } 6791 else switch (*dp++ = *sp) 6792 { 6793 case '\\': 6794 bslashmode = true; 6795 break; 6796 6797 case '(': 6798 cmntcnt++; 6799 break; 6800 6801 case ')': 6802 cmntcnt--; 6803 break; 6804 6805 case '<': 6806 anglecnt++; 6807 break; 6808 6809 case '>': 6810 anglecnt--; 6811 break; 6812 6813 case ' ': 6814 spacecnt++; 6815 break; 6816 6817 case '"': 6818 quotemode = !quotemode; 6819 break; 6820 } 6821 } 6822 } 6823 } 6824 if (anglecnt != 0 || cmntcnt != 0 || quotemode || 6825 bslashmode || spacecnt != 0) 6826 { 6827 sm_syslog(LOG_WARNING, NOQID, 6828 "Warning: regex may cause prescan() failure map=%s lookup=%s", 6829 map->map_mname, name); 6830 return NULL; 6831 } 6832 6833 *dp = '\0'; 6834 6835 return regex_map_rewrite(map, retbuf, strlen(retbuf), av); 6836 } 6837 return regex_map_rewrite(map, "", (size_t)0, av); 6838 } 6839 #endif /* MAP_REGEX */ 6840 /* 6841 ** NSD modules 6842 */ 6843 #if MAP_NSD 6844 6845 # include <ndbm.h> 6846 # define _DATUM_DEFINED 6847 # include <ns_api.h> 6848 6849 typedef struct ns_map_list 6850 { 6851 ns_map_t *map; /* XXX ns_ ? */ 6852 char *mapname; 6853 struct ns_map_list *next; 6854 } ns_map_list_t; 6855 6856 static ns_map_t * 6857 ns_map_t_find(mapname) 6858 char *mapname; 6859 { 6860 static ns_map_list_t *ns_maps = NULL; 6861 ns_map_list_t *ns_map; 6862 6863 /* walk the list of maps looking for the correctly named map */ 6864 for (ns_map = ns_maps; ns_map != NULL; ns_map = ns_map->next) 6865 { 6866 if (strcmp(ns_map->mapname, mapname) == 0) 6867 break; 6868 } 6869 6870 /* if we are looking at a NULL ns_map_list_t, then create a new one */ 6871 if (ns_map == NULL) 6872 { 6873 ns_map = (ns_map_list_t *) xalloc(sizeof *ns_map); 6874 ns_map->mapname = newstr(mapname); 6875 ns_map->map = (ns_map_t *) xalloc(sizeof *ns_map->map); 6876 memset(ns_map->map, '\0', sizeof *ns_map->map); 6877 ns_map->next = ns_maps; 6878 ns_maps = ns_map; 6879 } 6880 return ns_map->map; 6881 } 6882 6883 char * 6884 nsd_map_lookup(map, name, av, statp) 6885 MAP *map; 6886 char *name; 6887 char **av; 6888 int *statp; 6889 { 6890 int buflen, r; 6891 char *p; 6892 ns_map_t *ns_map; 6893 char keybuf[MAXNAME + 1]; 6894 char buf[MAXLINE]; 6895 6896 if (tTd(38, 20)) 6897 sm_dprintf("nsd_map_lookup(%s, %s)\n", map->map_mname, name); 6898 6899 buflen = strlen(name); 6900 if (buflen > sizeof keybuf - 1) 6901 buflen = sizeof keybuf - 1; /* XXX simply cut off? */ 6902 memmove(keybuf, name, buflen); 6903 keybuf[buflen] = '\0'; 6904 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 6905 makelower(keybuf); 6906 6907 ns_map = ns_map_t_find(map->map_file); 6908 if (ns_map == NULL) 6909 { 6910 if (tTd(38, 20)) 6911 sm_dprintf("nsd_map_t_find failed\n"); 6912 *statp = EX_UNAVAILABLE; 6913 return NULL; 6914 } 6915 r = ns_lookup(ns_map, NULL, map->map_file, keybuf, NULL, 6916 buf, sizeof buf); 6917 if (r == NS_UNAVAIL || r == NS_TRYAGAIN) 6918 { 6919 *statp = EX_TEMPFAIL; 6920 return NULL; 6921 } 6922 if (r == NS_BADREQ 6923 # ifdef NS_NOPERM 6924 || r == NS_NOPERM 6925 # endif /* NS_NOPERM */ 6926 ) 6927 { 6928 *statp = EX_CONFIG; 6929 return NULL; 6930 } 6931 if (r != NS_SUCCESS) 6932 { 6933 *statp = EX_NOTFOUND; 6934 return NULL; 6935 } 6936 6937 *statp = EX_OK; 6938 6939 /* Null out trailing \n */ 6940 if ((p = strchr(buf, '\n')) != NULL) 6941 *p = '\0'; 6942 6943 return map_rewrite(map, buf, strlen(buf), av); 6944 } 6945 #endif /* MAP_NSD */ 6946 6947 char * 6948 arith_map_lookup(map, name, av, statp) 6949 MAP *map; 6950 char *name; 6951 char **av; 6952 int *statp; 6953 { 6954 long r; 6955 long v[2]; 6956 bool res = false; 6957 bool boolres; 6958 static char result[16]; 6959 char **cpp; 6960 6961 if (tTd(38, 2)) 6962 { 6963 sm_dprintf("arith_map_lookup: key '%s'\n", name); 6964 for (cpp = av; cpp != NULL && *cpp != NULL; cpp++) 6965 sm_dprintf("arith_map_lookup: arg '%s'\n", *cpp); 6966 } 6967 r = 0; 6968 boolres = false; 6969 cpp = av; 6970 *statp = EX_OK; 6971 6972 /* 6973 ** read arguments for arith map 6974 ** - no check is made whether they are really numbers 6975 ** - just ignores args after the second 6976 */ 6977 6978 for (++cpp; cpp != NULL && *cpp != NULL && r < 2; cpp++) 6979 v[r++] = strtol(*cpp, NULL, 0); 6980 6981 /* operator and (at least) two operands given? */ 6982 if (name != NULL && r == 2) 6983 { 6984 switch (*name) 6985 { 6986 case '|': 6987 r = v[0] | v[1]; 6988 break; 6989 6990 case '&': 6991 r = v[0] & v[1]; 6992 break; 6993 6994 case '%': 6995 if (v[1] == 0) 6996 return NULL; 6997 r = v[0] % v[1]; 6998 break; 6999 case '+': 7000 r = v[0] + v[1]; 7001 break; 7002 7003 case '-': 7004 r = v[0] - v[1]; 7005 break; 7006 7007 case '*': 7008 r = v[0] * v[1]; 7009 break; 7010 7011 case '/': 7012 if (v[1] == 0) 7013 return NULL; 7014 r = v[0] / v[1]; 7015 break; 7016 7017 case 'l': 7018 res = v[0] < v[1]; 7019 boolres = true; 7020 break; 7021 7022 case '=': 7023 res = v[0] == v[1]; 7024 boolres = true; 7025 break; 7026 7027 default: 7028 /* XXX */ 7029 *statp = EX_CONFIG; 7030 if (LogLevel > 10) 7031 sm_syslog(LOG_WARNING, NOQID, 7032 "arith_map: unknown operator %c", 7033 isprint(*name) ? *name : '?'); 7034 return NULL; 7035 } 7036 if (boolres) 7037 (void) sm_snprintf(result, sizeof result, 7038 res ? "TRUE" : "FALSE"); 7039 else 7040 (void) sm_snprintf(result, sizeof result, "%ld", r); 7041 return result; 7042 } 7043 *statp = EX_CONFIG; 7044 return NULL; 7045 } 7046 7047 #if SOCKETMAP 7048 7049 # if NETINET || NETINET6 7050 # include <arpa/inet.h> 7051 # endif /* NETINET || NETINET6 */ 7052 7053 # define socket_map_next map_stack[0] 7054 7055 /* 7056 ** SOCKET_MAP_OPEN -- open socket table 7057 */ 7058 7059 bool 7060 socket_map_open(map, mode) 7061 MAP *map; 7062 int mode; 7063 { 7064 STAB *s; 7065 int sock = 0; 7066 SOCKADDR_LEN_T addrlen = 0; 7067 int addrno = 0; 7068 int save_errno; 7069 char *p; 7070 char *colon; 7071 char *at; 7072 struct hostent *hp = NULL; 7073 SOCKADDR addr; 7074 7075 if (tTd(38, 2)) 7076 sm_dprintf("socket_map_open(%s, %s, %d)\n", 7077 map->map_mname, map->map_file, mode); 7078 7079 mode &= O_ACCMODE; 7080 7081 /* sendmail doesn't have the ability to write to SOCKET (yet) */ 7082 if (mode != O_RDONLY) 7083 { 7084 /* issue a pseudo-error message */ 7085 errno = SM_EMAPCANTWRITE; 7086 return false; 7087 } 7088 7089 if (*map->map_file == '\0') 7090 { 7091 syserr("socket map \"%s\": empty or missing socket information", 7092 map->map_mname); 7093 return false; 7094 } 7095 7096 s = socket_map_findconn(map->map_file); 7097 if (s->s_socketmap != NULL) 7098 { 7099 /* Copy open connection */ 7100 map->map_db1 = s->s_socketmap->map_db1; 7101 7102 /* Add this map as head of linked list */ 7103 map->socket_map_next = s->s_socketmap; 7104 s->s_socketmap = map; 7105 7106 if (tTd(38, 2)) 7107 sm_dprintf("using cached connection\n"); 7108 return true; 7109 } 7110 7111 if (tTd(38, 2)) 7112 sm_dprintf("opening new connection\n"); 7113 7114 /* following code is ripped from milter.c */ 7115 /* XXX It should be put in a library... */ 7116 7117 /* protocol:filename or protocol:port@host */ 7118 memset(&addr, '\0', sizeof addr); 7119 p = map->map_file; 7120 colon = strchr(p, ':'); 7121 if (colon != NULL) 7122 { 7123 *colon = '\0'; 7124 7125 if (*p == '\0') 7126 { 7127 # if NETUNIX 7128 /* default to AF_UNIX */ 7129 addr.sa.sa_family = AF_UNIX; 7130 # else /* NETUNIX */ 7131 # if NETINET 7132 /* default to AF_INET */ 7133 addr.sa.sa_family = AF_INET; 7134 # else /* NETINET */ 7135 # if NETINET6 7136 /* default to AF_INET6 */ 7137 addr.sa.sa_family = AF_INET6; 7138 # else /* NETINET6 */ 7139 /* no protocols available */ 7140 syserr("socket map \"%s\": no valid socket protocols available", 7141 map->map_mname); 7142 return false; 7143 # endif /* NETINET6 */ 7144 # endif /* NETINET */ 7145 # endif /* NETUNIX */ 7146 } 7147 # if NETUNIX 7148 else if (sm_strcasecmp(p, "unix") == 0 || 7149 sm_strcasecmp(p, "local") == 0) 7150 addr.sa.sa_family = AF_UNIX; 7151 # endif /* NETUNIX */ 7152 # if NETINET 7153 else if (sm_strcasecmp(p, "inet") == 0) 7154 addr.sa.sa_family = AF_INET; 7155 # endif /* NETINET */ 7156 # if NETINET6 7157 else if (sm_strcasecmp(p, "inet6") == 0) 7158 addr.sa.sa_family = AF_INET6; 7159 # endif /* NETINET6 */ 7160 else 7161 { 7162 # ifdef EPROTONOSUPPORT 7163 errno = EPROTONOSUPPORT; 7164 # else /* EPROTONOSUPPORT */ 7165 errno = EINVAL; 7166 # endif /* EPROTONOSUPPORT */ 7167 syserr("socket map \"%s\": unknown socket type %s", 7168 map->map_mname, p); 7169 return false; 7170 } 7171 *colon++ = ':'; 7172 } 7173 else 7174 { 7175 colon = p; 7176 #if NETUNIX 7177 /* default to AF_UNIX */ 7178 addr.sa.sa_family = AF_UNIX; 7179 #else /* NETUNIX */ 7180 # if NETINET 7181 /* default to AF_INET */ 7182 addr.sa.sa_family = AF_INET; 7183 # else /* NETINET */ 7184 # if NETINET6 7185 /* default to AF_INET6 */ 7186 addr.sa.sa_family = AF_INET6; 7187 # else /* NETINET6 */ 7188 syserr("socket map \"%s\": unknown socket type %s", 7189 map->map_mname, p); 7190 return false; 7191 # endif /* NETINET6 */ 7192 # endif /* NETINET */ 7193 #endif /* NETUNIX */ 7194 } 7195 7196 # if NETUNIX 7197 if (addr.sa.sa_family == AF_UNIX) 7198 { 7199 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK; 7200 7201 at = colon; 7202 if (strlen(colon) >= sizeof addr.sunix.sun_path) 7203 { 7204 syserr("socket map \"%s\": local socket name %s too long", 7205 map->map_mname, colon); 7206 return false; 7207 } 7208 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff, 7209 S_IRUSR|S_IWUSR, NULL); 7210 7211 if (errno != 0) 7212 { 7213 /* if not safe, don't create */ 7214 syserr("socket map \"%s\": local socket name %s unsafe", 7215 map->map_mname, colon); 7216 return false; 7217 } 7218 7219 (void) sm_strlcpy(addr.sunix.sun_path, colon, 7220 sizeof addr.sunix.sun_path); 7221 addrlen = sizeof (struct sockaddr_un); 7222 } 7223 else 7224 # endif /* NETUNIX */ 7225 # if NETINET || NETINET6 7226 if (false 7227 # if NETINET 7228 || addr.sa.sa_family == AF_INET 7229 # endif /* NETINET */ 7230 # if NETINET6 7231 || addr.sa.sa_family == AF_INET6 7232 # endif /* NETINET6 */ 7233 ) 7234 { 7235 unsigned short port; 7236 7237 /* Parse port@host */ 7238 at = strchr(colon, '@'); 7239 if (at == NULL) 7240 { 7241 syserr("socket map \"%s\": bad address %s (expected port@host)", 7242 map->map_mname, colon); 7243 return false; 7244 } 7245 *at = '\0'; 7246 if (isascii(*colon) && isdigit(*colon)) 7247 port = htons((unsigned short) atoi(colon)); 7248 else 7249 { 7250 # ifdef NO_GETSERVBYNAME 7251 syserr("socket map \"%s\": invalid port number %s", 7252 map->map_mname, colon); 7253 return false; 7254 # else /* NO_GETSERVBYNAME */ 7255 register struct servent *sp; 7256 7257 sp = getservbyname(colon, "tcp"); 7258 if (sp == NULL) 7259 { 7260 syserr("socket map \"%s\": unknown port name %s", 7261 map->map_mname, colon); 7262 return false; 7263 } 7264 port = sp->s_port; 7265 # endif /* NO_GETSERVBYNAME */ 7266 } 7267 *at++ = '@'; 7268 if (*at == '[') 7269 { 7270 char *end; 7271 7272 end = strchr(at, ']'); 7273 if (end != NULL) 7274 { 7275 bool found = false; 7276 # if NETINET 7277 unsigned long hid = INADDR_NONE; 7278 # endif /* NETINET */ 7279 # if NETINET6 7280 struct sockaddr_in6 hid6; 7281 # endif /* NETINET6 */ 7282 7283 *end = '\0'; 7284 # if NETINET 7285 if (addr.sa.sa_family == AF_INET && 7286 (hid = inet_addr(&at[1])) != INADDR_NONE) 7287 { 7288 addr.sin.sin_addr.s_addr = hid; 7289 addr.sin.sin_port = port; 7290 found = true; 7291 } 7292 # endif /* NETINET */ 7293 # if NETINET6 7294 (void) memset(&hid6, '\0', sizeof hid6); 7295 if (addr.sa.sa_family == AF_INET6 && 7296 anynet_pton(AF_INET6, &at[1], 7297 &hid6.sin6_addr) == 1) 7298 { 7299 addr.sin6.sin6_addr = hid6.sin6_addr; 7300 addr.sin6.sin6_port = port; 7301 found = true; 7302 } 7303 # endif /* NETINET6 */ 7304 *end = ']'; 7305 if (!found) 7306 { 7307 syserr("socket map \"%s\": Invalid numeric domain spec \"%s\"", 7308 map->map_mname, at); 7309 return false; 7310 } 7311 } 7312 else 7313 { 7314 syserr("socket map \"%s\": Invalid numeric domain spec \"%s\"", 7315 map->map_mname, at); 7316 return false; 7317 } 7318 } 7319 else 7320 { 7321 hp = sm_gethostbyname(at, addr.sa.sa_family); 7322 if (hp == NULL) 7323 { 7324 syserr("socket map \"%s\": Unknown host name %s", 7325 map->map_mname, at); 7326 return false; 7327 } 7328 addr.sa.sa_family = hp->h_addrtype; 7329 switch (hp->h_addrtype) 7330 { 7331 # if NETINET 7332 case AF_INET: 7333 memmove(&addr.sin.sin_addr, 7334 hp->h_addr, INADDRSZ); 7335 addr.sin.sin_port = port; 7336 addrlen = sizeof (struct sockaddr_in); 7337 addrno = 1; 7338 break; 7339 # endif /* NETINET */ 7340 7341 # if NETINET6 7342 case AF_INET6: 7343 memmove(&addr.sin6.sin6_addr, 7344 hp->h_addr, IN6ADDRSZ); 7345 addr.sin6.sin6_port = port; 7346 addrlen = sizeof (struct sockaddr_in6); 7347 addrno = 1; 7348 break; 7349 # endif /* NETINET6 */ 7350 7351 default: 7352 syserr("socket map \"%s\": Unknown protocol for %s (%d)", 7353 map->map_mname, at, hp->h_addrtype); 7354 # if NETINET6 7355 freehostent(hp); 7356 # endif /* NETINET6 */ 7357 return false; 7358 } 7359 } 7360 } 7361 else 7362 # endif /* NETINET || NETINET6 */ 7363 { 7364 syserr("socket map \"%s\": unknown socket protocol", 7365 map->map_mname); 7366 return false; 7367 } 7368 7369 /* nope, actually connecting */ 7370 for (;;) 7371 { 7372 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0); 7373 if (sock < 0) 7374 { 7375 save_errno = errno; 7376 if (tTd(38, 5)) 7377 sm_dprintf("socket map \"%s\": error creating socket: %s\n", 7378 map->map_mname, 7379 sm_errstring(save_errno)); 7380 # if NETINET6 7381 if (hp != NULL) 7382 freehostent(hp); 7383 # endif /* NETINET6 */ 7384 return false; 7385 } 7386 7387 if (connect(sock, (struct sockaddr *) &addr, addrlen) >= 0) 7388 break; 7389 7390 /* couldn't connect.... try next address */ 7391 save_errno = errno; 7392 p = CurHostName; 7393 CurHostName = at; 7394 if (tTd(38, 5)) 7395 sm_dprintf("socket_open (%s): open %s failed: %s\n", 7396 map->map_mname, at, sm_errstring(save_errno)); 7397 CurHostName = p; 7398 (void) close(sock); 7399 7400 /* try next address */ 7401 if (hp != NULL && hp->h_addr_list[addrno] != NULL) 7402 { 7403 switch (addr.sa.sa_family) 7404 { 7405 # if NETINET 7406 case AF_INET: 7407 memmove(&addr.sin.sin_addr, 7408 hp->h_addr_list[addrno++], 7409 INADDRSZ); 7410 break; 7411 # endif /* NETINET */ 7412 7413 # if NETINET6 7414 case AF_INET6: 7415 memmove(&addr.sin6.sin6_addr, 7416 hp->h_addr_list[addrno++], 7417 IN6ADDRSZ); 7418 break; 7419 # endif /* NETINET6 */ 7420 7421 default: 7422 if (tTd(38, 5)) 7423 sm_dprintf("socket map \"%s\": Unknown protocol for %s (%d)\n", 7424 map->map_mname, at, 7425 hp->h_addrtype); 7426 # if NETINET6 7427 freehostent(hp); 7428 # endif /* NETINET6 */ 7429 return false; 7430 } 7431 continue; 7432 } 7433 p = CurHostName; 7434 CurHostName = at; 7435 if (tTd(38, 5)) 7436 sm_dprintf("socket map \"%s\": error connecting to socket map: %s\n", 7437 map->map_mname, sm_errstring(save_errno)); 7438 CurHostName = p; 7439 # if NETINET6 7440 if (hp != NULL) 7441 freehostent(hp); 7442 # endif /* NETINET6 */ 7443 return false; 7444 } 7445 # if NETINET6 7446 if (hp != NULL) 7447 { 7448 freehostent(hp); 7449 hp = NULL; 7450 } 7451 # endif /* NETINET6 */ 7452 if ((map->map_db1 = (ARBPTR_T) sm_io_open(SmFtStdiofd, 7453 SM_TIME_DEFAULT, 7454 (void *) &sock, 7455 SM_IO_RDWR, 7456 NULL)) == NULL) 7457 { 7458 close(sock); 7459 if (tTd(38, 2)) 7460 sm_dprintf("socket_open (%s): failed to create stream: %s\n", 7461 map->map_mname, sm_errstring(errno)); 7462 return false; 7463 } 7464 7465 /* Save connection for reuse */ 7466 s->s_socketmap = map; 7467 return true; 7468 } 7469 7470 /* 7471 ** SOCKET_MAP_FINDCONN -- find a SOCKET connection to the server 7472 ** 7473 ** Cache SOCKET connections based on the connection specifier 7474 ** and PID so we don't have multiple connections open to 7475 ** the same server for different maps. Need a separate connection 7476 ** per PID since a parent process may close the map before the 7477 ** child is done with it. 7478 ** 7479 ** Parameters: 7480 ** conn -- SOCKET map connection specifier 7481 ** 7482 ** Returns: 7483 ** Symbol table entry for the SOCKET connection. 7484 */ 7485 7486 static STAB * 7487 socket_map_findconn(conn) 7488 const char *conn; 7489 { 7490 char *nbuf; 7491 STAB *SM_NONVOLATILE s = NULL; 7492 7493 nbuf = sm_stringf_x("%s%c%d", conn, CONDELSE, (int) CurrentPid); 7494 SM_TRY 7495 s = stab(nbuf, ST_SOCKETMAP, ST_ENTER); 7496 SM_FINALLY 7497 sm_free(nbuf); 7498 SM_END_TRY 7499 return s; 7500 } 7501 7502 /* 7503 ** SOCKET_MAP_CLOSE -- close the socket 7504 */ 7505 7506 void 7507 socket_map_close(map) 7508 MAP *map; 7509 { 7510 STAB *s; 7511 MAP *smap; 7512 7513 if (tTd(38, 20)) 7514 sm_dprintf("socket_map_close(%s), pid=%ld\n", map->map_file, 7515 (long) CurrentPid); 7516 7517 /* Check if already closed */ 7518 if (map->map_db1 == NULL) 7519 { 7520 if (tTd(38, 20)) 7521 sm_dprintf("socket_map_close(%s) already closed\n", 7522 map->map_file); 7523 return; 7524 } 7525 sm_io_close((SM_FILE_T *)map->map_db1, SM_TIME_DEFAULT); 7526 7527 /* Mark all the maps that share the connection as closed */ 7528 s = socket_map_findconn(map->map_file); 7529 smap = s->s_socketmap; 7530 while (smap != NULL) 7531 { 7532 MAP *next; 7533 7534 if (tTd(38, 2) && smap != map) 7535 sm_dprintf("socket_map_close(%s): closed %s (shared SOCKET connection)\n", 7536 map->map_mname, smap->map_mname); 7537 7538 smap->map_mflags &= ~(MF_OPEN|MF_WRITABLE); 7539 smap->map_db1 = NULL; 7540 next = smap->socket_map_next; 7541 smap->socket_map_next = NULL; 7542 smap = next; 7543 } 7544 s->s_socketmap = NULL; 7545 } 7546 7547 /* 7548 ** SOCKET_MAP_LOOKUP -- look up a datum in a SOCKET table 7549 */ 7550 7551 char * 7552 socket_map_lookup(map, name, av, statp) 7553 MAP *map; 7554 char *name; 7555 char **av; 7556 int *statp; 7557 { 7558 unsigned int nettolen, replylen, recvlen; 7559 char *replybuf, *rval, *value, *status, *key; 7560 SM_FILE_T *f; 7561 char keybuf[MAXNAME + 1]; 7562 7563 replybuf = NULL; 7564 rval = NULL; 7565 f = (SM_FILE_T *)map->map_db1; 7566 if (tTd(38, 20)) 7567 sm_dprintf("socket_map_lookup(%s, %s) %s\n", 7568 map->map_mname, name, map->map_file); 7569 7570 if (!bitset(MF_NOFOLDCASE, map->map_mflags)) 7571 { 7572 nettolen = strlen(name); 7573 if (nettolen > sizeof keybuf - 1) 7574 nettolen = sizeof keybuf - 1; 7575 memmove(keybuf, name, nettolen); 7576 keybuf[nettolen] = '\0'; 7577 makelower(keybuf); 7578 key = keybuf; 7579 } 7580 else 7581 key = name; 7582 7583 nettolen = strlen(map->map_mname) + 1 + strlen(key); 7584 SM_ASSERT(nettolen > strlen(map->map_mname)); 7585 SM_ASSERT(nettolen > strlen(key)); 7586 if ((sm_io_fprintf(f, SM_TIME_DEFAULT, "%u:%s %s,", 7587 nettolen, map->map_mname, key) == SM_IO_EOF) || 7588 (sm_io_flush(f, SM_TIME_DEFAULT) != 0) || 7589 (sm_io_error(f))) 7590 { 7591 syserr("451 4.3.0 socket_map_lookup(%s): failed to send lookup request", 7592 map->map_mname); 7593 *statp = EX_TEMPFAIL; 7594 goto errcl; 7595 } 7596 7597 if (sm_io_fscanf(f, SM_TIME_DEFAULT, "%9u", &replylen) != 1) 7598 { 7599 syserr("451 4.3.0 socket_map_lookup(%s): failed to read length parameter of reply", 7600 map->map_mname); 7601 *statp = EX_TEMPFAIL; 7602 goto errcl; 7603 } 7604 if (replylen > SOCKETMAP_MAXL) 7605 { 7606 syserr("451 4.3.0 socket_map_lookup(%s): reply too long: %u", 7607 map->map_mname, replylen); 7608 *statp = EX_TEMPFAIL; 7609 goto errcl; 7610 } 7611 if (sm_io_getc(f, SM_TIME_DEFAULT) != ':') 7612 { 7613 syserr("451 4.3.0 socket_map_lookup(%s): missing ':' in reply", 7614 map->map_mname); 7615 *statp = EX_TEMPFAIL; 7616 goto error; 7617 } 7618 7619 replybuf = (char *) sm_malloc(replylen + 1); 7620 if (replybuf == NULL) 7621 { 7622 syserr("451 4.3.0 socket_map_lookup(%s): can't allocate %u bytes", 7623 map->map_mname, replylen + 1); 7624 *statp = EX_OSERR; 7625 goto error; 7626 } 7627 7628 recvlen = sm_io_read(f, SM_TIME_DEFAULT, replybuf, replylen); 7629 if (recvlen < replylen) 7630 { 7631 syserr("451 4.3.0 socket_map_lookup(%s): received only %u of %u reply characters", 7632 map->map_mname, recvlen, replylen); 7633 *statp = EX_TEMPFAIL; 7634 goto errcl; 7635 } 7636 if (sm_io_getc(f, SM_TIME_DEFAULT) != ',') 7637 { 7638 syserr("451 4.3.0 socket_map_lookup(%s): missing ',' in reply", 7639 map->map_mname); 7640 *statp = EX_TEMPFAIL; 7641 goto errcl; 7642 } 7643 status = replybuf; 7644 replybuf[recvlen] = '\0'; 7645 value = strchr(replybuf, ' '); 7646 if (value != NULL) 7647 { 7648 *value = '\0'; 7649 value++; 7650 } 7651 if (strcmp(status, "OK") == 0) 7652 { 7653 *statp = EX_OK; 7654 7655 /* collect the return value */ 7656 if (bitset(MF_MATCHONLY, map->map_mflags)) 7657 rval = map_rewrite(map, key, strlen(key), NULL); 7658 else 7659 rval = map_rewrite(map, value, strlen(value), av); 7660 } 7661 else if (strcmp(status, "NOTFOUND") == 0) 7662 { 7663 *statp = EX_NOTFOUND; 7664 if (tTd(38, 20)) 7665 sm_dprintf("socket_map_lookup(%s): %s not found\n", 7666 map->map_mname, key); 7667 } 7668 else 7669 { 7670 if (tTd(38, 5)) 7671 sm_dprintf("socket_map_lookup(%s, %s): server returned error: type=%s, reason=%s\n", 7672 map->map_mname, key, status, 7673 value ? value : ""); 7674 if ((strcmp(status, "TEMP") == 0) || 7675 (strcmp(status, "TIMEOUT") == 0)) 7676 *statp = EX_TEMPFAIL; 7677 else if(strcmp(status, "PERM") == 0) 7678 *statp = EX_UNAVAILABLE; 7679 else 7680 *statp = EX_PROTOCOL; 7681 } 7682 7683 if (replybuf != NULL) 7684 sm_free(replybuf); 7685 return rval; 7686 7687 errcl: 7688 socket_map_close(map); 7689 error: 7690 if (replybuf != NULL) 7691 sm_free(replybuf); 7692 return rval; 7693 } 7694 #endif /* SOCKETMAP */ 7695