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