contrib/sendmail/src/map.c

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