contrib/sendmail/src/udb.c

   1 /*
   2  * Copyright (c) 1998-2003, 2006 Proofpoint, Inc. and its suppliers.
   3  *      All rights reserved.
   4  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
   5  * Copyright (c) 1988, 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 #include "map.h"
  16
  17 #if USERDB
  18 SM_RCSID("@(#)$Id: udb.c,v 8.166 2013-11-22 20:51:57 ca Exp $ (with USERDB)")
  19 #else
  20 SM_RCSID("@(#)$Id: udb.c,v 8.166 2013-11-22 20:51:57 ca Exp $ (without USERDB)")
  21 #endif
  22
  23 #if USERDB
  24
  25 #include <sm/sendmail.h>
  26 # if NEWDB
  27 #  include "sm/bdb.h"
  28 # else /* NEWDB */
  29 #  define DBT   struct _data_base_thang_
  30 DBT
  31 {
  32         void    *data;          /* pointer to data */
  33         size_t  size;           /* length of data */
  34 };
  35 # endif /* NEWDB */
  36
  37 /*
  38 **  UDB.C -- interface between sendmail and Berkeley User Data Base.
  39 **
  40 **      This depends on the 4.4BSD db package.
  41 */
  42
  43
  44 struct udbent
  45 {
  46         char    *udb_spec;              /* string version of spec */
  47         int     udb_type;               /* type of entry */
  48         pid_t   udb_pid;                /* PID of process which opened db */
  49         char    *udb_default;           /* default host for outgoing mail */
  50         union
  51         {
  52 # if NETINET || NETINET6
  53                 /* type UE_REMOTE -- do remote call for lookup */
  54                 struct
  55                 {
  56                         SOCKADDR        _udb_addr;      /* address */
  57                         int             _udb_timeout;   /* timeout */
  58                 } udb_remote;
  59 #  define udb_addr      udb_u.udb_remote._udb_addr
  60 #  define udb_timeout   udb_u.udb_remote._udb_timeout
  61 # endif /* NETINET || NETINET6 */
  62
  63                 /* type UE_FORWARD -- forward message to remote */
  64                 struct
  65                 {
  66                         char    *_udb_fwdhost;  /* name of forward host */
  67                 } udb_forward;
  68 # define udb_fwdhost    udb_u.udb_forward._udb_fwdhost
  69
  70 # if NEWDB
  71                 /* type UE_FETCH -- lookup in local database */
  72                 struct
  73                 {
  74                         char    *_udb_dbname;   /* pathname of database */
  75                         DB      *_udb_dbp;      /* open database ptr */
  76                 } udb_lookup;
  77 #  define udb_dbname    udb_u.udb_lookup._udb_dbname
  78 #  define udb_dbp       udb_u.udb_lookup._udb_dbp
  79 # endif /* NEWDB */
  80         } udb_u;
  81 };
  82
  83 # define UDB_EOLIST     0       /* end of list */
  84 # define UDB_SKIP       1       /* skip this entry */
  85 # define UDB_REMOTE     2       /* look up in remote database */
  86 # define UDB_DBFETCH    3       /* look up in local database */
  87 # define UDB_FORWARD    4       /* forward to remote host */
  88 # define UDB_HESIOD     5       /* look up via hesiod */
  89
  90 # define MAXUDBENT      10      /* maximum number of UDB entries */
  91
  92
  93 struct udb_option
  94 {
  95         char    *udbo_name;
  96         char    *udbo_val;
  97 };
  98
  99 # if HESIOD
 100 static int      hes_udb_get __P((DBT *, DBT *));
 101 # endif
 102 static char     *udbmatch __P((char *, char *, SM_RPOOL_T *));
 103 static int      _udbx_init __P((ENVELOPE *));
 104 static int      _udb_parsespec __P((char *, struct udb_option [], int));
 105
 106 /*
 107 **  UDBEXPAND -- look up user in database and expand
 108 **
 109 **      Parameters:
 110 **              a -- address to expand.
 111 **              sendq -- pointer to head of sendq to put the expansions in.
 112 **              aliaslevel -- the current alias nesting depth.
 113 **              e -- the current envelope.
 114 **
 115 **      Returns:
 116 **              EX_TEMPFAIL -- if something "odd" happened -- probably due
 117 **                      to accessing a file on an NFS server that is down.
 118 **              EX_OK -- otherwise.
 119 **
 120 **      Side Effects:
 121 **              Modifies sendq.
 122 */
 123
 124 static struct udbent    UdbEnts[MAXUDBENT + 1];
 125 static bool             UdbInitialized = false;
 126
 127 int
 128 udbexpand(a, sendq, aliaslevel, e)
 129         register ADDRESS *a;
 130         ADDRESS **sendq;
 131         int aliaslevel;
 132         register ENVELOPE *e;
 133 {
 134         int i;
 135         DBT key;
 136         DBT info;
 137         bool breakout;
 138         register struct udbent *up;
 139         int keylen;
 140         int naddrs;
 141         char *user;
 142         char keybuf[MAXUDBKEY];
 143
 144         memset(&key, '\0', sizeof(key));
 145         memset(&info, '\0', sizeof(info));
 146
 147         if (tTd(28, 1))
 148                 sm_dprintf("udbexpand(%s)\n", a->q_paddr);
 149
 150         /* make certain we are supposed to send to this address */
 151         if (!QS_IS_SENDABLE(a->q_state))
 152                 return EX_OK;
 153         e->e_to = a->q_paddr;
 154
 155         /* on first call, locate the database */
 156         if (!UdbInitialized)
 157         {
 158                 if (_udbx_init(e) == EX_TEMPFAIL)
 159                         return EX_TEMPFAIL;
 160         }
 161
 162         /* short circuit the process if no chance of a match */
 163         if (UdbSpec == NULL || UdbSpec[0] == '\0')
 164                 return EX_OK;
 165
 166         /* extract user to do userdb matching on */
 167         user = a->q_user;
 168
 169         /* short circuit name begins with '\\' since it can't possibly match */
 170         /* (might want to treat this as unquoted instead) */
 171         if (user[0] == '\\')
 172                 return EX_OK;
 173
 174         /* if name begins with a colon, it indicates our metadata */
 175         if (user[0] == ':')
 176                 return EX_OK;
 177
 178         keylen = sm_strlcpyn(keybuf, sizeof(keybuf), 2, user, ":maildrop");
 179
 180         /* if name is too long, assume it won't match */
 181         if (keylen >= sizeof(keybuf))
 182                 return EX_OK;
 183
 184         /* build actual database key */
 185
 186         breakout = false;
 187         for (up = UdbEnts; !breakout; up++)
 188         {
 189                 int usersize;
 190 # if NEWDB
 191                 int userleft;
 192 # endif
 193                 char userbuf[MEMCHUNKSIZE];
 194 # if HESIOD && HES_GETMAILHOST
 195                 char pobuf[MAXNAME];
 196 # endif
 197 # if defined(NEWDB) && DB_VERSION_MAJOR > 1
 198                 DBC *dbc = NULL;
 199 # endif
 200
 201                 user = userbuf;
 202                 userbuf[0] = '\0';
 203                 usersize = sizeof(userbuf);
 204 # if NEWDB
 205                 userleft = sizeof(userbuf) - 1;
 206 # endif
 207
 208                 /*
 209                 **  Select action based on entry type.
 210                 **
 211                 **      On dropping out of this switch, "class" should
 212                 **      explain the type of the data, and "user" should
 213                 **      contain the user information.
 214                 */
 215
 216                 switch (up->udb_type)
 217                 {
 218 # if NEWDB
 219                   case UDB_DBFETCH:
 220                         key.data = keybuf;
 221                         key.size = keylen;
 222                         if (tTd(28, 80))
 223                                 sm_dprintf("udbexpand: trying %s (%d) via db\n",
 224                                         keybuf, keylen);
 225 #  if DB_VERSION_MAJOR < 2
 226                         i = (*up->udb_dbp->seq)(up->udb_dbp, &key, &info, R_CURSOR);
 227 #  else /* DB_VERSION_MAJOR < 2 */
 228                         i = 0;
 229                         if (dbc == NULL &&
 230 #   if DB_VERSION_MAJOR > 2 || DB_VERSION_MINOR >= 6
 231                             (errno = (*up->udb_dbp->cursor)(up->udb_dbp,
 232                                                             NULL, &dbc, 0)) != 0)
 233 #   else /* DB_VERSION_MAJOR > 2 || DB_VERSION_MINOR >= 6 */
 234                             (errno = (*up->udb_dbp->cursor)(up->udb_dbp,
 235                                                             NULL, &dbc)) != 0)
 236 #   endif /* DB_VERSION_MAJOR > 2 || DB_VERSION_MINOR >= 6 */
 237                                 i = -1;
 238                         if (i != 0 || dbc == NULL ||
 239                             (errno = dbc->c_get(dbc, &key,
 240                                                 &info, DB_SET)) != 0)
 241                                 i = 1;
 242 #  endif /* DB_VERSION_MAJOR < 2 */
 243                         if (i > 0 || info.size <= 0)
 244                         {
 245                                 if (tTd(28, 2))
 246                                         sm_dprintf("udbexpand: no match on %s (%d)\n",
 247                                                 keybuf, keylen);
 248 #  if DB_VERSION_MAJOR > 1
 249                                 if (dbc != NULL)
 250                                 {
 251                                         (void) dbc->c_close(dbc);
 252                                         dbc = NULL;
 253                                 }
 254 #  endif /* DB_VERSION_MAJOR > 1 */
 255                                 break;
 256                         }
 257                         if (tTd(28, 80))
 258                                 sm_dprintf("udbexpand: match %.*s: %.*s\n",
 259                                         (int) key.size, (char *) key.data,
 260                                         (int) info.size, (char *) info.data);
 261
 262                         a->q_flags &= ~QSELFREF;
 263                         while (i == 0 && key.size == keylen &&
 264                                memcmp(key.data, keybuf, keylen) == 0)
 265                         {
 266                                 char *p;
 267
 268                                 if (bitset(EF_VRFYONLY, e->e_flags))
 269                                 {
 270                                         a->q_state = QS_VERIFIED;
 271 #  if DB_VERSION_MAJOR > 1
 272                                         if (dbc != NULL)
 273                                         {
 274                                                 (void) dbc->c_close(dbc);
 275                                                 dbc = NULL;
 276                                         }
 277 #  endif /* DB_VERSION_MAJOR > 1 */
 278                                         return EX_OK;
 279                                 }
 280
 281                                 breakout = true;
 282                                 if (info.size >= userleft - 1)
 283                                 {
 284                                         char *nuser;
 285                                         int size = MEMCHUNKSIZE;
 286
 287                                         if (info.size > MEMCHUNKSIZE)
 288                                                 size = info.size;
 289                                         nuser = sm_malloc_x(usersize + size);
 290
 291                                         memmove(nuser, user, usersize);
 292                                         if (user != userbuf)
 293                                                 sm_free(user); /* XXX */
 294                                         user = nuser;
 295                                         usersize += size;
 296                                         userleft += size;
 297                                 }
 298                                 p = &user[strlen(user)];
 299                                 if (p != user)
 300                                 {
 301                                         *p++ = ',';
 302                                         userleft--;
 303                                 }
 304                                 memmove(p, info.data, info.size);
 305                                 p[info.size] = '\0';
 306                                 userleft -= info.size;
 307
 308                                 /* get the next record */
 309 #  if DB_VERSION_MAJOR < 2
 310                                 i = (*up->udb_dbp->seq)(up->udb_dbp, &key, &info, R_NEXT);
 311 #  else /* DB_VERSION_MAJOR < 2 */
 312                                 i = 0;
 313                                 if ((errno = dbc->c_get(dbc, &key,
 314                                                         &info, DB_NEXT)) != 0)
 315                                         i = 1;
 316 #  endif /* DB_VERSION_MAJOR < 2 */
 317                         }
 318
 319 #  if DB_VERSION_MAJOR > 1
 320                         if (dbc != NULL)
 321                         {
 322                                 (void) dbc->c_close(dbc);
 323                                 dbc = NULL;
 324                         }
 325 #  endif /* DB_VERSION_MAJOR > 1 */
 326
 327                         /* if nothing ever matched, try next database */
 328                         if (!breakout)
 329                                 break;
 330
 331                         message("expanded to %s", user);
 332                         if (LogLevel > 10)
 333                                 sm_syslog(LOG_INFO, e->e_id,
 334                                           "expand %.100s => %s",
 335                                           e->e_to,
 336                                           shortenstring(user, MAXSHORTSTR));
 337                         naddrs = sendtolist(user, a, sendq, aliaslevel + 1, e);
 338                         if (naddrs > 0 && !bitset(QSELFREF, a->q_flags))
 339                         {
 340                                 if (tTd(28, 5))
 341                                 {
 342                                         sm_dprintf("udbexpand: QS_EXPANDED ");
 343                                         printaddr(sm_debug_file(), a, false);
 344                                 }
 345                                 a->q_state = QS_EXPANDED;
 346                         }
 347                         if (i < 0)
 348                         {
 349                                 syserr("udbexpand: db-get %.*s stat %d",
 350                                         (int) key.size, (char *) key.data, i);
 351                                 return EX_TEMPFAIL;
 352                         }
 353
 354                         /*
 355                         **  If this address has a -request address, reflect
 356                         **  it into the envelope.
 357                         */
 358
 359                         memset(&key, '\0', sizeof(key));
 360                         memset(&info, '\0', sizeof(info));
 361                         (void) sm_strlcpyn(keybuf, sizeof(keybuf), 2, a->q_user,
 362                                            ":mailsender");
 363                         keylen = strlen(keybuf);
 364                         key.data = keybuf;
 365                         key.size = keylen;
 366
 367 #  if DB_VERSION_MAJOR < 2
 368                         i = (*up->udb_dbp->get)(up->udb_dbp, &key, &info, 0);
 369 #  else
 370                         i = errno = (*up->udb_dbp->get)(up->udb_dbp, NULL,
 371                                                         &key, &info, 0);
 372 #  endif
 373                         if (i != 0 || info.size <= 0)
 374                                 break;
 375                         a->q_owner = sm_rpool_malloc_x(e->e_rpool,
 376                                                        info.size + 1);
 377                         memmove(a->q_owner, info.data, info.size);
 378                         a->q_owner[info.size] = '\0';
 379
 380                         /* announce delivery; NORECEIPT bit set later */
 381                         if (e->e_xfp != NULL)
 382                         {
 383                                 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT,
 384                                                      "Message delivered to mailing list %s\n",
 385                                                      a->q_paddr);
 386                         }
 387                         e->e_flags |= EF_SENDRECEIPT;
 388                         a->q_flags |= QDELIVERED|QEXPANDED;
 389                         break;
 390 # endif /* NEWDB */
 391
 392 # if HESIOD
 393                   case UDB_HESIOD:
 394                         key.data = keybuf;
 395                         key.size = keylen;
 396                         if (tTd(28, 80))
 397                                 sm_dprintf("udbexpand: trying %s (%d) via hesiod\n",
 398                                         keybuf, keylen);
 399                         /* look up the key via hesiod */
 400                         i = hes_udb_get(&key, &info);
 401                         if (i < 0)
 402                         {
 403                                 syserr("udbexpand: hesiod-get %.*s stat %d",
 404                                         (int) key.size, (char *) key.data, i);
 405                                 return EX_TEMPFAIL;
 406                         }
 407                         else if (i > 0 || info.size <= 0)
 408                         {
 409 #  if HES_GETMAILHOST
 410                                 struct hes_postoffice *hp;
 411 #  endif
 412
 413                                 if (tTd(28, 2))
 414                                         sm_dprintf("udbexpand: no match on %s (%d)\n",
 415                                                 (char *) keybuf, (int) keylen);
 416 #  if HES_GETMAILHOST
 417                                 if (tTd(28, 8))
 418                                         sm_dprintf("  ... trying hes_getmailhost(%s)\n",
 419                                                 a->q_user);
 420                                 hp = hes_getmailhost(a->q_user);
 421                                 if (hp == NULL)
 422                                 {
 423                                         if (hes_error() == HES_ER_NET)
 424                                         {
 425                                                 syserr("udbexpand: hesiod-getmail %s stat %d",
 426                                                         a->q_user, hes_error());
 427                                                 return EX_TEMPFAIL;
 428                                         }
 429                                         if (tTd(28, 2))
 430                                                 sm_dprintf("hes_getmailhost(%s): %d\n",
 431                                                         a->q_user, hes_error());
 432                                         break;
 433                                 }
 434                                 if (strlen(hp->po_name) + strlen(hp->po_host) >
 435                                     sizeof(pobuf) - 2)
 436                                 {
 437                                         if (tTd(28, 2))
 438                                                 sm_dprintf("hes_getmailhost(%s): expansion too long: %.30s@%.30s\n",
 439                                                         a->q_user,
 440                                                         hp->po_name,
 441                                                         hp->po_host);
 442                                         break;
 443                                 }
 444                                 info.data = pobuf;
 445                                 (void) sm_snprintf(pobuf, sizeof(pobuf),
 446                                         "%s@%s", hp->po_name, hp->po_host);
 447                                 info.size = strlen(info.data);
 448 #  else /* HES_GETMAILHOST */
 449                                 break;
 450 #  endif /* HES_GETMAILHOST */
 451                         }
 452                         if (tTd(28, 80))
 453                                 sm_dprintf("udbexpand: match %.*s: %.*s\n",
 454                                         (int) key.size, (char *) key.data,
 455                                         (int) info.size, (char *) info.data);
 456                         a->q_flags &= ~QSELFREF;
 457
 458                         if (bitset(EF_VRFYONLY, e->e_flags))
 459                         {
 460                                 a->q_state = QS_VERIFIED;
 461                                 return EX_OK;
 462                         }
 463
 464                         breakout = true;
 465                         if (info.size >= usersize)
 466                                 user = sm_malloc_x(info.size + 1);
 467                         memmove(user, info.data, info.size);
 468                         user[info.size] = '\0';
 469
 470                         message("hesioded to %s", user);
 471                         if (LogLevel > 10)
 472                                 sm_syslog(LOG_INFO, e->e_id,
 473                                           "hesiod %.100s => %s",
 474                                           e->e_to,
 475                                           shortenstring(user, MAXSHORTSTR));
 476                         naddrs = sendtolist(user, a, sendq, aliaslevel + 1, e);
 477
 478                         if (naddrs > 0 && !bitset(QSELFREF, a->q_flags))
 479                         {
 480                                 if (tTd(28, 5))
 481                                 {
 482                                         sm_dprintf("udbexpand: QS_EXPANDED ");
 483                                         printaddr(sm_debug_file(), a, false);
 484                                 }
 485                                 a->q_state = QS_EXPANDED;
 486                         }
 487
 488                         /*
 489                         **  If this address has a -request address, reflect
 490                         **  it into the envelope.
 491                         */
 492
 493                         (void) sm_strlcpyn(keybuf, sizeof(keybuf), 2, a->q_user,
 494                                            ":mailsender");
 495                         keylen = strlen(keybuf);
 496                         key.data = keybuf;
 497                         key.size = keylen;
 498                         i = hes_udb_get(&key, &info);
 499                         if (i != 0 || info.size <= 0)
 500                                 break;
 501                         a->q_owner = sm_rpool_malloc_x(e->e_rpool,
 502                                                        info.size + 1);
 503                         memmove(a->q_owner, info.data, info.size);
 504                         a->q_owner[info.size] = '\0';
 505                         break;
 506 # endif /* HESIOD */
 507
 508                   case UDB_REMOTE:
 509                         /* not yet implemented */
 510                         break;
 511
 512                   case UDB_FORWARD:
 513                         if (bitset(EF_VRFYONLY, e->e_flags))
 514                         {
 515                                 a->q_state = QS_VERIFIED;
 516                                 return EX_OK;
 517                         }
 518                         i = strlen(up->udb_fwdhost) + strlen(a->q_user) + 1;
 519                         if (i >= usersize)
 520                         {
 521                                 usersize = i + 1;
 522                                 user = sm_malloc_x(usersize);
 523                         }
 524                         (void) sm_strlcpyn(user, usersize, 3,
 525                                         a->q_user, "@", up->udb_fwdhost);
 526                         message("expanded to %s", user);
 527                         a->q_flags &= ~QSELFREF;
 528                         naddrs = sendtolist(user, a, sendq, aliaslevel + 1, e);
 529                         if (naddrs > 0 && !bitset(QSELFREF, a->q_flags))
 530                         {
 531                                 if (tTd(28, 5))
 532                                 {
 533                                         sm_dprintf("udbexpand: QS_EXPANDED ");
 534                                         printaddr(sm_debug_file(), a, false);
 535                                 }
 536                                 a->q_state = QS_EXPANDED;
 537                         }
 538                         breakout = true;
 539                         break;
 540
 541                   case UDB_EOLIST:
 542                         breakout = true;
 543                         break;
 544
 545                   default:
 546                         /* unknown entry type */
 547                         break;
 548                 }
 549                 /* XXX if an exception occurs, there is a storage leak */
 550                 if (user != userbuf)
 551                         sm_free(user); /* XXX */
 552         }
 553         return EX_OK;
 554 }
 555 /*
 556 **  UDBSENDER -- return canonical external name of sender, given local name
 557 **
 558 **      Parameters:
 559 **              sender -- the name of the sender on the local machine.
 560 **              rpool -- resource pool from which to allocate result
 561 **
 562 **      Returns:
 563 **              The external name for this sender, if derivable from the
 564 **                      database.  Storage allocated from rpool.
 565 **              NULL -- if nothing is changed from the database.
 566 **
 567 **      Side Effects:
 568 **              none.
 569 */
 570
 571 char *
 572 udbsender(sender, rpool)
 573         char *sender;
 574         SM_RPOOL_T *rpool;
 575 {
 576         return udbmatch(sender, "mailname", rpool);
 577 }
 578 /*
 579 **  UDBMATCH -- match user in field, return result of lookup.
 580 **
 581 **      Parameters:
 582 **              user -- the name of the user.
 583 **              field -- the field to lookup.
 584 **              rpool -- resource pool from which to allocate result
 585 **
 586 **      Returns:
 587 **              The external name for this sender, if derivable from the
 588 **                      database.  Storage allocated from rpool.
 589 **              NULL -- if nothing is changed from the database.
 590 **
 591 **      Side Effects:
 592 **              none.
 593 */
 594
 595 static char *
 596 udbmatch(user, field, rpool)
 597         char *user;
 598         char *field;
 599         SM_RPOOL_T *rpool;
 600 {
 601         register char *p;
 602         register struct udbent *up;
 603         int i;
 604         int keylen;
 605         DBT key, info;
 606         char keybuf[MAXUDBKEY];
 607
 608         if (tTd(28, 1))
 609                 sm_dprintf("udbmatch(%s, %s)\n", user, field);
 610
 611         if (!UdbInitialized)
 612         {
 613                 if (_udbx_init(CurEnv) == EX_TEMPFAIL)
 614                         return NULL;
 615         }
 616
 617         /* short circuit if no spec */
 618         if (UdbSpec == NULL || UdbSpec[0] == '\0')
 619                 return NULL;
 620
 621         /* short circuit name begins with '\\' since it can't possibly match */
 622         if (user[0] == '\\')
 623                 return NULL;
 624
 625         /* long names can never match and are a pain to deal with */
 626         i = strlen(field);
 627         if (i < sizeof("maildrop"))
 628                 i = sizeof("maildrop");
 629         if ((strlen(user) + i) > sizeof(keybuf) - 4)
 630                 return NULL;
 631
 632         /* names beginning with colons indicate metadata */
 633         if (user[0] == ':')
 634                 return NULL;
 635
 636         /* build database key */
 637         (void) sm_strlcpyn(keybuf, sizeof(keybuf), 3, user, ":", field);
 638         keylen = strlen(keybuf);
 639
 640         for (up = UdbEnts; up->udb_type != UDB_EOLIST; up++)
 641         {
 642                 /*
 643                 **  Select action based on entry type.
 644                 */
 645
 646                 switch (up->udb_type)
 647                 {
 648 # if NEWDB
 649                   case UDB_DBFETCH:
 650                         memset(&key, '\0', sizeof(key));
 651                         memset(&info, '\0', sizeof(info));
 652                         key.data = keybuf;
 653                         key.size = keylen;
 654 #  if DB_VERSION_MAJOR < 2
 655                         i = (*up->udb_dbp->get)(up->udb_dbp, &key, &info, 0);
 656 #  else
 657                         i = errno = (*up->udb_dbp->get)(up->udb_dbp, NULL,
 658                                                         &key, &info, 0);
 659 #  endif
 660                         if (i != 0 || info.size <= 0)
 661                         {
 662                                 if (tTd(28, 2))
 663                                         sm_dprintf("udbmatch: no match on %s (%d) via db\n",
 664                                                 keybuf, keylen);
 665                                 continue;
 666                         }
 667
 668                         p = sm_rpool_malloc_x(rpool, info.size + 1);
 669                         memmove(p, info.data, info.size);
 670                         p[info.size] = '\0';
 671                         if (tTd(28, 1))
 672                                 sm_dprintf("udbmatch ==> %s\n", p);
 673                         return p;
 674 # endif /* NEWDB */
 675
 676 # if HESIOD
 677                   case UDB_HESIOD:
 678                         key.data = keybuf;
 679                         key.size = keylen;
 680                         i = hes_udb_get(&key, &info);
 681                         if (i != 0 || info.size <= 0)
 682                         {
 683                                 if (tTd(28, 2))
 684                                         sm_dprintf("udbmatch: no match on %s (%d) via hesiod\n",
 685                                                 keybuf, keylen);
 686                                 continue;
 687                         }
 688
 689                         p = sm_rpool_malloc_x(rpool, info.size + 1);
 690                         memmove(p, info.data, info.size);
 691                         p[info.size] = '\0';
 692                         if (tTd(28, 1))
 693                                 sm_dprintf("udbmatch ==> %s\n", p);
 694                         return p;
 695 # endif /* HESIOD */
 696                 }
 697         }
 698
 699         if (strcmp(field, "mailname") != 0)
 700                 return NULL;
 701
 702         /*
 703         **  Nothing yet.  Search again for a default case.  But only
 704         **  use it if we also have a forward (:maildrop) pointer already
 705         **  in the database.
 706         */
 707
 708         /* build database key */
 709         (void) sm_strlcpyn(keybuf, sizeof(keybuf), 2, user, ":maildrop");
 710         keylen = strlen(keybuf);
 711
 712         for (up = UdbEnts; up->udb_type != UDB_EOLIST; up++)
 713         {
 714                 switch (up->udb_type)
 715                 {
 716 # if NEWDB
 717                   case UDB_DBFETCH:
 718                         /* get the default case for this database */
 719                         if (up->udb_default == NULL)
 720                         {
 721                                 memset(&key, '\0', sizeof(key));
 722                                 memset(&info, '\0', sizeof(info));
 723                                 key.data = ":default:mailname";
 724                                 key.size = strlen(key.data);
 725 #  if DB_VERSION_MAJOR < 2
 726                                 i = (*up->udb_dbp->get)(up->udb_dbp,
 727                                                         &key, &info, 0);
 728 #  else /* DB_VERSION_MAJOR < 2 */
 729                                 i = errno = (*up->udb_dbp->get)(up->udb_dbp,
 730                                                                 NULL, &key,
 731                                                                 &info, 0);
 732 #  endif /* DB_VERSION_MAJOR < 2 */
 733                                 if (i != 0 || info.size <= 0)
 734                                 {
 735                                         /* no default case */
 736                                         up->udb_default = "";
 737                                         continue;
 738                                 }
 739
 740                                 /* save the default case */
 741                                 up->udb_default = sm_pmalloc_x(info.size + 1);
 742                                 memmove(up->udb_default, info.data, info.size);
 743                                 up->udb_default[info.size] = '\0';
 744                         }
 745                         else if (up->udb_default[0] == '\0')
 746                                 continue;
 747
 748                         /* we have a default case -- verify user:maildrop */
 749                         memset(&key, '\0', sizeof(key));
 750                         memset(&info, '\0', sizeof(info));
 751                         key.data = keybuf;
 752                         key.size = keylen;
 753 #  if DB_VERSION_MAJOR < 2
 754                         i = (*up->udb_dbp->get)(up->udb_dbp, &key, &info, 0);
 755 #  else
 756                         i = errno = (*up->udb_dbp->get)(up->udb_dbp, NULL,
 757                                                         &key, &info, 0);
 758 #  endif
 759                         if (i != 0 || info.size <= 0)
 760                         {
 761                                 /* nope -- no aliasing for this user */
 762                                 continue;
 763                         }
 764
 765                         /* they exist -- build the actual address */
 766                         i = strlen(user) + strlen(up->udb_default) + 2;
 767                         p = sm_rpool_malloc_x(rpool, i);
 768                         (void) sm_strlcpyn(p, i, 3, user, "@", up->udb_default);
 769                         if (tTd(28, 1))
 770                                 sm_dprintf("udbmatch ==> %s\n", p);
 771                         return p;
 772 # endif /* NEWDB */
 773
 774 # if HESIOD
 775                   case UDB_HESIOD:
 776                         /* get the default case for this database */
 777                         if (up->udb_default == NULL)
 778                         {
 779                                 key.data = ":default:mailname";
 780                                 key.size = strlen(key.data);
 781                                 i = hes_udb_get(&key, &info);
 782
 783                                 if (i != 0 || info.size <= 0)
 784                                 {
 785                                         /* no default case */
 786                                         up->udb_default = "";
 787                                         continue;
 788                                 }
 789
 790                                 /* save the default case */
 791                                 up->udb_default = sm_pmalloc_x(info.size + 1);
 792                                 memmove(up->udb_default, info.data, info.size);
 793                                 up->udb_default[info.size] = '\0';
 794                         }
 795                         else if (up->udb_default[0] == '\0')
 796                                 continue;
 797
 798                         /* we have a default case -- verify user:maildrop */
 799                         key.data = keybuf;
 800                         key.size = keylen;
 801                         i = hes_udb_get(&key, &info);
 802                         if (i != 0 || info.size <= 0)
 803                         {
 804                                 /* nope -- no aliasing for this user */
 805                                 continue;
 806                         }
 807
 808                         /* they exist -- build the actual address */
 809                         i = strlen(user) + strlen(up->udb_default) + 2;
 810                         p = sm_rpool_malloc_x(rpool, i);
 811                         (void) sm_strlcpyn(p, i, 3, user, "@", up->udb_default);
 812                         if (tTd(28, 1))
 813                                 sm_dprintf("udbmatch ==> %s\n", p);
 814                         return p;
 815                         break;
 816 # endif /* HESIOD */
 817                 }
 818         }
 819
 820         /* still nothing....  too bad */
 821         return NULL;
 822 }
 823 /*
 824 **  UDB_MAP_LOOKUP -- look up arbitrary entry in user database map
 825 **
 826 **      Parameters:
 827 **              map -- the map being queried.
 828 **              name -- the name to look up.
 829 **              av -- arguments to the map lookup.
 830 **              statp -- to get any error status.
 831 **
 832 **      Returns:
 833 **              NULL if name not found in map.
 834 **              The rewritten name otherwise.
 835 */
 836
 837 /* ARGSUSED3 */
 838 char *
 839 udb_map_lookup(map, name, av, statp)
 840         MAP *map;
 841         char *name;
 842         char **av;
 843         int *statp;
 844 {
 845         char *val;
 846         char *key;
 847         char *SM_NONVOLATILE result = NULL;
 848         char keybuf[MAXNAME + 1];
 849
 850         if (tTd(28, 20) || tTd(38, 20))
 851                 sm_dprintf("udb_map_lookup(%s, %s)\n", map->map_mname, name);
 852
 853         if (bitset(MF_NOFOLDCASE, map->map_mflags))
 854         {
 855                 key = name;
 856         }
 857         else
 858         {
 859                 int keysize = strlen(name);
 860
 861                 if (keysize > sizeof(keybuf) - 1)
 862                         keysize = sizeof(keybuf) - 1;
 863                 memmove(keybuf, name, keysize);
 864                 keybuf[keysize] = '\0';
 865                 makelower(keybuf);
 866                 key = keybuf;
 867         }
 868         val = udbmatch(key, map->map_file, NULL);
 869         if (val == NULL)
 870                 return NULL;
 871         SM_TRY
 872                 if (bitset(MF_MATCHONLY, map->map_mflags))
 873                         result = map_rewrite(map, name, strlen(name), NULL);
 874                 else
 875                         result = map_rewrite(map, val, strlen(val), av);
 876         SM_FINALLY
 877                 sm_free(val);
 878         SM_END_TRY
 879         return result;
 880 }
 881 /*
 882 **  _UDBX_INIT -- parse the UDB specification, opening any valid entries.
 883 **
 884 **      Parameters:
 885 **              e -- the current envelope.
 886 **
 887 **      Returns:
 888 **              EX_TEMPFAIL -- if it appeared it couldn't get hold of a
 889 **                      database due to a host being down or some similar
 890 **                      (recoverable) situation.
 891 **              EX_OK -- otherwise.
 892 **
 893 **      Side Effects:
 894 **              Fills in the UdbEnts structure from UdbSpec.
 895 */
 896
 897 # define MAXUDBOPTS     27
 898
 899 static int
 900 _udbx_init(e)
 901         ENVELOPE *e;
 902 {
 903         int ents = 0;
 904         register char *p;
 905         register struct udbent *up;
 906
 907         if (UdbInitialized)
 908                 return EX_OK;
 909
 910 # ifdef UDB_DEFAULT_SPEC
 911         if (UdbSpec == NULL)
 912                 UdbSpec = UDB_DEFAULT_SPEC;
 913 # endif
 914
 915         p = UdbSpec;
 916         up = UdbEnts;
 917         while (p != NULL)
 918         {
 919                 char *spec;
 920 # if NEWDB
 921                 int l;
 922 # endif
 923                 struct udb_option opts[MAXUDBOPTS + 1];
 924
 925                 while (*p == ' ' || *p == '\t' || *p == ',')
 926                         p++;
 927                 if (*p == '\0')
 928                         break;
 929                 spec = p;
 930                 p = strchr(p, ',');
 931                 if (p != NULL)
 932                         *p++ = '\0';
 933
 934                 if (ents >= MAXUDBENT)
 935                 {
 936                         syserr("Maximum number of UDB entries exceeded");
 937                         break;
 938                 }
 939
 940                 /* extract options */
 941                 (void) _udb_parsespec(spec, opts, MAXUDBOPTS);
 942
 943                 /*
 944                 **  Decode database specification.
 945                 **
 946                 **      In the sendmail tradition, the leading character
 947                 **      defines the semantics of the rest of the entry.
 948                 **
 949                 **      @hostname --    forward email to the indicated host.
 950                 **                      This should be the last in the list,
 951                 **                      since it always matches the input.
 952                 **      /dbname  --     search the named database on the local
 953                 **                      host using the Berkeley db package.
 954                 **      Hesiod --       search the named database with BIND
 955                 **                      using the MIT Hesiod package.
 956                 */
 957
 958                 switch (*spec)
 959                 {
 960                   case '@':     /* forward to remote host */
 961                         up->udb_type = UDB_FORWARD;
 962                         up->udb_pid = CurrentPid;
 963                         up->udb_fwdhost = spec + 1;
 964                         ents++;
 965                         up++;
 966                         break;
 967
 968 # if HESIOD
 969                   case 'h':     /* use hesiod */
 970                   case 'H':
 971                         if (sm_strcasecmp(spec, "hesiod") != 0)
 972                                 goto badspec;
 973                         up->udb_type = UDB_HESIOD;
 974                         up->udb_pid = CurrentPid;
 975                         ents++;
 976                         up++;
 977                         break;
 978 # endif /* HESIOD */
 979
 980 # if NEWDB
 981                   case '/':     /* look up remote name */
 982                         l = strlen(spec);
 983                         if (l > 3 && strcmp(&spec[l - 3], ".db") == 0)
 984                         {
 985                                 up->udb_dbname = spec;
 986                         }
 987                         else
 988                         {
 989                                 up->udb_dbname = sm_pmalloc_x(l + 4);
 990                                 (void) sm_strlcpyn(up->udb_dbname, l + 4, 2,
 991                                                    spec, ".db");
 992                         }
 993                         errno = 0;
 994 #  if DB_VERSION_MAJOR < 2
 995                         up->udb_dbp = dbopen(up->udb_dbname, O_RDONLY,
 996                                              0644, DB_BTREE, NULL);
 997 #  else /* DB_VERSION_MAJOR < 2 */
 998                         {
 999                                 int flags = DB_RDONLY;
1000 #  if DB_VERSION_MAJOR > 2
1001                                 int ret;
1002 #  endif /* DB_VERSION_MAJOR > 2 */
1003
1004                                 SM_DB_FLAG_ADD(flags);
1005                                 up->udb_dbp = NULL;
1006 #  if DB_VERSION_MAJOR > 2
1007                                 ret = db_create(&up->udb_dbp, NULL, 0);
1008                                 if (ret != 0)
1009                                 {
1010                                         (void) up->udb_dbp->close(up->udb_dbp,
1011                                                                   0);
1012                                         up->udb_dbp = NULL;
1013                                 }
1014                                 else
1015                                 {
1016                                         ret = up->udb_dbp->open(up->udb_dbp,
1017                                                                 DBTXN
1018                                                                 up->udb_dbname,
1019                                                                 NULL,
1020                                                                 DB_BTREE,
1021                                                                 flags,
1022                                                                 0644);
1023                                         if (ret != 0)
1024                                         {
1025 #ifdef DB_OLD_VERSION
1026                                                 if (ret == DB_OLD_VERSION)
1027                                                         ret = EINVAL;
1028 #endif
1029                                                 (void) up->udb_dbp->close(up->udb_dbp, 0);
1030                                                 up->udb_dbp = NULL;
1031                                         }
1032                                 }
1033                                 errno = ret;
1034 #  else /* DB_VERSION_MAJOR > 2 */
1035                                 errno = db_open(up->udb_dbname, DB_BTREE,
1036                                                 flags, 0644, NULL,
1037                                                 NULL, &up->udb_dbp);
1038 #  endif /* DB_VERSION_MAJOR > 2 */
1039                         }
1040 #  endif /* DB_VERSION_MAJOR < 2 */
1041                         if (up->udb_dbp == NULL)
1042                         {
1043                                 if (tTd(28, 1))
1044                                 {
1045                                         int save_errno = errno;
1046
1047 #  if DB_VERSION_MAJOR < 2
1048                                         sm_dprintf("dbopen(%s): %s\n",
1049 #  else /* DB_VERSION_MAJOR < 2 */
1050                                         sm_dprintf("db_open(%s): %s\n",
1051 #  endif /* DB_VERSION_MAJOR < 2 */
1052                                                 up->udb_dbname,
1053                                                 sm_errstring(errno));
1054                                         errno = save_errno;
1055                                 }
1056                                 if (errno != ENOENT && errno != EACCES)
1057                                 {
1058                                         if (LogLevel > 2)
1059                                                 sm_syslog(LOG_ERR, e->e_id,
1060 #  if DB_VERSION_MAJOR < 2
1061                                                           "dbopen(%s): %s",
1062 #  else /* DB_VERSION_MAJOR < 2 */
1063                                                           "db_open(%s): %s",
1064 #  endif /* DB_VERSION_MAJOR < 2 */
1065                                                           up->udb_dbname,
1066                                                           sm_errstring(errno));
1067                                         up->udb_type = UDB_EOLIST;
1068                                         if (up->udb_dbname != spec)
1069                                                 sm_free(up->udb_dbname); /* XXX */
1070                                         goto tempfail;
1071                                 }
1072                                 if (up->udb_dbname != spec)
1073                                         sm_free(up->udb_dbname); /* XXX */
1074                                 break;
1075                         }
1076                         if (tTd(28, 1))
1077                         {
1078 #  if DB_VERSION_MAJOR < 2
1079                                 sm_dprintf("_udbx_init: dbopen(%s)\n",
1080 #  else /* DB_VERSION_MAJOR < 2 */
1081                                 sm_dprintf("_udbx_init: db_open(%s)\n",
1082 #  endif /* DB_VERSION_MAJOR < 2 */
1083                                         up->udb_dbname);
1084                         }
1085                         up->udb_type = UDB_DBFETCH;
1086                         up->udb_pid = CurrentPid;
1087                         ents++;
1088                         up++;
1089                         break;
1090 # endif /* NEWDB */
1091
1092                   default:
1093 # if HESIOD
1094 badspec:
1095 # endif
1096                         syserr("Unknown UDB spec %s", spec);
1097                         break;
1098                 }
1099         }
1100         up->udb_type = UDB_EOLIST;
1101
1102         if (tTd(28, 4))
1103         {
1104                 for (up = UdbEnts; up->udb_type != UDB_EOLIST; up++)
1105                 {
1106                         switch (up->udb_type)
1107                         {
1108                           case UDB_REMOTE:
1109                                 sm_dprintf("REMOTE: addr %s, timeo %d\n",
1110                                            anynet_ntoa((SOCKADDR *) &up->udb_addr),
1111                                            up->udb_timeout);
1112                                 break;
1113
1114                           case UDB_DBFETCH:
1115 # if NEWDB
1116                                 sm_dprintf("FETCH: file %s\n", up->udb_dbname);
1117 # else
1118                                 sm_dprintf("FETCH\n");
1119 # endif
1120                                 break;
1121
1122                           case UDB_FORWARD:
1123                                 sm_dprintf("FORWARD: host %s\n",
1124                                         up->udb_fwdhost);
1125                                 break;
1126
1127                           case UDB_HESIOD:
1128                                 sm_dprintf("HESIOD\n");
1129                                 break;
1130
1131                           default:
1132                                 sm_dprintf("UNKNOWN\n");
1133                                 break;
1134                         }
1135                 }
1136         }
1137
1138         UdbInitialized = true;
1139         errno = 0;
1140         return EX_OK;
1141
1142         /*
1143         **  On temporary failure, back out anything we've already done
1144         */
1145
1146 # if NEWDB
1147   tempfail:
1148         for (up = UdbEnts; up->udb_type != UDB_EOLIST; up++)
1149         {
1150                 if (up->udb_type == UDB_DBFETCH)
1151                 {
1152 #  if DB_VERSION_MAJOR < 2
1153                         (*up->udb_dbp->close)(up->udb_dbp);
1154 #  else
1155                         errno = (*up->udb_dbp->close)(up->udb_dbp, 0);
1156 #  endif
1157                         if (tTd(28, 1))
1158                                 sm_dprintf("_udbx_init: db->close(%s)\n",
1159                                         up->udb_dbname);
1160                 }
1161         }
1162 # endif /* NEWDB */
1163         return EX_TEMPFAIL;
1164 }
1165
1166 static int
1167 _udb_parsespec(udbspec, opt, maxopts)
1168         char *udbspec;
1169         struct udb_option opt[];
1170         int maxopts;
1171 {
1172         register char *spec;
1173         register char *spec_end;
1174         register int optnum;
1175
1176         spec_end = strchr(udbspec, ':');
1177         for (optnum = 0; optnum < maxopts && (spec = spec_end) != NULL; optnum++)
1178         {
1179                 register char *p;
1180
1181                 while (SM_ISSPACE(*spec))
1182                         spec++;
1183                 spec_end = strchr(spec, ':');
1184                 if (spec_end != NULL)
1185                         *spec_end++ = '\0';
1186
1187                 opt[optnum].udbo_name = spec;
1188                 opt[optnum].udbo_val = NULL;
1189                 p = strchr(spec, '=');
1190                 if (p != NULL)
1191                         opt[optnum].udbo_val = ++p;
1192         }
1193         return optnum;
1194 }
1195 /*
1196 **  _UDBX_CLOSE -- close all file based UDB entries.
1197 **
1198 **      Parameters:
1199 **              none
1200 **
1201 **      Returns:
1202 **              none
1203 */
1204 void
1205 _udbx_close()
1206 {
1207         struct udbent *up;
1208
1209         if (!UdbInitialized)
1210                 return;
1211
1212         for (up = UdbEnts; up->udb_type != UDB_EOLIST; up++)
1213         {
1214                 if (up->udb_pid != CurrentPid)
1215                         continue;
1216
1217 # if NEWDB
1218                 if (up->udb_type == UDB_DBFETCH)
1219                 {
1220 #  if DB_VERSION_MAJOR < 2
1221                         (*up->udb_dbp->close)(up->udb_dbp);
1222 #  else
1223                         errno = (*up->udb_dbp->close)(up->udb_dbp, 0);
1224 #  endif
1225                 }
1226                 if (tTd(28, 1))
1227                         sm_dprintf("_udbx_close: db->close(%s)\n",
1228                                 up->udb_dbname);
1229 # endif /* NEWDB */
1230         }
1231 }
1232
1233 # if HESIOD
1234
1235 static int
1236 hes_udb_get(key, info)
1237         DBT *key;
1238         DBT *info;
1239 {
1240         char *name, *type;
1241         char **hp;
1242         char kbuf[MAXUDBKEY + 1];
1243
1244         if (sm_strlcpy(kbuf, key->data, sizeof(kbuf)) >= sizeof(kbuf))
1245                 return 0;
1246         name = kbuf;
1247         type = strrchr(name, ':');
1248         if (type == NULL)
1249                 return 1;
1250         *type++ = '\0';
1251         if (strchr(name, '@') != NULL)
1252                 return 1;
1253
1254         if (tTd(28, 1))
1255                 sm_dprintf("hes_udb_get(%s, %s)\n", name, type);
1256
1257         /* make the hesiod query */
1258 #  ifdef HESIOD_INIT
1259         if (HesiodContext == NULL && hesiod_init(&HesiodContext) != 0)
1260                 return -1;
1261         hp = hesiod_resolve(HesiodContext, name, type);
1262 #  else
1263         hp = hes_resolve(name, type);
1264 #  endif
1265         *--type = ':';
1266 #  ifdef HESIOD_INIT
1267         if (hp == NULL)
1268                 return 1;
1269         if (*hp == NULL)
1270         {
1271                 hesiod_free_list(HesiodContext, hp);
1272                 if (errno == ECONNREFUSED || errno == EMSGSIZE)
1273                         return -1;
1274                 return 1;
1275         }
1276 #  else /* HESIOD_INIT */
1277         if (hp == NULL || hp[0] == NULL)
1278         {
1279                 /* network problem or timeout */
1280                 if (hes_error() == HES_ER_NET)
1281                         return -1;
1282
1283                 return 1;
1284         }
1285 #  endif /* HESIOD_INIT */
1286         else
1287         {
1288                 /*
1289                 **  If there are multiple matches, just return the
1290                 **  first one.
1291                 **
1292                 **  XXX These should really be returned; for example,
1293                 **  XXX it is legal for :maildrop to be multi-valued.
1294                 */
1295
1296                 info->data = hp[0];
1297                 info->size = (size_t) strlen(info->data);
1298         }
1299
1300         if (tTd(28, 80))
1301                 sm_dprintf("hes_udb_get => %s\n", *hp);
1302
1303         return 0;
1304 }
1305 # endif /* HESIOD */
1306
1307 #else /* USERDB */
1308
1309 int
1310 udbexpand(a, sendq, aliaslevel, e)
1311         ADDRESS *a;
1312         ADDRESS **sendq;
1313         int aliaslevel;
1314         ENVELOPE *e;
1315 {
1316         return EX_OK;
1317 }
1318
1319 #endif /* USERDB */