contrib/sendmail/src/map.c

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