1 /* 2 * Copyright (c) 1998-2010, 2012 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 <sm/time.h> 16 17 SM_RCSID("@(#)$Id: deliver.c,v 8.1028 2013/01/02 18:57:42 ca Exp $") 18 19 #if HASSETUSERCONTEXT 20 # include <login_cap.h> 21 #endif /* HASSETUSERCONTEXT */ 22 23 #if NETINET || NETINET6 24 # include <arpa/inet.h> 25 #endif /* NETINET || NETINET6 */ 26 27 #if STARTTLS || SASL 28 # include "sfsasl.h" 29 #endif /* STARTTLS || SASL */ 30 31 static int deliver __P((ENVELOPE *, ADDRESS *)); 32 static void dup_queue_file __P((ENVELOPE *, ENVELOPE *, int)); 33 static void mailfiletimeout __P((int)); 34 static void endwaittimeout __P((int)); 35 static int parse_hostsignature __P((char *, char **, MAILER *)); 36 static void sendenvelope __P((ENVELOPE *, int)); 37 static int coloncmp __P((const char *, const char *)); 38 39 #if STARTTLS 40 # include <openssl/err.h> 41 static int starttls __P((MAILER *, MCI *, ENVELOPE *)); 42 static int endtlsclt __P((MCI *)); 43 #endif /* STARTTLS */ 44 # if STARTTLS || SASL 45 static bool iscltflgset __P((ENVELOPE *, int)); 46 # endif /* STARTTLS || SASL */ 47 48 /* 49 ** SENDALL -- actually send all the messages. 50 ** 51 ** Parameters: 52 ** e -- the envelope to send. 53 ** mode -- the delivery mode to use. If SM_DEFAULT, use 54 ** the current e->e_sendmode. 55 ** 56 ** Returns: 57 ** none. 58 ** 59 ** Side Effects: 60 ** Scans the send lists and sends everything it finds. 61 ** Delivers any appropriate error messages. 62 ** If we are running in a non-interactive mode, takes the 63 ** appropriate action. 64 */ 65 66 void 67 sendall(e, mode) 68 ENVELOPE *e; 69 int mode; 70 { 71 register ADDRESS *q; 72 char *owner; 73 int otherowners; 74 int save_errno; 75 register ENVELOPE *ee; 76 ENVELOPE *splitenv = NULL; 77 int oldverbose = Verbose; 78 bool somedeliveries = false, expensive = false; 79 pid_t pid; 80 81 /* 82 ** If this message is to be discarded, don't bother sending 83 ** the message at all. 84 */ 85 86 if (bitset(EF_DISCARD, e->e_flags)) 87 { 88 if (tTd(13, 1)) 89 sm_dprintf("sendall: discarding id %s\n", e->e_id); 90 e->e_flags |= EF_CLRQUEUE; 91 if (LogLevel > 9) 92 logundelrcpts(e, "discarded", 9, true); 93 else if (LogLevel > 4) 94 sm_syslog(LOG_INFO, e->e_id, "discarded"); 95 markstats(e, NULL, STATS_REJECT); 96 return; 97 } 98 99 /* 100 ** If we have had global, fatal errors, don't bother sending 101 ** the message at all if we are in SMTP mode. Local errors 102 ** (e.g., a single address failing) will still cause the other 103 ** addresses to be sent. 104 */ 105 106 if (bitset(EF_FATALERRS, e->e_flags) && 107 (OpMode == MD_SMTP || OpMode == MD_DAEMON)) 108 { 109 e->e_flags |= EF_CLRQUEUE; 110 return; 111 } 112 113 /* determine actual delivery mode */ 114 if (mode == SM_DEFAULT) 115 { 116 mode = e->e_sendmode; 117 if (mode != SM_VERIFY && mode != SM_DEFER && 118 shouldqueue(e->e_msgpriority, e->e_ctime)) 119 mode = SM_QUEUE; 120 } 121 122 if (tTd(13, 1)) 123 { 124 sm_dprintf("\n===== SENDALL: mode %c, id %s, e_from ", 125 mode, e->e_id); 126 printaddr(sm_debug_file(), &e->e_from, false); 127 sm_dprintf("\te_flags = "); 128 printenvflags(e); 129 sm_dprintf("sendqueue:\n"); 130 printaddr(sm_debug_file(), e->e_sendqueue, true); 131 } 132 133 /* 134 ** Do any preprocessing necessary for the mode we are running. 135 ** Check to make sure the hop count is reasonable. 136 ** Delete sends to the sender in mailing lists. 137 */ 138 139 CurEnv = e; 140 if (tTd(62, 1)) 141 checkfds(NULL); 142 143 if (e->e_hopcount > MaxHopCount) 144 { 145 char *recip; 146 147 if (e->e_sendqueue != NULL && 148 e->e_sendqueue->q_paddr != NULL) 149 recip = e->e_sendqueue->q_paddr; 150 else 151 recip = "(nobody)"; 152 153 errno = 0; 154 queueup(e, WILL_BE_QUEUED(mode), false); 155 e->e_flags |= EF_FATALERRS|EF_PM_NOTIFY|EF_CLRQUEUE; 156 ExitStat = EX_UNAVAILABLE; 157 syserr("554 5.4.6 Too many hops %d (%d max): from %s via %s, to %s", 158 e->e_hopcount, MaxHopCount, e->e_from.q_paddr, 159 RealHostName == NULL ? "localhost" : RealHostName, 160 recip); 161 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 162 { 163 if (QS_IS_DEAD(q->q_state)) 164 continue; 165 q->q_state = QS_BADADDR; 166 q->q_status = "5.4.6"; 167 q->q_rstatus = "554 5.4.6 Too many hops"; 168 } 169 return; 170 } 171 172 /* 173 ** Do sender deletion. 174 ** 175 ** If the sender should be queued up, skip this. 176 ** This can happen if the name server is hosed when you 177 ** are trying to send mail. The result is that the sender 178 ** is instantiated in the queue as a recipient. 179 */ 180 181 if (!bitset(EF_METOO, e->e_flags) && 182 !QS_IS_QUEUEUP(e->e_from.q_state)) 183 { 184 if (tTd(13, 5)) 185 { 186 sm_dprintf("sendall: QS_SENDER "); 187 printaddr(sm_debug_file(), &e->e_from, false); 188 } 189 e->e_from.q_state = QS_SENDER; 190 (void) recipient(&e->e_from, &e->e_sendqueue, 0, e); 191 } 192 193 /* 194 ** Handle alias owners. 195 ** 196 ** We scan up the q_alias chain looking for owners. 197 ** We discard owners that are the same as the return path. 198 */ 199 200 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 201 { 202 register struct address *a; 203 204 for (a = q; a != NULL && a->q_owner == NULL; a = a->q_alias) 205 continue; 206 if (a != NULL) 207 q->q_owner = a->q_owner; 208 209 if (q->q_owner != NULL && 210 !QS_IS_DEAD(q->q_state) && 211 strcmp(q->q_owner, e->e_from.q_paddr) == 0) 212 q->q_owner = NULL; 213 } 214 215 if (tTd(13, 25)) 216 { 217 sm_dprintf("\nAfter first owner pass, sendq =\n"); 218 printaddr(sm_debug_file(), e->e_sendqueue, true); 219 } 220 221 owner = ""; 222 otherowners = 1; 223 while (owner != NULL && otherowners > 0) 224 { 225 if (tTd(13, 28)) 226 sm_dprintf("owner = \"%s\", otherowners = %d\n", 227 owner, otherowners); 228 owner = NULL; 229 otherowners = bitset(EF_SENDRECEIPT, e->e_flags) ? 1 : 0; 230 231 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 232 { 233 if (tTd(13, 30)) 234 { 235 sm_dprintf("Checking "); 236 printaddr(sm_debug_file(), q, false); 237 } 238 if (QS_IS_DEAD(q->q_state)) 239 { 240 if (tTd(13, 30)) 241 sm_dprintf(" ... QS_IS_DEAD\n"); 242 continue; 243 } 244 if (tTd(13, 29) && !tTd(13, 30)) 245 { 246 sm_dprintf("Checking "); 247 printaddr(sm_debug_file(), q, false); 248 } 249 250 if (q->q_owner != NULL) 251 { 252 if (owner == NULL) 253 { 254 if (tTd(13, 40)) 255 sm_dprintf(" ... First owner = \"%s\"\n", 256 q->q_owner); 257 owner = q->q_owner; 258 } 259 else if (owner != q->q_owner) 260 { 261 if (strcmp(owner, q->q_owner) == 0) 262 { 263 if (tTd(13, 40)) 264 sm_dprintf(" ... Same owner = \"%s\"\n", 265 owner); 266 267 /* make future comparisons cheap */ 268 q->q_owner = owner; 269 } 270 else 271 { 272 if (tTd(13, 40)) 273 sm_dprintf(" ... Another owner \"%s\"\n", 274 q->q_owner); 275 otherowners++; 276 } 277 owner = q->q_owner; 278 } 279 else if (tTd(13, 40)) 280 sm_dprintf(" ... Same owner = \"%s\"\n", 281 owner); 282 } 283 else 284 { 285 if (tTd(13, 40)) 286 sm_dprintf(" ... Null owner\n"); 287 otherowners++; 288 } 289 290 if (QS_IS_BADADDR(q->q_state)) 291 { 292 if (tTd(13, 30)) 293 sm_dprintf(" ... QS_IS_BADADDR\n"); 294 continue; 295 } 296 297 if (QS_IS_QUEUEUP(q->q_state)) 298 { 299 MAILER *m = q->q_mailer; 300 301 /* 302 ** If we have temporary address failures 303 ** (e.g., dns failure) and a fallback MX is 304 ** set, send directly to the fallback MX host. 305 */ 306 307 if (FallbackMX != NULL && 308 !wordinclass(FallbackMX, 'w') && 309 mode != SM_VERIFY && 310 !bitnset(M_NOMX, m->m_flags) && 311 strcmp(m->m_mailer, "[IPC]") == 0 && 312 m->m_argv[0] != NULL && 313 strcmp(m->m_argv[0], "TCP") == 0) 314 { 315 int len; 316 char *p; 317 318 if (tTd(13, 30)) 319 sm_dprintf(" ... FallbackMX\n"); 320 321 len = strlen(FallbackMX) + 1; 322 p = sm_rpool_malloc_x(e->e_rpool, len); 323 (void) sm_strlcpy(p, FallbackMX, len); 324 q->q_state = QS_OK; 325 q->q_host = p; 326 } 327 else 328 { 329 if (tTd(13, 30)) 330 sm_dprintf(" ... QS_IS_QUEUEUP\n"); 331 continue; 332 } 333 } 334 335 /* 336 ** If this mailer is expensive, and if we don't 337 ** want to make connections now, just mark these 338 ** addresses and return. This is useful if we 339 ** want to batch connections to reduce load. This 340 ** will cause the messages to be queued up, and a 341 ** daemon will come along to send the messages later. 342 */ 343 344 if (NoConnect && !Verbose && 345 bitnset(M_EXPENSIVE, q->q_mailer->m_flags)) 346 { 347 if (tTd(13, 30)) 348 sm_dprintf(" ... expensive\n"); 349 q->q_state = QS_QUEUEUP; 350 expensive = true; 351 } 352 else if (bitnset(M_HOLD, q->q_mailer->m_flags) && 353 QueueLimitId == NULL && 354 QueueLimitSender == NULL && 355 QueueLimitRecipient == NULL) 356 { 357 if (tTd(13, 30)) 358 sm_dprintf(" ... hold\n"); 359 q->q_state = QS_QUEUEUP; 360 expensive = true; 361 } 362 else if (QueueMode != QM_QUARANTINE && 363 e->e_quarmsg != NULL) 364 { 365 if (tTd(13, 30)) 366 sm_dprintf(" ... quarantine: %s\n", 367 e->e_quarmsg); 368 q->q_state = QS_QUEUEUP; 369 expensive = true; 370 } 371 else 372 { 373 if (tTd(13, 30)) 374 sm_dprintf(" ... deliverable\n"); 375 somedeliveries = true; 376 } 377 } 378 379 if (owner != NULL && otherowners > 0) 380 { 381 /* 382 ** Split this envelope into two. 383 */ 384 385 ee = (ENVELOPE *) sm_rpool_malloc_x(e->e_rpool, 386 sizeof(*ee)); 387 STRUCTCOPY(*e, *ee); 388 ee->e_message = NULL; 389 ee->e_id = NULL; 390 assign_queueid(ee); 391 392 if (tTd(13, 1)) 393 sm_dprintf("sendall: split %s into %s, owner = \"%s\", otherowners = %d\n", 394 e->e_id, ee->e_id, owner, 395 otherowners); 396 397 ee->e_header = copyheader(e->e_header, ee->e_rpool); 398 ee->e_sendqueue = copyqueue(e->e_sendqueue, 399 ee->e_rpool); 400 ee->e_errorqueue = copyqueue(e->e_errorqueue, 401 ee->e_rpool); 402 ee->e_flags = e->e_flags & ~(EF_INQUEUE|EF_CLRQUEUE|EF_FATALERRS|EF_SENDRECEIPT|EF_RET_PARAM); 403 ee->e_flags |= EF_NORECEIPT; 404 setsender(owner, ee, NULL, '\0', true); 405 if (tTd(13, 5)) 406 { 407 sm_dprintf("sendall(split): QS_SENDER "); 408 printaddr(sm_debug_file(), &ee->e_from, false); 409 } 410 ee->e_from.q_state = QS_SENDER; 411 ee->e_dfp = NULL; 412 ee->e_lockfp = NULL; 413 ee->e_xfp = NULL; 414 ee->e_qgrp = e->e_qgrp; 415 ee->e_qdir = e->e_qdir; 416 ee->e_errormode = EM_MAIL; 417 ee->e_sibling = splitenv; 418 ee->e_statmsg = NULL; 419 if (e->e_quarmsg != NULL) 420 ee->e_quarmsg = sm_rpool_strdup_x(ee->e_rpool, 421 e->e_quarmsg); 422 splitenv = ee; 423 424 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 425 { 426 if (q->q_owner == owner) 427 { 428 q->q_state = QS_CLONED; 429 if (tTd(13, 6)) 430 sm_dprintf("\t... stripping %s from original envelope\n", 431 q->q_paddr); 432 } 433 } 434 for (q = ee->e_sendqueue; q != NULL; q = q->q_next) 435 { 436 if (q->q_owner != owner) 437 { 438 q->q_state = QS_CLONED; 439 if (tTd(13, 6)) 440 sm_dprintf("\t... dropping %s from cloned envelope\n", 441 q->q_paddr); 442 } 443 else 444 { 445 /* clear DSN parameters */ 446 q->q_flags &= ~(QHASNOTIFY|Q_PINGFLAGS); 447 q->q_flags |= DefaultNotify & ~QPINGONSUCCESS; 448 if (tTd(13, 6)) 449 sm_dprintf("\t... moving %s to cloned envelope\n", 450 q->q_paddr); 451 } 452 } 453 454 if (mode != SM_VERIFY && bitset(EF_HAS_DF, e->e_flags)) 455 dup_queue_file(e, ee, DATAFL_LETTER); 456 457 /* 458 ** Give the split envelope access to the parent 459 ** transcript file for errors obtained while 460 ** processing the recipients (done before the 461 ** envelope splitting). 462 */ 463 464 if (e->e_xfp != NULL) 465 ee->e_xfp = sm_io_dup(e->e_xfp); 466 467 /* failed to dup e->e_xfp, start a new transcript */ 468 if (ee->e_xfp == NULL) 469 openxscript(ee); 470 471 if (mode != SM_VERIFY && LogLevel > 4) 472 sm_syslog(LOG_INFO, e->e_id, 473 "%s: clone: owner=%s", 474 ee->e_id, owner); 475 } 476 } 477 478 if (owner != NULL) 479 { 480 setsender(owner, e, NULL, '\0', true); 481 if (tTd(13, 5)) 482 { 483 sm_dprintf("sendall(owner): QS_SENDER "); 484 printaddr(sm_debug_file(), &e->e_from, false); 485 } 486 e->e_from.q_state = QS_SENDER; 487 e->e_errormode = EM_MAIL; 488 e->e_flags |= EF_NORECEIPT; 489 e->e_flags &= ~EF_FATALERRS; 490 } 491 492 /* if nothing to be delivered, just queue up everything */ 493 if (!somedeliveries && !WILL_BE_QUEUED(mode) && 494 mode != SM_VERIFY) 495 { 496 time_t now; 497 498 if (tTd(13, 29)) 499 sm_dprintf("No deliveries: auto-queueing\n"); 500 mode = SM_QUEUE; 501 now = curtime(); 502 503 /* treat this as a delivery in terms of counting tries */ 504 e->e_dtime = now; 505 if (!expensive) 506 e->e_ntries++; 507 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 508 { 509 ee->e_dtime = now; 510 if (!expensive) 511 ee->e_ntries++; 512 } 513 } 514 515 if ((WILL_BE_QUEUED(mode) || mode == SM_FORK || 516 (mode != SM_VERIFY && 517 (SuperSafe == SAFE_REALLY || 518 SuperSafe == SAFE_REALLY_POSTMILTER))) && 519 (!bitset(EF_INQUEUE, e->e_flags) || splitenv != NULL)) 520 { 521 bool msync; 522 523 /* 524 ** Be sure everything is instantiated in the queue. 525 ** Split envelopes first in case the machine crashes. 526 ** If the original were done first, we may lose 527 ** recipients. 528 */ 529 530 #if !HASFLOCK 531 msync = false; 532 #else /* !HASFLOCK */ 533 msync = mode == SM_FORK; 534 #endif /* !HASFLOCK */ 535 536 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 537 queueup(ee, WILL_BE_QUEUED(mode), msync); 538 queueup(e, WILL_BE_QUEUED(mode), msync); 539 } 540 541 if (tTd(62, 10)) 542 checkfds("after envelope splitting"); 543 544 /* 545 ** If we belong in background, fork now. 546 */ 547 548 if (tTd(13, 20)) 549 { 550 sm_dprintf("sendall: final mode = %c\n", mode); 551 if (tTd(13, 21)) 552 { 553 sm_dprintf("\n================ Final Send Queue(s) =====================\n"); 554 sm_dprintf("\n *** Envelope %s, e_from=%s ***\n", 555 e->e_id, e->e_from.q_paddr); 556 printaddr(sm_debug_file(), e->e_sendqueue, true); 557 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 558 { 559 sm_dprintf("\n *** Envelope %s, e_from=%s ***\n", 560 ee->e_id, ee->e_from.q_paddr); 561 printaddr(sm_debug_file(), ee->e_sendqueue, true); 562 } 563 sm_dprintf("==========================================================\n\n"); 564 } 565 } 566 switch (mode) 567 { 568 case SM_VERIFY: 569 Verbose = 2; 570 break; 571 572 case SM_QUEUE: 573 case SM_DEFER: 574 #if HASFLOCK 575 queueonly: 576 #endif /* HASFLOCK */ 577 if (e->e_nrcpts > 0) 578 e->e_flags |= EF_INQUEUE; 579 (void) dropenvelope(e, splitenv != NULL, true); 580 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 581 { 582 if (ee->e_nrcpts > 0) 583 ee->e_flags |= EF_INQUEUE; 584 (void) dropenvelope(ee, false, true); 585 } 586 return; 587 588 case SM_FORK: 589 if (e->e_xfp != NULL) 590 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT); 591 592 #if !HASFLOCK 593 /* 594 ** Since fcntl locking has the interesting semantic that 595 ** the lock is owned by a process, not by an open file 596 ** descriptor, we have to flush this to the queue, and 597 ** then restart from scratch in the child. 598 */ 599 600 { 601 /* save id for future use */ 602 char *qid = e->e_id; 603 604 /* now drop the envelope in the parent */ 605 e->e_flags |= EF_INQUEUE; 606 (void) dropenvelope(e, splitenv != NULL, false); 607 608 /* arrange to reacquire lock after fork */ 609 e->e_id = qid; 610 } 611 612 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 613 { 614 /* save id for future use */ 615 char *qid = ee->e_id; 616 617 /* drop envelope in parent */ 618 ee->e_flags |= EF_INQUEUE; 619 (void) dropenvelope(ee, false, false); 620 621 /* and save qid for reacquisition */ 622 ee->e_id = qid; 623 } 624 625 #endif /* !HASFLOCK */ 626 627 /* 628 ** Since the delivery may happen in a child and the parent 629 ** does not wait, the parent may close the maps thereby 630 ** removing any shared memory used by the map. Therefore, 631 ** close the maps now so the child will dynamically open 632 ** them if necessary. 633 */ 634 635 closemaps(false); 636 637 pid = fork(); 638 if (pid < 0) 639 { 640 syserr("deliver: fork 1"); 641 #if HASFLOCK 642 goto queueonly; 643 #else /* HASFLOCK */ 644 e->e_id = NULL; 645 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 646 ee->e_id = NULL; 647 return; 648 #endif /* HASFLOCK */ 649 } 650 else if (pid > 0) 651 { 652 #if HASFLOCK 653 /* be sure we leave the temp files to our child */ 654 /* close any random open files in the envelope */ 655 closexscript(e); 656 if (e->e_dfp != NULL) 657 (void) sm_io_close(e->e_dfp, SM_TIME_DEFAULT); 658 e->e_dfp = NULL; 659 e->e_flags &= ~EF_HAS_DF; 660 661 /* can't call unlockqueue to avoid unlink of xfp */ 662 if (e->e_lockfp != NULL) 663 (void) sm_io_close(e->e_lockfp, SM_TIME_DEFAULT); 664 else 665 syserr("%s: sendall: null lockfp", e->e_id); 666 e->e_lockfp = NULL; 667 #endif /* HASFLOCK */ 668 669 /* make sure the parent doesn't own the envelope */ 670 e->e_id = NULL; 671 672 #if USE_DOUBLE_FORK 673 /* catch intermediate zombie */ 674 (void) waitfor(pid); 675 #endif /* USE_DOUBLE_FORK */ 676 return; 677 } 678 679 /* Reset global flags */ 680 RestartRequest = NULL; 681 RestartWorkGroup = false; 682 ShutdownRequest = NULL; 683 PendingSignal = 0; 684 685 /* 686 ** Initialize exception stack and default exception 687 ** handler for child process. 688 */ 689 690 sm_exc_newthread(fatal_error); 691 692 /* 693 ** Since we have accepted responsbility for the message, 694 ** change the SIGTERM handler. intsig() (the old handler) 695 ** would remove the envelope if this was a command line 696 ** message submission. 697 */ 698 699 (void) sm_signal(SIGTERM, SIG_DFL); 700 701 #if USE_DOUBLE_FORK 702 /* double fork to avoid zombies */ 703 pid = fork(); 704 if (pid > 0) 705 exit(EX_OK); 706 save_errno = errno; 707 #endif /* USE_DOUBLE_FORK */ 708 709 CurrentPid = getpid(); 710 711 /* be sure we are immune from the terminal */ 712 disconnect(2, e); 713 clearstats(); 714 715 /* prevent parent from waiting if there was an error */ 716 if (pid < 0) 717 { 718 errno = save_errno; 719 syserr("deliver: fork 2"); 720 #if HASFLOCK 721 e->e_flags |= EF_INQUEUE; 722 #else /* HASFLOCK */ 723 e->e_id = NULL; 724 #endif /* HASFLOCK */ 725 finis(true, true, ExitStat); 726 } 727 728 /* be sure to give error messages in child */ 729 QuickAbort = false; 730 731 /* 732 ** Close any cached connections. 733 ** 734 ** We don't send the QUIT protocol because the parent 735 ** still knows about the connection. 736 ** 737 ** This should only happen when delivering an error 738 ** message. 739 */ 740 741 mci_flush(false, NULL); 742 743 #if HASFLOCK 744 break; 745 #else /* HASFLOCK */ 746 747 /* 748 ** Now reacquire and run the various queue files. 749 */ 750 751 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 752 { 753 ENVELOPE *sibling = ee->e_sibling; 754 755 (void) dowork(ee->e_qgrp, ee->e_qdir, ee->e_id, 756 false, false, ee); 757 ee->e_sibling = sibling; 758 } 759 (void) dowork(e->e_qgrp, e->e_qdir, e->e_id, 760 false, false, e); 761 finis(true, true, ExitStat); 762 #endif /* HASFLOCK */ 763 } 764 765 sendenvelope(e, mode); 766 (void) dropenvelope(e, true, true); 767 for (ee = splitenv; ee != NULL; ee = ee->e_sibling) 768 { 769 CurEnv = ee; 770 if (mode != SM_VERIFY) 771 openxscript(ee); 772 sendenvelope(ee, mode); 773 (void) dropenvelope(ee, true, true); 774 } 775 CurEnv = e; 776 777 Verbose = oldverbose; 778 if (mode == SM_FORK) 779 finis(true, true, ExitStat); 780 } 781 782 static void 783 sendenvelope(e, mode) 784 register ENVELOPE *e; 785 int mode; 786 { 787 register ADDRESS *q; 788 bool didany; 789 790 if (tTd(13, 10)) 791 sm_dprintf("sendenvelope(%s) e_flags=0x%lx\n", 792 e->e_id == NULL ? "[NOQUEUE]" : e->e_id, 793 e->e_flags); 794 if (LogLevel > 80) 795 sm_syslog(LOG_DEBUG, e->e_id, 796 "sendenvelope, flags=0x%lx", 797 e->e_flags); 798 799 /* 800 ** If we have had global, fatal errors, don't bother sending 801 ** the message at all if we are in SMTP mode. Local errors 802 ** (e.g., a single address failing) will still cause the other 803 ** addresses to be sent. 804 */ 805 806 if (bitset(EF_FATALERRS, e->e_flags) && 807 (OpMode == MD_SMTP || OpMode == MD_DAEMON)) 808 { 809 e->e_flags |= EF_CLRQUEUE; 810 return; 811 } 812 813 /* 814 ** Don't attempt deliveries if we want to bounce now 815 ** or if deliver-by time is exceeded. 816 */ 817 818 if (!bitset(EF_RESPONSE, e->e_flags) && 819 (TimeOuts.to_q_return[e->e_timeoutclass] == NOW || 820 (IS_DLVR_RETURN(e) && e->e_deliver_by > 0 && 821 curtime() > e->e_ctime + e->e_deliver_by))) 822 return; 823 824 /* 825 ** Run through the list and send everything. 826 ** 827 ** Set EF_GLOBALERRS so that error messages during delivery 828 ** result in returned mail. 829 */ 830 831 e->e_nsent = 0; 832 e->e_flags |= EF_GLOBALERRS; 833 834 macdefine(&e->e_macro, A_PERM, macid("{envid}"), e->e_envid); 835 macdefine(&e->e_macro, A_PERM, macid("{bodytype}"), e->e_bodytype); 836 didany = false; 837 838 if (!bitset(EF_SPLIT, e->e_flags)) 839 { 840 ENVELOPE *oldsib; 841 ENVELOPE *ee; 842 843 /* 844 ** Save old sibling and set it to NULL to avoid 845 ** queueing up the same envelopes again. 846 ** This requires that envelopes in that list have 847 ** been take care of before (or at some other place). 848 */ 849 850 oldsib = e->e_sibling; 851 e->e_sibling = NULL; 852 if (!split_by_recipient(e) && 853 bitset(EF_FATALERRS, e->e_flags)) 854 { 855 if (OpMode == MD_SMTP || OpMode == MD_DAEMON) 856 e->e_flags |= EF_CLRQUEUE; 857 return; 858 } 859 for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling) 860 queueup(ee, false, true); 861 862 /* clean up */ 863 for (ee = e->e_sibling; ee != NULL; ee = ee->e_sibling) 864 { 865 /* now unlock the job */ 866 closexscript(ee); 867 unlockqueue(ee); 868 869 /* this envelope is marked unused */ 870 if (ee->e_dfp != NULL) 871 { 872 (void) sm_io_close(ee->e_dfp, SM_TIME_DEFAULT); 873 ee->e_dfp = NULL; 874 } 875 ee->e_id = NULL; 876 ee->e_flags &= ~EF_HAS_DF; 877 } 878 e->e_sibling = oldsib; 879 } 880 881 /* now run through the queue */ 882 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 883 { 884 #if XDEBUG 885 char wbuf[MAXNAME + 20]; 886 887 (void) sm_snprintf(wbuf, sizeof(wbuf), "sendall(%.*s)", 888 MAXNAME, q->q_paddr); 889 checkfd012(wbuf); 890 #endif /* XDEBUG */ 891 if (mode == SM_VERIFY) 892 { 893 e->e_to = q->q_paddr; 894 if (QS_IS_SENDABLE(q->q_state)) 895 { 896 if (q->q_host != NULL && q->q_host[0] != '\0') 897 message("deliverable: mailer %s, host %s, user %s", 898 q->q_mailer->m_name, 899 q->q_host, 900 q->q_user); 901 else 902 message("deliverable: mailer %s, user %s", 903 q->q_mailer->m_name, 904 q->q_user); 905 } 906 } 907 else if (QS_IS_OK(q->q_state)) 908 { 909 /* 910 ** Checkpoint the send list every few addresses 911 */ 912 913 if (CheckpointInterval > 0 && 914 e->e_nsent >= CheckpointInterval) 915 { 916 queueup(e, false, false); 917 e->e_nsent = 0; 918 } 919 (void) deliver(e, q); 920 didany = true; 921 } 922 } 923 if (didany) 924 { 925 e->e_dtime = curtime(); 926 e->e_ntries++; 927 } 928 929 #if XDEBUG 930 checkfd012("end of sendenvelope"); 931 #endif /* XDEBUG */ 932 } 933 934 #if REQUIRES_DIR_FSYNC 935 /* 936 ** SYNC_DIR -- fsync a directory based on a filename 937 ** 938 ** Parameters: 939 ** filename -- path of file 940 ** panic -- panic? 941 ** 942 ** Returns: 943 ** none 944 */ 945 946 void 947 sync_dir(filename, panic) 948 char *filename; 949 bool panic; 950 { 951 int dirfd; 952 char *dirp; 953 char dir[MAXPATHLEN]; 954 955 if (!RequiresDirfsync) 956 return; 957 958 /* filesystems which require the directory be synced */ 959 dirp = strrchr(filename, '/'); 960 if (dirp != NULL) 961 { 962 if (sm_strlcpy(dir, filename, sizeof(dir)) >= sizeof(dir)) 963 return; 964 dir[dirp - filename] = '\0'; 965 dirp = dir; 966 } 967 else 968 dirp = "."; 969 dirfd = open(dirp, O_RDONLY, 0700); 970 if (tTd(40,32)) 971 sm_syslog(LOG_INFO, NOQID, "sync_dir: %s: fsync(%d)", 972 dirp, dirfd); 973 if (dirfd >= 0) 974 { 975 if (fsync(dirfd) < 0) 976 { 977 if (panic) 978 syserr("!sync_dir: cannot fsync directory %s", 979 dirp); 980 else if (LogLevel > 1) 981 sm_syslog(LOG_ERR, NOQID, 982 "sync_dir: cannot fsync directory %s: %s", 983 dirp, sm_errstring(errno)); 984 } 985 (void) close(dirfd); 986 } 987 } 988 #endif /* REQUIRES_DIR_FSYNC */ 989 /* 990 ** DUP_QUEUE_FILE -- duplicate a queue file into a split queue 991 ** 992 ** Parameters: 993 ** e -- the existing envelope 994 ** ee -- the new envelope 995 ** type -- the queue file type (e.g., DATAFL_LETTER) 996 ** 997 ** Returns: 998 ** none 999 */ 1000 1001 static void 1002 dup_queue_file(e, ee, type) 1003 ENVELOPE *e, *ee; 1004 int type; 1005 { 1006 char f1buf[MAXPATHLEN], f2buf[MAXPATHLEN]; 1007 1008 ee->e_dfp = NULL; 1009 ee->e_xfp = NULL; 1010 1011 /* 1012 ** Make sure both are in the same directory. 1013 */ 1014 1015 (void) sm_strlcpy(f1buf, queuename(e, type), sizeof(f1buf)); 1016 (void) sm_strlcpy(f2buf, queuename(ee, type), sizeof(f2buf)); 1017 1018 /* Force the df to disk if it's not there yet */ 1019 if (type == DATAFL_LETTER && e->e_dfp != NULL && 1020 sm_io_setinfo(e->e_dfp, SM_BF_COMMIT, NULL) < 0 && 1021 errno != EINVAL) 1022 { 1023 syserr("!dup_queue_file: can't commit %s", f1buf); 1024 /* NOTREACHED */ 1025 } 1026 1027 if (link(f1buf, f2buf) < 0) 1028 { 1029 int save_errno = errno; 1030 1031 syserr("sendall: link(%s, %s)", f1buf, f2buf); 1032 if (save_errno == EEXIST) 1033 { 1034 if (unlink(f2buf) < 0) 1035 { 1036 syserr("!sendall: unlink(%s): permanent", 1037 f2buf); 1038 /* NOTREACHED */ 1039 } 1040 if (link(f1buf, f2buf) < 0) 1041 { 1042 syserr("!sendall: link(%s, %s): permanent", 1043 f1buf, f2buf); 1044 /* NOTREACHED */ 1045 } 1046 } 1047 } 1048 SYNC_DIR(f2buf, true); 1049 } 1050 /* 1051 ** DOFORK -- do a fork, retrying a couple of times on failure. 1052 ** 1053 ** This MUST be a macro, since after a vfork we are running 1054 ** two processes on the same stack!!! 1055 ** 1056 ** Parameters: 1057 ** none. 1058 ** 1059 ** Returns: 1060 ** From a macro??? You've got to be kidding! 1061 ** 1062 ** Side Effects: 1063 ** Modifies the ==> LOCAL <== variable 'pid', leaving: 1064 ** pid of child in parent, zero in child. 1065 ** -1 on unrecoverable error. 1066 ** 1067 ** Notes: 1068 ** I'm awfully sorry this looks so awful. That's 1069 ** vfork for you..... 1070 */ 1071 1072 #define NFORKTRIES 5 1073 1074 #ifndef FORK 1075 # define FORK fork 1076 #endif /* ! FORK */ 1077 1078 #define DOFORK(fORKfN) \ 1079 {\ 1080 register int i;\ 1081 \ 1082 for (i = NFORKTRIES; --i >= 0; )\ 1083 {\ 1084 pid = fORKfN();\ 1085 if (pid >= 0)\ 1086 break;\ 1087 if (i > 0)\ 1088 (void) sleep((unsigned) NFORKTRIES - i);\ 1089 }\ 1090 } 1091 /* 1092 ** DOFORK -- simple fork interface to DOFORK. 1093 ** 1094 ** Parameters: 1095 ** none. 1096 ** 1097 ** Returns: 1098 ** pid of child in parent. 1099 ** zero in child. 1100 ** -1 on error. 1101 ** 1102 ** Side Effects: 1103 ** returns twice, once in parent and once in child. 1104 */ 1105 1106 pid_t 1107 dofork() 1108 { 1109 register pid_t pid = -1; 1110 1111 DOFORK(fork); 1112 return pid; 1113 } 1114 1115 /* 1116 ** COLONCMP -- compare host-signatures up to first ':' or EOS 1117 ** 1118 ** This takes two strings which happen to be host-signatures and 1119 ** compares them. If the lowest preference portions of the MX-RR's 1120 ** match (up to ':' or EOS, whichever is first), then we have 1121 ** match. This is used for coattail-piggybacking messages during 1122 ** message delivery. 1123 ** If the signatures are the same up to the first ':' the remainder of 1124 ** the signatures are then compared with a normal strcmp(). This saves 1125 ** re-examining the first part of the signatures. 1126 ** 1127 ** Parameters: 1128 ** a - first host-signature 1129 ** b - second host-signature 1130 ** 1131 ** Returns: 1132 ** HS_MATCH_NO -- no "match". 1133 ** HS_MATCH_FIRST -- "match" for the first MX preference 1134 ** (up to the first colon (':')). 1135 ** HS_MATCH_FULL -- match for the entire MX record. 1136 ** 1137 ** Side Effects: 1138 ** none. 1139 */ 1140 1141 #define HS_MATCH_NO 0 1142 #define HS_MATCH_FIRST 1 1143 #define HS_MATCH_FULL 2 1144 1145 static int 1146 coloncmp(a, b) 1147 register const char *a; 1148 register const char *b; 1149 { 1150 int ret = HS_MATCH_NO; 1151 int braclev = 0; 1152 1153 while (*a == *b++) 1154 { 1155 /* Need to account for IPv6 bracketed addresses */ 1156 if (*a == '[') 1157 braclev++; 1158 else if (*a == ']' && braclev > 0) 1159 braclev--; 1160 else if (*a == ':' && braclev <= 0) 1161 { 1162 ret = HS_MATCH_FIRST; 1163 a++; 1164 break; 1165 } 1166 else if (*a == '\0') 1167 return HS_MATCH_FULL; /* a full match */ 1168 a++; 1169 } 1170 if (ret == HS_MATCH_NO && 1171 braclev <= 0 && 1172 ((*a == '\0' && *(b - 1) == ':') || 1173 (*a == ':' && *(b - 1) == '\0'))) 1174 return HS_MATCH_FIRST; 1175 if (ret == HS_MATCH_FIRST && strcmp(a, b) == 0) 1176 return HS_MATCH_FULL; 1177 1178 return ret; 1179 } 1180 1181 /* 1182 ** SHOULD_TRY_FBSH -- Should try FallbackSmartHost? 1183 ** 1184 ** Parameters: 1185 ** e -- envelope 1186 ** tried_fallbacksmarthost -- has been tried already? (in/out) 1187 ** hostbuf -- buffer for hostname (expand FallbackSmartHost) (out) 1188 ** hbsz -- size of hostbuf 1189 ** status -- current delivery status 1190 ** 1191 ** Returns: 1192 ** true iff FallbackSmartHost should be tried. 1193 */ 1194 1195 static bool should_try_fbsh __P((ENVELOPE *, bool *, char *, size_t, int)); 1196 1197 static bool 1198 should_try_fbsh(e, tried_fallbacksmarthost, hostbuf, hbsz, status) 1199 ENVELOPE *e; 1200 bool *tried_fallbacksmarthost; 1201 char *hostbuf; 1202 size_t hbsz; 1203 int status; 1204 { 1205 /* 1206 ** If the host was not found or a temporary failure occurred 1207 ** and a FallbackSmartHost is defined (and we have not yet 1208 ** tried it), then make one last try with it as the host. 1209 */ 1210 1211 if ((status == EX_NOHOST || status == EX_TEMPFAIL) && 1212 FallbackSmartHost != NULL && !*tried_fallbacksmarthost) 1213 { 1214 *tried_fallbacksmarthost = true; 1215 expand(FallbackSmartHost, hostbuf, hbsz, e); 1216 if (!wordinclass(hostbuf, 'w')) 1217 { 1218 if (tTd(11, 1)) 1219 sm_dprintf("one last try with FallbackSmartHost %s\n", 1220 hostbuf); 1221 return true; 1222 } 1223 } 1224 return false; 1225 } 1226 /* 1227 ** DELIVER -- Deliver a message to a list of addresses. 1228 ** 1229 ** This routine delivers to everyone on the same host as the 1230 ** user on the head of the list. It is clever about mailers 1231 ** that don't handle multiple users. It is NOT guaranteed 1232 ** that it will deliver to all these addresses however -- so 1233 ** deliver should be called once for each address on the 1234 ** list. 1235 ** Deliver tries to be as opportunistic as possible about piggybacking 1236 ** messages. Some definitions to make understanding easier follow below. 1237 ** Piggybacking occurs when an existing connection to a mail host can 1238 ** be used to send the same message to more than one recipient at the 1239 ** same time. So "no piggybacking" means one message for one recipient 1240 ** per connection. "Intentional piggybacking" happens when the 1241 ** recipients' host address (not the mail host address) is used to 1242 ** attempt piggybacking. Recipients with the same host address 1243 ** have the same mail host. "Coincidental piggybacking" relies on 1244 ** piggybacking based on all the mail host addresses in the MX-RR. This 1245 ** is "coincidental" in the fact it could not be predicted until the 1246 ** MX Resource Records for the hosts were obtained and examined. For 1247 ** example (preference order and equivalence is important, not values): 1248 ** domain1 IN MX 10 mxhost-A 1249 ** IN MX 20 mxhost-B 1250 ** domain2 IN MX 4 mxhost-A 1251 ** IN MX 8 mxhost-B 1252 ** Domain1 and domain2 can piggyback the same message to mxhost-A or 1253 ** mxhost-B (if mxhost-A cannot be reached). 1254 ** "Coattail piggybacking" relaxes the strictness of "coincidental 1255 ** piggybacking" in the hope that most significant (lowest value) 1256 ** MX preference host(s) can create more piggybacking. For example 1257 ** (again, preference order and equivalence is important, not values): 1258 ** domain3 IN MX 100 mxhost-C 1259 ** IN MX 100 mxhost-D 1260 ** IN MX 200 mxhost-E 1261 ** domain4 IN MX 50 mxhost-C 1262 ** IN MX 50 mxhost-D 1263 ** IN MX 80 mxhost-F 1264 ** A message for domain3 and domain4 can piggyback to mxhost-C if mxhost-C 1265 ** is available. Same with mxhost-D because in both RR's the preference 1266 ** value is the same as mxhost-C, respectively. 1267 ** So deliver attempts coattail piggybacking when possible. If the 1268 ** first MX preference level hosts cannot be used then the piggybacking 1269 ** reverts to coincidental piggybacking. Using the above example you 1270 ** cannot deliver to mxhost-F for domain3 regardless of preference value. 1271 ** ("Coattail" from "riding on the coattails of your predecessor" meaning 1272 ** gaining benefit from a predecessor effort with no or little addition 1273 ** effort. The predecessor here being the preceding MX RR). 1274 ** 1275 ** Parameters: 1276 ** e -- the envelope to deliver. 1277 ** firstto -- head of the address list to deliver to. 1278 ** 1279 ** Returns: 1280 ** zero -- successfully delivered. 1281 ** else -- some failure, see ExitStat for more info. 1282 ** 1283 ** Side Effects: 1284 ** The standard input is passed off to someone. 1285 */ 1286 1287 static int 1288 deliver(e, firstto) 1289 register ENVELOPE *e; 1290 ADDRESS *firstto; 1291 { 1292 char *host; /* host being sent to */ 1293 char *user; /* user being sent to */ 1294 char **pvp; 1295 register char **mvp; 1296 register char *p; 1297 register MAILER *m; /* mailer for this recipient */ 1298 ADDRESS *volatile ctladdr; 1299 #if HASSETUSERCONTEXT 1300 ADDRESS *volatile contextaddr = NULL; 1301 #endif /* HASSETUSERCONTEXT */ 1302 register MCI *volatile mci; 1303 register ADDRESS *SM_NONVOLATILE to = firstto; 1304 volatile bool clever = false; /* running user smtp to this mailer */ 1305 ADDRESS *volatile tochain = NULL; /* users chain in this mailer call */ 1306 int rcode; /* response code */ 1307 SM_NONVOLATILE int lmtp_rcode = EX_OK; 1308 SM_NONVOLATILE int nummxhosts = 0; /* number of MX hosts available */ 1309 SM_NONVOLATILE int hostnum = 0; /* current MX host index */ 1310 char *firstsig; /* signature of firstto */ 1311 volatile pid_t pid = -1; 1312 char *volatile curhost; 1313 SM_NONVOLATILE unsigned short port = 0; 1314 SM_NONVOLATILE time_t enough = 0; 1315 #if NETUNIX 1316 char *SM_NONVOLATILE mux_path = NULL; /* path to UNIX domain socket */ 1317 #endif /* NETUNIX */ 1318 time_t xstart; 1319 bool suidwarn; 1320 bool anyok; /* at least one address was OK */ 1321 SM_NONVOLATILE bool goodmxfound = false; /* at least one MX was OK */ 1322 bool ovr; 1323 bool quarantine; 1324 int strsize; 1325 int rcptcount; 1326 int ret; 1327 static int tobufsize = 0; 1328 static char *tobuf = NULL; 1329 char *rpath; /* translated return path */ 1330 int mpvect[2]; 1331 int rpvect[2]; 1332 char *mxhosts[MAXMXHOSTS + 1]; 1333 char *pv[MAXPV + 1]; 1334 char buf[MAXNAME + 1]; 1335 char cbuf[MAXPATHLEN]; 1336 1337 errno = 0; 1338 SM_REQUIRE(firstto != NULL); /* same as to */ 1339 if (!QS_IS_OK(to->q_state)) 1340 return 0; 1341 1342 suidwarn = geteuid() == 0; 1343 1344 SM_REQUIRE(e != NULL); 1345 m = to->q_mailer; 1346 host = to->q_host; 1347 CurEnv = e; /* just in case */ 1348 e->e_statmsg = NULL; 1349 SmtpError[0] = '\0'; 1350 xstart = curtime(); 1351 1352 if (tTd(10, 1)) 1353 sm_dprintf("\n--deliver, id=%s, mailer=%s, host=`%s', first user=`%s'\n", 1354 e->e_id, m->m_name, host, to->q_user); 1355 if (tTd(10, 100)) 1356 printopenfds(false); 1357 1358 /* 1359 ** Clear {client_*} macros if this is a bounce message to 1360 ** prevent rejection by check_compat ruleset. 1361 */ 1362 1363 if (bitset(EF_RESPONSE, e->e_flags)) 1364 { 1365 macdefine(&e->e_macro, A_PERM, macid("{client_name}"), ""); 1366 macdefine(&e->e_macro, A_PERM, macid("{client_ptr}"), ""); 1367 macdefine(&e->e_macro, A_PERM, macid("{client_addr}"), ""); 1368 macdefine(&e->e_macro, A_PERM, macid("{client_port}"), ""); 1369 macdefine(&e->e_macro, A_PERM, macid("{client_resolve}"), ""); 1370 } 1371 1372 SM_TRY 1373 { 1374 ADDRESS *skip_back = NULL; 1375 1376 /* 1377 ** Do initial argv setup. 1378 ** Insert the mailer name. Notice that $x expansion is 1379 ** NOT done on the mailer name. Then, if the mailer has 1380 ** a picky -f flag, we insert it as appropriate. This 1381 ** code does not check for 'pv' overflow; this places a 1382 ** manifest lower limit of 4 for MAXPV. 1383 ** The from address rewrite is expected to make 1384 ** the address relative to the other end. 1385 */ 1386 1387 /* rewrite from address, using rewriting rules */ 1388 rcode = EX_OK; 1389 SM_ASSERT(e->e_from.q_mailer != NULL); 1390 if (bitnset(M_UDBENVELOPE, e->e_from.q_mailer->m_flags)) 1391 p = e->e_sender; 1392 else 1393 p = e->e_from.q_paddr; 1394 rpath = remotename(p, m, RF_SENDERADDR|RF_CANONICAL, &rcode, e); 1395 if (strlen(rpath) > MAXNAME) 1396 { 1397 rpath = shortenstring(rpath, MAXSHORTSTR); 1398 1399 /* avoid bogus errno */ 1400 errno = 0; 1401 syserr("remotename: huge return path %s", rpath); 1402 } 1403 rpath = sm_rpool_strdup_x(e->e_rpool, rpath); 1404 macdefine(&e->e_macro, A_PERM, 'g', rpath); 1405 macdefine(&e->e_macro, A_PERM, 'h', host); 1406 Errors = 0; 1407 pvp = pv; 1408 *pvp++ = m->m_argv[0]; 1409 1410 /* ignore long term host status information if mailer flag W is set */ 1411 if (bitnset(M_NOHOSTSTAT, m->m_flags)) 1412 IgnoreHostStatus = true; 1413 1414 /* insert -f or -r flag as appropriate */ 1415 if (FromFlag && 1416 (bitnset(M_FOPT, m->m_flags) || 1417 bitnset(M_ROPT, m->m_flags))) 1418 { 1419 if (bitnset(M_FOPT, m->m_flags)) 1420 *pvp++ = "-f"; 1421 else 1422 *pvp++ = "-r"; 1423 *pvp++ = rpath; 1424 } 1425 1426 /* 1427 ** Append the other fixed parts of the argv. These run 1428 ** up to the first entry containing "$u". There can only 1429 ** be one of these, and there are only a few more slots 1430 ** in the pv after it. 1431 */ 1432 1433 for (mvp = m->m_argv; (p = *++mvp) != NULL; ) 1434 { 1435 /* can't use strchr here because of sign extension problems */ 1436 while (*p != '\0') 1437 { 1438 if ((*p++ & 0377) == MACROEXPAND) 1439 { 1440 if (*p == 'u') 1441 break; 1442 } 1443 } 1444 1445 if (*p != '\0') 1446 break; 1447 1448 /* this entry is safe -- go ahead and process it */ 1449 expand(*mvp, buf, sizeof(buf), e); 1450 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf); 1451 if (pvp >= &pv[MAXPV - 3]) 1452 { 1453 syserr("554 5.3.5 Too many parameters to %s before $u", 1454 pv[0]); 1455 rcode = -1; 1456 goto cleanup; 1457 } 1458 } 1459 1460 /* 1461 ** If we have no substitution for the user name in the argument 1462 ** list, we know that we must supply the names otherwise -- and 1463 ** SMTP is the answer!! 1464 */ 1465 1466 if (*mvp == NULL) 1467 { 1468 /* running LMTP or SMTP */ 1469 clever = true; 1470 *pvp = NULL; 1471 } 1472 else if (bitnset(M_LMTP, m->m_flags)) 1473 { 1474 /* not running LMTP */ 1475 sm_syslog(LOG_ERR, NULL, 1476 "Warning: mailer %s: LMTP flag (F=z) turned off", 1477 m->m_name); 1478 clrbitn(M_LMTP, m->m_flags); 1479 } 1480 1481 /* 1482 ** At this point *mvp points to the argument with $u. We 1483 ** run through our address list and append all the addresses 1484 ** we can. If we run out of space, do not fret! We can 1485 ** always send another copy later. 1486 */ 1487 1488 e->e_to = NULL; 1489 strsize = 2; 1490 rcptcount = 0; 1491 ctladdr = NULL; 1492 if (firstto->q_signature == NULL) 1493 firstto->q_signature = hostsignature(firstto->q_mailer, 1494 firstto->q_host); 1495 firstsig = firstto->q_signature; 1496 1497 for (; to != NULL; to = to->q_next) 1498 { 1499 /* avoid sending multiple recipients to dumb mailers */ 1500 if (tochain != NULL && !bitnset(M_MUSER, m->m_flags)) 1501 break; 1502 1503 /* if already sent or not for this host, don't send */ 1504 if (!QS_IS_OK(to->q_state)) /* already sent; look at next */ 1505 continue; 1506 1507 /* 1508 ** Must be same mailer to keep grouping rcpts. 1509 ** If mailers don't match: continue; sendqueue is not 1510 ** sorted by mailers, so don't break; 1511 */ 1512 1513 if (to->q_mailer != firstto->q_mailer) 1514 continue; 1515 1516 if (to->q_signature == NULL) /* for safety */ 1517 to->q_signature = hostsignature(to->q_mailer, 1518 to->q_host); 1519 1520 /* 1521 ** This is for coincidental and tailcoat piggybacking messages 1522 ** to the same mail host. While the signatures are identical 1523 ** (that's the MX-RR's are identical) we can do coincidental 1524 ** piggybacking. We try hard for coattail piggybacking 1525 ** with the same mail host when the next recipient has the 1526 ** same host at lowest preference. It may be that this 1527 ** won't work out, so 'skip_back' is maintained if a backup 1528 ** to coincidental piggybacking or full signature must happen. 1529 */ 1530 1531 ret = firstto == to ? HS_MATCH_FULL : 1532 coloncmp(to->q_signature, firstsig); 1533 if (ret == HS_MATCH_FULL) 1534 skip_back = to; 1535 else if (ret == HS_MATCH_NO) 1536 break; 1537 1538 if (!clever) 1539 { 1540 /* avoid overflowing tobuf */ 1541 strsize += strlen(to->q_paddr) + 1; 1542 if (strsize > TOBUFSIZE) 1543 break; 1544 } 1545 1546 if (++rcptcount > to->q_mailer->m_maxrcpt) 1547 break; 1548 1549 if (tTd(10, 1)) 1550 { 1551 sm_dprintf("\nsend to "); 1552 printaddr(sm_debug_file(), to, false); 1553 } 1554 1555 /* compute effective uid/gid when sending */ 1556 if (bitnset(M_RUNASRCPT, to->q_mailer->m_flags)) 1557 # if HASSETUSERCONTEXT 1558 contextaddr = ctladdr = getctladdr(to); 1559 # else /* HASSETUSERCONTEXT */ 1560 ctladdr = getctladdr(to); 1561 # endif /* HASSETUSERCONTEXT */ 1562 1563 if (tTd(10, 2)) 1564 { 1565 sm_dprintf("ctladdr="); 1566 printaddr(sm_debug_file(), ctladdr, false); 1567 } 1568 1569 user = to->q_user; 1570 e->e_to = to->q_paddr; 1571 1572 /* 1573 ** Check to see that these people are allowed to 1574 ** talk to each other. 1575 ** Check also for overflow of e_msgsize. 1576 */ 1577 1578 if (m->m_maxsize != 0 && 1579 (e->e_msgsize > m->m_maxsize || e->e_msgsize < 0)) 1580 { 1581 e->e_flags |= EF_NO_BODY_RETN; 1582 if (bitnset(M_LOCALMAILER, to->q_mailer->m_flags)) 1583 to->q_status = "5.2.3"; 1584 else 1585 to->q_status = "5.3.4"; 1586 1587 /* set to->q_rstatus = NULL; or to the following? */ 1588 usrerrenh(to->q_status, 1589 "552 Message is too large; %ld bytes max", 1590 m->m_maxsize); 1591 markfailure(e, to, NULL, EX_UNAVAILABLE, false); 1592 giveresponse(EX_UNAVAILABLE, to->q_status, m, 1593 NULL, ctladdr, xstart, e, to); 1594 continue; 1595 } 1596 SM_SET_H_ERRNO(0); 1597 ovr = true; 1598 1599 /* do config file checking of compatibility */ 1600 quarantine = (e->e_quarmsg != NULL); 1601 rcode = rscheck("check_compat", e->e_from.q_paddr, to->q_paddr, 1602 e, RSF_RMCOMM|RSF_COUNT, 3, NULL, 1603 e->e_id, NULL); 1604 if (rcode == EX_OK) 1605 { 1606 /* do in-code checking if not discarding */ 1607 if (!bitset(EF_DISCARD, e->e_flags)) 1608 { 1609 rcode = checkcompat(to, e); 1610 ovr = false; 1611 } 1612 } 1613 if (rcode != EX_OK) 1614 { 1615 markfailure(e, to, NULL, rcode, ovr); 1616 giveresponse(rcode, to->q_status, m, 1617 NULL, ctladdr, xstart, e, to); 1618 continue; 1619 } 1620 if (!quarantine && e->e_quarmsg != NULL) 1621 { 1622 /* 1623 ** check_compat or checkcompat() has tried 1624 ** to quarantine but that isn't supported. 1625 ** Revert the attempt. 1626 */ 1627 1628 e->e_quarmsg = NULL; 1629 macdefine(&e->e_macro, A_PERM, 1630 macid("{quarantine}"), ""); 1631 } 1632 if (bitset(EF_DISCARD, e->e_flags)) 1633 { 1634 if (tTd(10, 5)) 1635 { 1636 sm_dprintf("deliver: discarding recipient "); 1637 printaddr(sm_debug_file(), to, false); 1638 } 1639 1640 /* pretend the message was sent */ 1641 /* XXX should we log something here? */ 1642 to->q_state = QS_DISCARDED; 1643 1644 /* 1645 ** Remove discard bit to prevent discard of 1646 ** future recipients. This is safe because the 1647 ** true "global discard" has been handled before 1648 ** we get here. 1649 */ 1650 1651 e->e_flags &= ~EF_DISCARD; 1652 continue; 1653 } 1654 1655 /* 1656 ** Strip quote bits from names if the mailer is dumb 1657 ** about them. 1658 */ 1659 1660 if (bitnset(M_STRIPQ, m->m_flags)) 1661 { 1662 stripquotes(user); 1663 stripquotes(host); 1664 } 1665 1666 /* 1667 ** Strip all leading backslashes if requested and the 1668 ** next character is alphanumerical (the latter can 1669 ** probably relaxed a bit, see RFC2821). 1670 */ 1671 1672 if (bitnset(M_STRIPBACKSL, m->m_flags) && user[0] == '\\') 1673 stripbackslash(user); 1674 1675 /* hack attack -- delivermail compatibility */ 1676 if (m == ProgMailer && *user == '|') 1677 user++; 1678 1679 /* 1680 ** If an error message has already been given, don't 1681 ** bother to send to this address. 1682 ** 1683 ** >>>>>>>>>> This clause assumes that the local mailer 1684 ** >> NOTE >> cannot do any further aliasing; that 1685 ** >>>>>>>>>> function is subsumed by sendmail. 1686 */ 1687 1688 if (!QS_IS_OK(to->q_state)) 1689 continue; 1690 1691 /* 1692 ** See if this user name is "special". 1693 ** If the user name has a slash in it, assume that this 1694 ** is a file -- send it off without further ado. Note 1695 ** that this type of addresses is not processed along 1696 ** with the others, so we fudge on the To person. 1697 */ 1698 1699 if (strcmp(m->m_mailer, "[FILE]") == 0) 1700 { 1701 macdefine(&e->e_macro, A_PERM, 'u', user); 1702 p = to->q_home; 1703 if (p == NULL && ctladdr != NULL) 1704 p = ctladdr->q_home; 1705 macdefine(&e->e_macro, A_PERM, 'z', p); 1706 expand(m->m_argv[1], buf, sizeof(buf), e); 1707 if (strlen(buf) > 0) 1708 rcode = mailfile(buf, m, ctladdr, SFF_CREAT, e); 1709 else 1710 { 1711 syserr("empty filename specification for mailer %s", 1712 m->m_name); 1713 rcode = EX_CONFIG; 1714 } 1715 giveresponse(rcode, to->q_status, m, NULL, 1716 ctladdr, xstart, e, to); 1717 markfailure(e, to, NULL, rcode, true); 1718 e->e_nsent++; 1719 if (rcode == EX_OK) 1720 { 1721 to->q_state = QS_SENT; 1722 if (bitnset(M_LOCALMAILER, m->m_flags) && 1723 bitset(QPINGONSUCCESS, to->q_flags)) 1724 { 1725 to->q_flags |= QDELIVERED; 1726 to->q_status = "2.1.5"; 1727 (void) sm_io_fprintf(e->e_xfp, 1728 SM_TIME_DEFAULT, 1729 "%s... Successfully delivered\n", 1730 to->q_paddr); 1731 } 1732 } 1733 to->q_statdate = curtime(); 1734 markstats(e, to, STATS_NORMAL); 1735 continue; 1736 } 1737 1738 /* 1739 ** Address is verified -- add this user to mailer 1740 ** argv, and add it to the print list of recipients. 1741 */ 1742 1743 /* link together the chain of recipients */ 1744 to->q_tchain = tochain; 1745 tochain = to; 1746 e->e_to = "[CHAIN]"; 1747 1748 macdefine(&e->e_macro, A_PERM, 'u', user); /* to user */ 1749 p = to->q_home; 1750 if (p == NULL && ctladdr != NULL) 1751 p = ctladdr->q_home; 1752 macdefine(&e->e_macro, A_PERM, 'z', p); /* user's home */ 1753 1754 /* set the ${dsn_notify} macro if applicable */ 1755 if (bitset(QHASNOTIFY, to->q_flags)) 1756 { 1757 char notify[MAXLINE]; 1758 1759 notify[0] = '\0'; 1760 if (bitset(QPINGONSUCCESS, to->q_flags)) 1761 (void) sm_strlcat(notify, "SUCCESS,", 1762 sizeof(notify)); 1763 if (bitset(QPINGONFAILURE, to->q_flags)) 1764 (void) sm_strlcat(notify, "FAILURE,", 1765 sizeof(notify)); 1766 if (bitset(QPINGONDELAY, to->q_flags)) 1767 (void) sm_strlcat(notify, "DELAY,", 1768 sizeof(notify)); 1769 1770 /* Set to NEVER or drop trailing comma */ 1771 if (notify[0] == '\0') 1772 (void) sm_strlcat(notify, "NEVER", 1773 sizeof(notify)); 1774 else 1775 notify[strlen(notify) - 1] = '\0'; 1776 1777 macdefine(&e->e_macro, A_TEMP, 1778 macid("{dsn_notify}"), notify); 1779 } 1780 else 1781 macdefine(&e->e_macro, A_PERM, 1782 macid("{dsn_notify}"), NULL); 1783 1784 /* 1785 ** Expand out this user into argument list. 1786 */ 1787 1788 if (!clever) 1789 { 1790 expand(*mvp, buf, sizeof(buf), e); 1791 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf); 1792 if (pvp >= &pv[MAXPV - 2]) 1793 { 1794 /* allow some space for trailing parms */ 1795 break; 1796 } 1797 } 1798 } 1799 1800 /* see if any addresses still exist */ 1801 if (tochain == NULL) 1802 { 1803 rcode = 0; 1804 goto cleanup; 1805 } 1806 1807 /* print out messages as full list */ 1808 strsize = 1; 1809 for (to = tochain; to != NULL; to = to->q_tchain) 1810 strsize += strlen(to->q_paddr) + 1; 1811 if (strsize < TOBUFSIZE) 1812 strsize = TOBUFSIZE; 1813 if (strsize > tobufsize) 1814 { 1815 SM_FREE_CLR(tobuf); 1816 tobuf = sm_pmalloc_x(strsize); 1817 tobufsize = strsize; 1818 } 1819 p = tobuf; 1820 *p = '\0'; 1821 for (to = tochain; to != NULL; to = to->q_tchain) 1822 { 1823 (void) sm_strlcpyn(p, tobufsize - (p - tobuf), 2, 1824 ",", to->q_paddr); 1825 p += strlen(p); 1826 } 1827 e->e_to = tobuf + 1; 1828 1829 /* 1830 ** Fill out any parameters after the $u parameter. 1831 */ 1832 1833 if (!clever) 1834 { 1835 while (*++mvp != NULL) 1836 { 1837 expand(*mvp, buf, sizeof(buf), e); 1838 *pvp++ = sm_rpool_strdup_x(e->e_rpool, buf); 1839 if (pvp >= &pv[MAXPV]) 1840 syserr("554 5.3.0 deliver: pv overflow after $u for %s", 1841 pv[0]); 1842 } 1843 } 1844 *pvp++ = NULL; 1845 1846 /* 1847 ** Call the mailer. 1848 ** The argument vector gets built, pipes 1849 ** are created as necessary, and we fork & exec as 1850 ** appropriate. 1851 ** If we are running SMTP, we just need to clean up. 1852 */ 1853 1854 /* XXX this seems a bit weird */ 1855 if (ctladdr == NULL && m != ProgMailer && m != FileMailer && 1856 bitset(QGOODUID, e->e_from.q_flags)) 1857 ctladdr = &e->e_from; 1858 1859 #if NAMED_BIND 1860 if (ConfigLevel < 2) 1861 _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */ 1862 #endif /* NAMED_BIND */ 1863 1864 if (tTd(11, 1)) 1865 { 1866 sm_dprintf("openmailer:"); 1867 printav(sm_debug_file(), pv); 1868 } 1869 errno = 0; 1870 SM_SET_H_ERRNO(0); 1871 CurHostName = NULL; 1872 1873 /* 1874 ** Deal with the special case of mail handled through an IPC 1875 ** connection. 1876 ** In this case we don't actually fork. We must be 1877 ** running SMTP for this to work. We will return a 1878 ** zero pid to indicate that we are running IPC. 1879 ** We also handle a debug version that just talks to stdin/out. 1880 */ 1881 1882 curhost = NULL; 1883 SmtpPhase = NULL; 1884 mci = NULL; 1885 1886 #if XDEBUG 1887 { 1888 char wbuf[MAXLINE]; 1889 1890 /* make absolutely certain 0, 1, and 2 are in use */ 1891 (void) sm_snprintf(wbuf, sizeof(wbuf), "%s... openmailer(%s)", 1892 shortenstring(e->e_to, MAXSHORTSTR), 1893 m->m_name); 1894 checkfd012(wbuf); 1895 } 1896 #endif /* XDEBUG */ 1897 1898 /* check for 8-bit available */ 1899 if (bitset(EF_HAS8BIT, e->e_flags) && 1900 bitnset(M_7BITS, m->m_flags) && 1901 (bitset(EF_DONT_MIME, e->e_flags) || 1902 !(bitset(MM_MIME8BIT, MimeMode) || 1903 (bitset(EF_IS_MIME, e->e_flags) && 1904 bitset(MM_CVTMIME, MimeMode))))) 1905 { 1906 e->e_status = "5.6.3"; 1907 usrerrenh(e->e_status, 1908 "554 Cannot send 8-bit data to 7-bit destination"); 1909 rcode = EX_DATAERR; 1910 goto give_up; 1911 } 1912 1913 if (tTd(62, 8)) 1914 checkfds("before delivery"); 1915 1916 /* check for Local Person Communication -- not for mortals!!! */ 1917 if (strcmp(m->m_mailer, "[LPC]") == 0) 1918 { 1919 if (clever) 1920 { 1921 /* flush any expired connections */ 1922 (void) mci_scan(NULL); 1923 1924 /* try to get a cached connection or just a slot */ 1925 mci = mci_get(m->m_name, m); 1926 if (mci->mci_host == NULL) 1927 mci->mci_host = m->m_name; 1928 CurHostName = mci->mci_host; 1929 if (mci->mci_state != MCIS_CLOSED) 1930 { 1931 message("Using cached SMTP/LPC connection for %s...", 1932 m->m_name); 1933 mci->mci_deliveries++; 1934 goto do_transfer; 1935 } 1936 } 1937 else 1938 { 1939 mci = mci_new(e->e_rpool); 1940 } 1941 mci->mci_in = smioin; 1942 mci->mci_out = smioout; 1943 mci->mci_mailer = m; 1944 mci->mci_host = m->m_name; 1945 if (clever) 1946 { 1947 mci->mci_state = MCIS_OPENING; 1948 mci_cache(mci); 1949 } 1950 else 1951 mci->mci_state = MCIS_OPEN; 1952 } 1953 else if (strcmp(m->m_mailer, "[IPC]") == 0) 1954 { 1955 register int i; 1956 1957 if (pv[0] == NULL || pv[1] == NULL || pv[1][0] == '\0') 1958 { 1959 syserr("null destination for %s mailer", m->m_mailer); 1960 rcode = EX_CONFIG; 1961 goto give_up; 1962 } 1963 1964 # if NETUNIX 1965 if (strcmp(pv[0], "FILE") == 0) 1966 { 1967 curhost = CurHostName = "localhost"; 1968 mux_path = pv[1]; 1969 } 1970 else 1971 # endif /* NETUNIX */ 1972 { 1973 CurHostName = pv[1]; 1974 curhost = hostsignature(m, pv[1]); 1975 } 1976 1977 if (curhost == NULL || curhost[0] == '\0') 1978 { 1979 syserr("null host signature for %s", pv[1]); 1980 rcode = EX_CONFIG; 1981 goto give_up; 1982 } 1983 1984 if (!clever) 1985 { 1986 syserr("554 5.3.5 non-clever IPC"); 1987 rcode = EX_CONFIG; 1988 goto give_up; 1989 } 1990 if (pv[2] != NULL 1991 # if NETUNIX 1992 && mux_path == NULL 1993 # endif /* NETUNIX */ 1994 ) 1995 { 1996 port = htons((unsigned short) atoi(pv[2])); 1997 if (port == 0) 1998 { 1999 # ifdef NO_GETSERVBYNAME 2000 syserr("Invalid port number: %s", pv[2]); 2001 # else /* NO_GETSERVBYNAME */ 2002 struct servent *sp = getservbyname(pv[2], "tcp"); 2003 2004 if (sp == NULL) 2005 syserr("Service %s unknown", pv[2]); 2006 else 2007 port = sp->s_port; 2008 # endif /* NO_GETSERVBYNAME */ 2009 } 2010 } 2011 2012 nummxhosts = parse_hostsignature(curhost, mxhosts, m); 2013 if (TimeOuts.to_aconnect > 0) 2014 enough = curtime() + TimeOuts.to_aconnect; 2015 tryhost: 2016 while (hostnum < nummxhosts) 2017 { 2018 char sep = ':'; 2019 char *endp; 2020 static char hostbuf[MAXNAME + 1]; 2021 bool tried_fallbacksmarthost = false; 2022 2023 # if NETINET6 2024 if (*mxhosts[hostnum] == '[') 2025 { 2026 endp = strchr(mxhosts[hostnum] + 1, ']'); 2027 if (endp != NULL) 2028 endp = strpbrk(endp + 1, ":,"); 2029 } 2030 else 2031 endp = strpbrk(mxhosts[hostnum], ":,"); 2032 # else /* NETINET6 */ 2033 endp = strpbrk(mxhosts[hostnum], ":,"); 2034 # endif /* NETINET6 */ 2035 if (endp != NULL) 2036 { 2037 sep = *endp; 2038 *endp = '\0'; 2039 } 2040 2041 if (hostnum == 1 && skip_back != NULL) 2042 { 2043 /* 2044 ** Coattail piggybacking is no longer an 2045 ** option with the mail host next to be tried 2046 ** no longer the lowest MX preference 2047 ** (hostnum == 1 meaning we're on the second 2048 ** preference). We do not try to coattail 2049 ** piggyback more than the first MX preference. 2050 ** Revert 'tochain' to last location for 2051 ** coincidental piggybacking. This works this 2052 ** easily because the q_tchain kept getting 2053 ** added to the top of the linked list. 2054 */ 2055 2056 tochain = skip_back; 2057 } 2058 2059 if (*mxhosts[hostnum] == '\0') 2060 { 2061 syserr("deliver: null host name in signature"); 2062 hostnum++; 2063 if (endp != NULL) 2064 *endp = sep; 2065 continue; 2066 } 2067 (void) sm_strlcpy(hostbuf, mxhosts[hostnum], 2068 sizeof(hostbuf)); 2069 hostnum++; 2070 if (endp != NULL) 2071 *endp = sep; 2072 2073 one_last_try: 2074 /* see if we already know that this host is fried */ 2075 CurHostName = hostbuf; 2076 mci = mci_get(hostbuf, m); 2077 if (mci->mci_state != MCIS_CLOSED) 2078 { 2079 char *type; 2080 2081 if (tTd(11, 1)) 2082 { 2083 sm_dprintf("openmailer: "); 2084 mci_dump(sm_debug_file(), mci, false); 2085 } 2086 CurHostName = mci->mci_host; 2087 if (bitnset(M_LMTP, m->m_flags)) 2088 type = "L"; 2089 else if (bitset(MCIF_ESMTP, mci->mci_flags)) 2090 type = "ES"; 2091 else 2092 type = "S"; 2093 message("Using cached %sMTP connection to %s via %s...", 2094 type, hostbuf, m->m_name); 2095 mci->mci_deliveries++; 2096 break; 2097 } 2098 mci->mci_mailer = m; 2099 if (mci->mci_exitstat != EX_OK) 2100 { 2101 if (mci->mci_exitstat == EX_TEMPFAIL) 2102 goodmxfound = true; 2103 2104 /* Try FallbackSmartHost? */ 2105 if (should_try_fbsh(e, &tried_fallbacksmarthost, 2106 hostbuf, sizeof(hostbuf), 2107 mci->mci_exitstat)) 2108 goto one_last_try; 2109 2110 continue; 2111 } 2112 2113 if (mci_lock_host(mci) != EX_OK) 2114 { 2115 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL); 2116 goodmxfound = true; 2117 continue; 2118 } 2119 2120 /* try the connection */ 2121 sm_setproctitle(true, e, "%s %s: %s", 2122 qid_printname(e), 2123 hostbuf, "user open"); 2124 # if NETUNIX 2125 if (mux_path != NULL) 2126 { 2127 message("Connecting to %s via %s...", 2128 mux_path, m->m_name); 2129 i = makeconnection_ds((char *) mux_path, mci); 2130 } 2131 else 2132 # endif /* NETUNIX */ 2133 { 2134 if (port == 0) 2135 message("Connecting to %s via %s...", 2136 hostbuf, m->m_name); 2137 else 2138 message("Connecting to %s port %d via %s...", 2139 hostbuf, ntohs(port), 2140 m->m_name); 2141 i = makeconnection(hostbuf, port, mci, e, 2142 enough); 2143 } 2144 mci->mci_errno = errno; 2145 mci->mci_lastuse = curtime(); 2146 mci->mci_deliveries = 0; 2147 mci->mci_exitstat = i; 2148 mci_clr_extensions(mci); 2149 # if NAMED_BIND 2150 mci->mci_herrno = h_errno; 2151 # endif /* NAMED_BIND */ 2152 2153 /* 2154 ** Have we tried long enough to get a connection? 2155 ** If yes, skip to the fallback MX hosts 2156 ** (if existent). 2157 */ 2158 2159 if (enough > 0 && mci->mci_lastuse >= enough) 2160 { 2161 int h; 2162 # if NAMED_BIND 2163 extern int NumFallbackMXHosts; 2164 # else /* NAMED_BIND */ 2165 const int NumFallbackMXHosts = 0; 2166 # endif /* NAMED_BIND */ 2167 2168 if (hostnum < nummxhosts && LogLevel > 9) 2169 sm_syslog(LOG_INFO, e->e_id, 2170 "Timeout.to_aconnect occurred before exhausting all addresses"); 2171 2172 /* turn off timeout if fallback available */ 2173 if (NumFallbackMXHosts > 0) 2174 enough = 0; 2175 2176 /* skip to a fallback MX host */ 2177 h = nummxhosts - NumFallbackMXHosts; 2178 if (hostnum < h) 2179 hostnum = h; 2180 } 2181 if (i == EX_OK) 2182 { 2183 goodmxfound = true; 2184 markstats(e, firstto, STATS_CONNECT); 2185 mci->mci_state = MCIS_OPENING; 2186 mci_cache(mci); 2187 if (TrafficLogFile != NULL) 2188 (void) sm_io_fprintf(TrafficLogFile, 2189 SM_TIME_DEFAULT, 2190 "%05d === CONNECT %s\n", 2191 (int) CurrentPid, 2192 hostbuf); 2193 break; 2194 } 2195 else 2196 { 2197 /* Try FallbackSmartHost? */ 2198 if (should_try_fbsh(e, &tried_fallbacksmarthost, 2199 hostbuf, sizeof(hostbuf), i)) 2200 goto one_last_try; 2201 2202 if (tTd(11, 1)) 2203 sm_dprintf("openmailer: makeconnection => stat=%d, errno=%d\n", 2204 i, errno); 2205 if (i == EX_TEMPFAIL) 2206 goodmxfound = true; 2207 mci_unlock_host(mci); 2208 } 2209 2210 /* enter status of this host */ 2211 setstat(i); 2212 2213 /* should print some message here for -v mode */ 2214 } 2215 if (mci == NULL) 2216 { 2217 syserr("deliver: no host name"); 2218 rcode = EX_SOFTWARE; 2219 goto give_up; 2220 } 2221 mci->mci_pid = 0; 2222 } 2223 else 2224 { 2225 /* flush any expired connections */ 2226 (void) mci_scan(NULL); 2227 mci = NULL; 2228 2229 if (bitnset(M_LMTP, m->m_flags)) 2230 { 2231 /* try to get a cached connection */ 2232 mci = mci_get(m->m_name, m); 2233 if (mci->mci_host == NULL) 2234 mci->mci_host = m->m_name; 2235 CurHostName = mci->mci_host; 2236 if (mci->mci_state != MCIS_CLOSED) 2237 { 2238 message("Using cached LMTP connection for %s...", 2239 m->m_name); 2240 mci->mci_deliveries++; 2241 goto do_transfer; 2242 } 2243 } 2244 2245 /* announce the connection to verbose listeners */ 2246 if (host == NULL || host[0] == '\0') 2247 message("Connecting to %s...", m->m_name); 2248 else 2249 message("Connecting to %s via %s...", host, m->m_name); 2250 if (TrafficLogFile != NULL) 2251 { 2252 char **av; 2253 2254 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT, 2255 "%05d === EXEC", (int) CurrentPid); 2256 for (av = pv; *av != NULL; av++) 2257 (void) sm_io_fprintf(TrafficLogFile, 2258 SM_TIME_DEFAULT, " %s", 2259 *av); 2260 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT, 2261 "\n"); 2262 } 2263 2264 #if XDEBUG 2265 checkfd012("before creating mail pipe"); 2266 #endif /* XDEBUG */ 2267 2268 /* create a pipe to shove the mail through */ 2269 if (pipe(mpvect) < 0) 2270 { 2271 syserr("%s... openmailer(%s): pipe (to mailer)", 2272 shortenstring(e->e_to, MAXSHORTSTR), m->m_name); 2273 if (tTd(11, 1)) 2274 sm_dprintf("openmailer: NULL\n"); 2275 rcode = EX_OSERR; 2276 goto give_up; 2277 } 2278 2279 #if XDEBUG 2280 /* make sure we didn't get one of the standard I/O files */ 2281 if (mpvect[0] < 3 || mpvect[1] < 3) 2282 { 2283 syserr("%s... openmailer(%s): bogus mpvect %d %d", 2284 shortenstring(e->e_to, MAXSHORTSTR), m->m_name, 2285 mpvect[0], mpvect[1]); 2286 printopenfds(true); 2287 if (tTd(11, 1)) 2288 sm_dprintf("openmailer: NULL\n"); 2289 rcode = EX_OSERR; 2290 goto give_up; 2291 } 2292 2293 /* make sure system call isn't dead meat */ 2294 checkfdopen(mpvect[0], "mpvect[0]"); 2295 checkfdopen(mpvect[1], "mpvect[1]"); 2296 if (mpvect[0] == mpvect[1] || 2297 (e->e_lockfp != NULL && 2298 (mpvect[0] == sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, 2299 NULL) || 2300 mpvect[1] == sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, 2301 NULL)))) 2302 { 2303 if (e->e_lockfp == NULL) 2304 syserr("%s... openmailer(%s): overlapping mpvect %d %d", 2305 shortenstring(e->e_to, MAXSHORTSTR), 2306 m->m_name, mpvect[0], mpvect[1]); 2307 else 2308 syserr("%s... openmailer(%s): overlapping mpvect %d %d, lockfp = %d", 2309 shortenstring(e->e_to, MAXSHORTSTR), 2310 m->m_name, mpvect[0], mpvect[1], 2311 sm_io_getinfo(e->e_lockfp, 2312 SM_IO_WHAT_FD, NULL)); 2313 } 2314 #endif /* XDEBUG */ 2315 2316 /* create a return pipe */ 2317 if (pipe(rpvect) < 0) 2318 { 2319 syserr("%s... openmailer(%s): pipe (from mailer)", 2320 shortenstring(e->e_to, MAXSHORTSTR), 2321 m->m_name); 2322 (void) close(mpvect[0]); 2323 (void) close(mpvect[1]); 2324 if (tTd(11, 1)) 2325 sm_dprintf("openmailer: NULL\n"); 2326 rcode = EX_OSERR; 2327 goto give_up; 2328 } 2329 #if XDEBUG 2330 checkfdopen(rpvect[0], "rpvect[0]"); 2331 checkfdopen(rpvect[1], "rpvect[1]"); 2332 #endif /* XDEBUG */ 2333 2334 /* 2335 ** Actually fork the mailer process. 2336 ** DOFORK is clever about retrying. 2337 ** 2338 ** Dispose of SIGCHLD signal catchers that may be laying 2339 ** around so that endmailer will get it. 2340 */ 2341 2342 if (e->e_xfp != NULL) /* for debugging */ 2343 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT); 2344 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 2345 (void) sm_signal(SIGCHLD, SIG_DFL); 2346 2347 2348 DOFORK(FORK); 2349 /* pid is set by DOFORK */ 2350 2351 if (pid < 0) 2352 { 2353 /* failure */ 2354 syserr("%s... openmailer(%s): cannot fork", 2355 shortenstring(e->e_to, MAXSHORTSTR), m->m_name); 2356 (void) close(mpvect[0]); 2357 (void) close(mpvect[1]); 2358 (void) close(rpvect[0]); 2359 (void) close(rpvect[1]); 2360 if (tTd(11, 1)) 2361 sm_dprintf("openmailer: NULL\n"); 2362 rcode = EX_OSERR; 2363 goto give_up; 2364 } 2365 else if (pid == 0) 2366 { 2367 int save_errno; 2368 int sff; 2369 int new_euid = NO_UID; 2370 int new_ruid = NO_UID; 2371 int new_gid = NO_GID; 2372 char *user = NULL; 2373 struct stat stb; 2374 extern int DtableSize; 2375 2376 CurrentPid = getpid(); 2377 2378 /* clear the events to turn off SIGALRMs */ 2379 sm_clear_events(); 2380 2381 /* Reset global flags */ 2382 RestartRequest = NULL; 2383 RestartWorkGroup = false; 2384 ShutdownRequest = NULL; 2385 PendingSignal = 0; 2386 2387 if (e->e_lockfp != NULL) 2388 (void) close(sm_io_getinfo(e->e_lockfp, 2389 SM_IO_WHAT_FD, 2390 NULL)); 2391 2392 /* child -- set up input & exec mailer */ 2393 (void) sm_signal(SIGALRM, sm_signal_noop); 2394 (void) sm_signal(SIGCHLD, SIG_DFL); 2395 (void) sm_signal(SIGHUP, SIG_IGN); 2396 (void) sm_signal(SIGINT, SIG_IGN); 2397 (void) sm_signal(SIGTERM, SIG_DFL); 2398 # ifdef SIGUSR1 2399 (void) sm_signal(SIGUSR1, sm_signal_noop); 2400 # endif /* SIGUSR1 */ 2401 2402 if (m != FileMailer || stat(tochain->q_user, &stb) < 0) 2403 stb.st_mode = 0; 2404 2405 # if HASSETUSERCONTEXT 2406 /* 2407 ** Set user resources. 2408 */ 2409 2410 if (contextaddr != NULL) 2411 { 2412 int sucflags; 2413 struct passwd *pwd; 2414 2415 if (contextaddr->q_ruser != NULL) 2416 pwd = sm_getpwnam(contextaddr->q_ruser); 2417 else 2418 pwd = sm_getpwnam(contextaddr->q_user); 2419 sucflags = LOGIN_SETRESOURCES|LOGIN_SETPRIORITY; 2420 #ifdef LOGIN_SETCPUMASK 2421 sucflags |= LOGIN_SETCPUMASK; 2422 #endif /* LOGIN_SETCPUMASK */ 2423 #ifdef LOGIN_SETLOGINCLASS 2424 sucflags |= LOGIN_SETLOGINCLASS; 2425 #endif /* LOGIN_SETLOGINCLASS */ 2426 #ifdef LOGIN_SETMAC 2427 sucflags |= LOGIN_SETMAC; 2428 #endif /* LOGIN_SETMAC */ 2429 if (pwd != NULL && 2430 setusercontext(NULL, pwd, pwd->pw_uid, 2431 sucflags) == -1 && 2432 suidwarn) 2433 { 2434 syserr("openmailer: setusercontext() failed"); 2435 exit(EX_TEMPFAIL); 2436 } 2437 } 2438 # endif /* HASSETUSERCONTEXT */ 2439 2440 #if HASNICE 2441 /* tweak niceness */ 2442 if (m->m_nice != 0) 2443 (void) nice(m->m_nice); 2444 #endif /* HASNICE */ 2445 2446 /* reset group id */ 2447 if (bitnset(M_SPECIFIC_UID, m->m_flags)) 2448 { 2449 if (m->m_gid == NO_GID) 2450 new_gid = RunAsGid; 2451 else 2452 new_gid = m->m_gid; 2453 } 2454 else if (bitset(S_ISGID, stb.st_mode)) 2455 new_gid = stb.st_gid; 2456 else if (ctladdr != NULL && ctladdr->q_gid != 0) 2457 { 2458 if (!DontInitGroups) 2459 { 2460 user = ctladdr->q_ruser; 2461 if (user == NULL) 2462 user = ctladdr->q_user; 2463 2464 if (initgroups(user, 2465 ctladdr->q_gid) == -1 2466 && suidwarn) 2467 { 2468 syserr("openmailer: initgroups(%s, %d) failed", 2469 user, ctladdr->q_gid); 2470 exit(EX_TEMPFAIL); 2471 } 2472 } 2473 else 2474 { 2475 GIDSET_T gidset[1]; 2476 2477 gidset[0] = ctladdr->q_gid; 2478 if (setgroups(1, gidset) == -1 2479 && suidwarn) 2480 { 2481 syserr("openmailer: setgroups() failed"); 2482 exit(EX_TEMPFAIL); 2483 } 2484 } 2485 new_gid = ctladdr->q_gid; 2486 } 2487 else 2488 { 2489 if (!DontInitGroups) 2490 { 2491 user = DefUser; 2492 if (initgroups(DefUser, DefGid) == -1 && 2493 suidwarn) 2494 { 2495 syserr("openmailer: initgroups(%s, %d) failed", 2496 DefUser, DefGid); 2497 exit(EX_TEMPFAIL); 2498 } 2499 } 2500 else 2501 { 2502 GIDSET_T gidset[1]; 2503 2504 gidset[0] = DefGid; 2505 if (setgroups(1, gidset) == -1 2506 && suidwarn) 2507 { 2508 syserr("openmailer: setgroups() failed"); 2509 exit(EX_TEMPFAIL); 2510 } 2511 } 2512 if (m->m_gid == NO_GID) 2513 new_gid = DefGid; 2514 else 2515 new_gid = m->m_gid; 2516 } 2517 if (new_gid != NO_GID) 2518 { 2519 if (RunAsUid != 0 && 2520 bitnset(M_SPECIFIC_UID, m->m_flags) && 2521 new_gid != getgid() && 2522 new_gid != getegid()) 2523 { 2524 /* Only root can change the gid */ 2525 syserr("openmailer: insufficient privileges to change gid, RunAsUid=%d, new_gid=%d, gid=%d, egid=%d", 2526 (int) RunAsUid, (int) new_gid, 2527 (int) getgid(), (int) getegid()); 2528 exit(EX_TEMPFAIL); 2529 } 2530 2531 if (setgid(new_gid) < 0 && suidwarn) 2532 { 2533 syserr("openmailer: setgid(%ld) failed", 2534 (long) new_gid); 2535 exit(EX_TEMPFAIL); 2536 } 2537 } 2538 2539 /* change root to some "safe" directory */ 2540 if (m->m_rootdir != NULL) 2541 { 2542 expand(m->m_rootdir, cbuf, sizeof(cbuf), e); 2543 if (tTd(11, 20)) 2544 sm_dprintf("openmailer: chroot %s\n", 2545 cbuf); 2546 if (chroot(cbuf) < 0) 2547 { 2548 syserr("openmailer: Cannot chroot(%s)", 2549 cbuf); 2550 exit(EX_TEMPFAIL); 2551 } 2552 if (chdir("/") < 0) 2553 { 2554 syserr("openmailer: cannot chdir(/)"); 2555 exit(EX_TEMPFAIL); 2556 } 2557 } 2558 2559 /* reset user id */ 2560 endpwent(); 2561 sm_mbdb_terminate(); 2562 if (bitnset(M_SPECIFIC_UID, m->m_flags)) 2563 { 2564 if (m->m_uid == NO_UID) 2565 new_euid = RunAsUid; 2566 else 2567 new_euid = m->m_uid; 2568 2569 /* 2570 ** Undo the effects of the uid change in main 2571 ** for signal handling. The real uid may 2572 ** be used by mailer in adding a "From " 2573 ** line. 2574 */ 2575 2576 if (RealUid != 0 && RealUid != getuid()) 2577 { 2578 # if MAILER_SETUID_METHOD == USE_SETEUID 2579 # if HASSETREUID 2580 if (setreuid(RealUid, geteuid()) < 0) 2581 { 2582 syserr("openmailer: setreuid(%d, %d) failed", 2583 (int) RealUid, (int) geteuid()); 2584 exit(EX_OSERR); 2585 } 2586 # endif /* HASSETREUID */ 2587 # endif /* MAILER_SETUID_METHOD == USE_SETEUID */ 2588 # if MAILER_SETUID_METHOD == USE_SETREUID 2589 new_ruid = RealUid; 2590 # endif /* MAILER_SETUID_METHOD == USE_SETREUID */ 2591 } 2592 } 2593 else if (bitset(S_ISUID, stb.st_mode)) 2594 new_ruid = stb.st_uid; 2595 else if (ctladdr != NULL && ctladdr->q_uid != 0) 2596 new_ruid = ctladdr->q_uid; 2597 else if (m->m_uid != NO_UID) 2598 new_ruid = m->m_uid; 2599 else 2600 new_ruid = DefUid; 2601 2602 # if _FFR_USE_SETLOGIN 2603 /* run disconnected from terminal and set login name */ 2604 if (setsid() >= 0 && 2605 ctladdr != NULL && ctladdr->q_uid != 0 && 2606 new_euid == ctladdr->q_uid) 2607 { 2608 struct passwd *pwd; 2609 2610 pwd = sm_getpwuid(ctladdr->q_uid); 2611 if (pwd != NULL && suidwarn) 2612 (void) setlogin(pwd->pw_name); 2613 endpwent(); 2614 } 2615 # endif /* _FFR_USE_SETLOGIN */ 2616 2617 if (new_euid != NO_UID) 2618 { 2619 if (RunAsUid != 0 && new_euid != RunAsUid) 2620 { 2621 /* Only root can change the uid */ 2622 syserr("openmailer: insufficient privileges to change uid, new_euid=%d, RunAsUid=%d", 2623 (int) new_euid, (int) RunAsUid); 2624 exit(EX_TEMPFAIL); 2625 } 2626 2627 vendor_set_uid(new_euid); 2628 # if MAILER_SETUID_METHOD == USE_SETEUID 2629 if (seteuid(new_euid) < 0 && suidwarn) 2630 { 2631 syserr("openmailer: seteuid(%ld) failed", 2632 (long) new_euid); 2633 exit(EX_TEMPFAIL); 2634 } 2635 # endif /* MAILER_SETUID_METHOD == USE_SETEUID */ 2636 # if MAILER_SETUID_METHOD == USE_SETREUID 2637 if (setreuid(new_ruid, new_euid) < 0 && suidwarn) 2638 { 2639 syserr("openmailer: setreuid(%ld, %ld) failed", 2640 (long) new_ruid, (long) new_euid); 2641 exit(EX_TEMPFAIL); 2642 } 2643 # endif /* MAILER_SETUID_METHOD == USE_SETREUID */ 2644 # if MAILER_SETUID_METHOD == USE_SETUID 2645 if (new_euid != geteuid() && setuid(new_euid) < 0 && suidwarn) 2646 { 2647 syserr("openmailer: setuid(%ld) failed", 2648 (long) new_euid); 2649 exit(EX_TEMPFAIL); 2650 } 2651 # endif /* MAILER_SETUID_METHOD == USE_SETUID */ 2652 } 2653 else if (new_ruid != NO_UID) 2654 { 2655 vendor_set_uid(new_ruid); 2656 if (setuid(new_ruid) < 0 && suidwarn) 2657 { 2658 syserr("openmailer: setuid(%ld) failed", 2659 (long) new_ruid); 2660 exit(EX_TEMPFAIL); 2661 } 2662 } 2663 2664 if (tTd(11, 2)) 2665 sm_dprintf("openmailer: running as r/euid=%d/%d, r/egid=%d/%d\n", 2666 (int) getuid(), (int) geteuid(), 2667 (int) getgid(), (int) getegid()); 2668 2669 /* move into some "safe" directory */ 2670 if (m->m_execdir != NULL) 2671 { 2672 char *q; 2673 2674 for (p = m->m_execdir; p != NULL; p = q) 2675 { 2676 q = strchr(p, ':'); 2677 if (q != NULL) 2678 *q = '\0'; 2679 expand(p, cbuf, sizeof(cbuf), e); 2680 if (q != NULL) 2681 *q++ = ':'; 2682 if (tTd(11, 20)) 2683 sm_dprintf("openmailer: trydir %s\n", 2684 cbuf); 2685 if (cbuf[0] != '\0' && 2686 chdir(cbuf) >= 0) 2687 break; 2688 } 2689 } 2690 2691 /* Check safety of program to be run */ 2692 sff = SFF_ROOTOK|SFF_EXECOK; 2693 if (!bitnset(DBS_RUNWRITABLEPROGRAM, 2694 DontBlameSendmail)) 2695 sff |= SFF_NOGWFILES|SFF_NOWWFILES; 2696 if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH, 2697 DontBlameSendmail)) 2698 sff |= SFF_NOPATHCHECK; 2699 else 2700 sff |= SFF_SAFEDIRPATH; 2701 ret = safefile(m->m_mailer, getuid(), getgid(), 2702 user, sff, 0, NULL); 2703 if (ret != 0) 2704 sm_syslog(LOG_INFO, e->e_id, 2705 "Warning: program %s unsafe: %s", 2706 m->m_mailer, sm_errstring(ret)); 2707 2708 /* arrange to filter std & diag output of command */ 2709 (void) close(rpvect[0]); 2710 if (dup2(rpvect[1], STDOUT_FILENO) < 0) 2711 { 2712 syserr("%s... openmailer(%s): cannot dup pipe %d for stdout", 2713 shortenstring(e->e_to, MAXSHORTSTR), 2714 m->m_name, rpvect[1]); 2715 _exit(EX_OSERR); 2716 } 2717 (void) close(rpvect[1]); 2718 2719 if (dup2(STDOUT_FILENO, STDERR_FILENO) < 0) 2720 { 2721 syserr("%s... openmailer(%s): cannot dup stdout for stderr", 2722 shortenstring(e->e_to, MAXSHORTSTR), 2723 m->m_name); 2724 _exit(EX_OSERR); 2725 } 2726 2727 /* arrange to get standard input */ 2728 (void) close(mpvect[1]); 2729 if (dup2(mpvect[0], STDIN_FILENO) < 0) 2730 { 2731 syserr("%s... openmailer(%s): cannot dup pipe %d for stdin", 2732 shortenstring(e->e_to, MAXSHORTSTR), 2733 m->m_name, mpvect[0]); 2734 _exit(EX_OSERR); 2735 } 2736 (void) close(mpvect[0]); 2737 2738 /* arrange for all the files to be closed */ 2739 sm_close_on_exec(STDERR_FILENO + 1, DtableSize); 2740 2741 # if !_FFR_USE_SETLOGIN 2742 /* run disconnected from terminal */ 2743 (void) setsid(); 2744 # endif /* !_FFR_USE_SETLOGIN */ 2745 2746 /* try to execute the mailer */ 2747 (void) execve(m->m_mailer, (ARGV_T) pv, 2748 (ARGV_T) UserEnviron); 2749 save_errno = errno; 2750 syserr("Cannot exec %s", m->m_mailer); 2751 if (bitnset(M_LOCALMAILER, m->m_flags) || 2752 transienterror(save_errno)) 2753 _exit(EX_OSERR); 2754 _exit(EX_UNAVAILABLE); 2755 } 2756 2757 /* 2758 ** Set up return value. 2759 */ 2760 2761 if (mci == NULL) 2762 { 2763 if (clever) 2764 { 2765 /* 2766 ** Allocate from general heap, not 2767 ** envelope rpool, because this mci 2768 ** is going to be cached. 2769 */ 2770 2771 mci = mci_new(NULL); 2772 } 2773 else 2774 { 2775 /* 2776 ** Prevent a storage leak by allocating 2777 ** this from the envelope rpool. 2778 */ 2779 2780 mci = mci_new(e->e_rpool); 2781 } 2782 } 2783 mci->mci_mailer = m; 2784 if (clever) 2785 { 2786 mci->mci_state = MCIS_OPENING; 2787 mci_cache(mci); 2788 } 2789 else 2790 { 2791 mci->mci_state = MCIS_OPEN; 2792 } 2793 mci->mci_pid = pid; 2794 (void) close(mpvect[0]); 2795 mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT, 2796 (void *) &(mpvect[1]), SM_IO_WRONLY_B, 2797 NULL); 2798 if (mci->mci_out == NULL) 2799 { 2800 syserr("deliver: cannot create mailer output channel, fd=%d", 2801 mpvect[1]); 2802 (void) close(mpvect[1]); 2803 (void) close(rpvect[0]); 2804 (void) close(rpvect[1]); 2805 rcode = EX_OSERR; 2806 goto give_up; 2807 } 2808 2809 (void) close(rpvect[1]); 2810 mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT, 2811 (void *) &(rpvect[0]), SM_IO_RDONLY_B, 2812 NULL); 2813 if (mci->mci_in == NULL) 2814 { 2815 syserr("deliver: cannot create mailer input channel, fd=%d", 2816 mpvect[1]); 2817 (void) close(rpvect[0]); 2818 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT); 2819 mci->mci_out = NULL; 2820 rcode = EX_OSERR; 2821 goto give_up; 2822 } 2823 } 2824 2825 /* 2826 ** If we are in SMTP opening state, send initial protocol. 2827 */ 2828 2829 if (bitnset(M_7BITS, m->m_flags) && 2830 (!clever || mci->mci_state == MCIS_OPENING)) 2831 mci->mci_flags |= MCIF_7BIT; 2832 if (clever && mci->mci_state != MCIS_CLOSED) 2833 { 2834 # if STARTTLS || SASL 2835 int dotpos; 2836 char *srvname; 2837 extern SOCKADDR CurHostAddr; 2838 # endif /* STARTTLS || SASL */ 2839 2840 # if SASL 2841 # define DONE_AUTH(f) bitset(MCIF_AUTHACT, f) 2842 # endif /* SASL */ 2843 # if STARTTLS 2844 # define DONE_STARTTLS(f) bitset(MCIF_TLSACT, f) 2845 # endif /* STARTTLS */ 2846 # define ONLY_HELO(f) bitset(MCIF_ONLY_EHLO, f) 2847 # define SET_HELO(f) f |= MCIF_ONLY_EHLO 2848 # define CLR_HELO(f) f &= ~MCIF_ONLY_EHLO 2849 2850 # if STARTTLS || SASL 2851 /* don't use CurHostName, it is changed in many places */ 2852 if (mci->mci_host != NULL) 2853 { 2854 srvname = mci->mci_host; 2855 dotpos = strlen(srvname) - 1; 2856 if (dotpos >= 0) 2857 { 2858 if (srvname[dotpos] == '.') 2859 srvname[dotpos] = '\0'; 2860 else 2861 dotpos = -1; 2862 } 2863 } 2864 else if (mci->mci_mailer != NULL) 2865 { 2866 srvname = mci->mci_mailer->m_name; 2867 dotpos = -1; 2868 } 2869 else 2870 { 2871 srvname = "local"; 2872 dotpos = -1; 2873 } 2874 2875 /* don't set {server_name} to NULL or "": see getauth() */ 2876 macdefine(&mci->mci_macro, A_TEMP, macid("{server_name}"), 2877 srvname); 2878 2879 /* CurHostAddr is set by makeconnection() and mci_get() */ 2880 if (CurHostAddr.sa.sa_family != 0) 2881 { 2882 macdefine(&mci->mci_macro, A_TEMP, 2883 macid("{server_addr}"), 2884 anynet_ntoa(&CurHostAddr)); 2885 } 2886 else if (mci->mci_mailer != NULL) 2887 { 2888 /* mailer name is unique, use it as address */ 2889 macdefine(&mci->mci_macro, A_PERM, 2890 macid("{server_addr}"), 2891 mci->mci_mailer->m_name); 2892 } 2893 else 2894 { 2895 /* don't set it to NULL or "": see getauth() */ 2896 macdefine(&mci->mci_macro, A_PERM, 2897 macid("{server_addr}"), "0"); 2898 } 2899 2900 /* undo change of srvname (mci->mci_host) */ 2901 if (dotpos >= 0) 2902 srvname[dotpos] = '.'; 2903 2904 reconnect: /* after switching to an encrypted connection */ 2905 # endif /* STARTTLS || SASL */ 2906 2907 /* set the current connection information */ 2908 e->e_mci = mci; 2909 # if SASL 2910 mci->mci_saslcap = NULL; 2911 # endif /* SASL */ 2912 smtpinit(m, mci, e, ONLY_HELO(mci->mci_flags)); 2913 CLR_HELO(mci->mci_flags); 2914 2915 if (IS_DLVR_RETURN(e)) 2916 { 2917 /* 2918 ** Check whether other side can deliver e-mail 2919 ** fast enough 2920 */ 2921 2922 if (!bitset(MCIF_DLVR_BY, mci->mci_flags)) 2923 { 2924 e->e_status = "5.4.7"; 2925 usrerrenh(e->e_status, 2926 "554 Server does not support Deliver By"); 2927 rcode = EX_UNAVAILABLE; 2928 goto give_up; 2929 } 2930 if (e->e_deliver_by > 0 && 2931 e->e_deliver_by - (curtime() - e->e_ctime) < 2932 mci->mci_min_by) 2933 { 2934 e->e_status = "5.4.7"; 2935 usrerrenh(e->e_status, 2936 "554 Message can't be delivered in time; %ld < %ld", 2937 e->e_deliver_by - (curtime() - e->e_ctime), 2938 mci->mci_min_by); 2939 rcode = EX_UNAVAILABLE; 2940 goto give_up; 2941 } 2942 } 2943 2944 # if STARTTLS 2945 /* first TLS then AUTH to provide a security layer */ 2946 if (mci->mci_state != MCIS_CLOSED && 2947 !DONE_STARTTLS(mci->mci_flags)) 2948 { 2949 int olderrors; 2950 bool usetls; 2951 bool saveQuickAbort = QuickAbort; 2952 bool saveSuprErrs = SuprErrs; 2953 char *host = NULL; 2954 2955 rcode = EX_OK; 2956 usetls = bitset(MCIF_TLS, mci->mci_flags); 2957 if (usetls) 2958 usetls = !iscltflgset(e, D_NOTLS); 2959 2960 host = macvalue(macid("{server_name}"), e); 2961 if (usetls) 2962 { 2963 olderrors = Errors; 2964 QuickAbort = false; 2965 SuprErrs = true; 2966 if (rscheck("try_tls", host, NULL, e, 2967 RSF_RMCOMM, 7, host, NOQID, NULL) 2968 != EX_OK 2969 || Errors > olderrors) 2970 { 2971 usetls = false; 2972 } 2973 SuprErrs = saveSuprErrs; 2974 QuickAbort = saveQuickAbort; 2975 } 2976 2977 if (usetls) 2978 { 2979 if ((rcode = starttls(m, mci, e)) == EX_OK) 2980 { 2981 /* start again without STARTTLS */ 2982 mci->mci_flags |= MCIF_TLSACT; 2983 } 2984 else 2985 { 2986 char *s; 2987 2988 /* 2989 ** TLS negotiation failed, what to do? 2990 ** fall back to unencrypted connection 2991 ** or abort? How to decide? 2992 ** set a macro and call a ruleset. 2993 */ 2994 2995 mci->mci_flags &= ~MCIF_TLS; 2996 switch (rcode) 2997 { 2998 case EX_TEMPFAIL: 2999 s = "TEMP"; 3000 break; 3001 case EX_USAGE: 3002 s = "USAGE"; 3003 break; 3004 case EX_PROTOCOL: 3005 s = "PROTOCOL"; 3006 break; 3007 case EX_SOFTWARE: 3008 s = "SOFTWARE"; 3009 break; 3010 case EX_UNAVAILABLE: 3011 s = "NONE"; 3012 break; 3013 3014 /* everything else is a failure */ 3015 default: 3016 s = "FAILURE"; 3017 rcode = EX_TEMPFAIL; 3018 } 3019 macdefine(&e->e_macro, A_PERM, 3020 macid("{verify}"), s); 3021 } 3022 } 3023 else 3024 macdefine(&e->e_macro, A_PERM, 3025 macid("{verify}"), "NONE"); 3026 olderrors = Errors; 3027 QuickAbort = false; 3028 SuprErrs = true; 3029 3030 /* 3031 ** rcode == EX_SOFTWARE is special: 3032 ** the TLS negotiation failed 3033 ** we have to drop the connection no matter what 3034 ** However, we call tls_server to give it the chance 3035 ** to log the problem and return an appropriate 3036 ** error code. 3037 */ 3038 3039 if (rscheck("tls_server", 3040 macvalue(macid("{verify}"), e), 3041 NULL, e, RSF_RMCOMM|RSF_COUNT, 5, 3042 host, NOQID, NULL) != EX_OK || 3043 Errors > olderrors || 3044 rcode == EX_SOFTWARE) 3045 { 3046 char enhsc[ENHSCLEN]; 3047 extern char MsgBuf[]; 3048 3049 if (ISSMTPCODE(MsgBuf) && 3050 extenhsc(MsgBuf + 4, ' ', enhsc) > 0) 3051 { 3052 p = sm_rpool_strdup_x(e->e_rpool, 3053 MsgBuf); 3054 } 3055 else 3056 { 3057 p = "403 4.7.0 server not authenticated."; 3058 (void) sm_strlcpy(enhsc, "4.7.0", 3059 sizeof(enhsc)); 3060 } 3061 SuprErrs = saveSuprErrs; 3062 QuickAbort = saveQuickAbort; 3063 3064 if (rcode == EX_SOFTWARE) 3065 { 3066 /* drop the connection */ 3067 mci->mci_state = MCIS_QUITING; 3068 if (mci->mci_in != NULL) 3069 { 3070 (void) sm_io_close(mci->mci_in, 3071 SM_TIME_DEFAULT); 3072 mci->mci_in = NULL; 3073 } 3074 mci->mci_flags &= ~MCIF_TLSACT; 3075 (void) endmailer(mci, e, pv); 3076 } 3077 else 3078 { 3079 /* abort transfer */ 3080 smtpquit(m, mci, e); 3081 } 3082 3083 /* avoid bogus error msg */ 3084 mci->mci_errno = 0; 3085 3086 /* temp or permanent failure? */ 3087 rcode = (*p == '4') ? EX_TEMPFAIL 3088 : EX_UNAVAILABLE; 3089 mci_setstat(mci, rcode, enhsc, p); 3090 3091 /* 3092 ** hack to get the error message into 3093 ** the envelope (done in giveresponse()) 3094 */ 3095 3096 (void) sm_strlcpy(SmtpError, p, 3097 sizeof(SmtpError)); 3098 } 3099 else if (mci->mci_state == MCIS_CLOSED) 3100 { 3101 /* connection close caused by 421 */ 3102 mci->mci_errno = 0; 3103 rcode = EX_TEMPFAIL; 3104 mci_setstat(mci, rcode, NULL, "421"); 3105 } 3106 else 3107 rcode = 0; 3108 3109 QuickAbort = saveQuickAbort; 3110 SuprErrs = saveSuprErrs; 3111 if (DONE_STARTTLS(mci->mci_flags) && 3112 mci->mci_state != MCIS_CLOSED) 3113 { 3114 SET_HELO(mci->mci_flags); 3115 mci_clr_extensions(mci); 3116 goto reconnect; 3117 } 3118 } 3119 # endif /* STARTTLS */ 3120 # if SASL 3121 /* if other server supports authentication let's authenticate */ 3122 if (mci->mci_state != MCIS_CLOSED && 3123 mci->mci_saslcap != NULL && 3124 !DONE_AUTH(mci->mci_flags) && !iscltflgset(e, D_NOAUTH)) 3125 { 3126 /* Should we require some minimum authentication? */ 3127 if ((ret = smtpauth(m, mci, e)) == EX_OK) 3128 { 3129 int result; 3130 sasl_ssf_t *ssf = NULL; 3131 3132 /* Get security strength (features) */ 3133 result = sasl_getprop(mci->mci_conn, SASL_SSF, 3134 # if SASL >= 20000 3135 (const void **) &ssf); 3136 # else /* SASL >= 20000 */ 3137 (void **) &ssf); 3138 # endif /* SASL >= 20000 */ 3139 3140 /* XXX authid? */ 3141 if (LogLevel > 9) 3142 sm_syslog(LOG_INFO, NOQID, 3143 "AUTH=client, relay=%.100s, mech=%.16s, bits=%d", 3144 mci->mci_host, 3145 macvalue(macid("{auth_type}"), e), 3146 result == SASL_OK ? *ssf : 0); 3147 3148 /* 3149 ** Only switch to encrypted connection 3150 ** if a security layer has been negotiated 3151 */ 3152 3153 if (result == SASL_OK && *ssf > 0) 3154 { 3155 int tmo; 3156 3157 /* 3158 ** Convert I/O layer to use SASL. 3159 ** If the call fails, the connection 3160 ** is aborted. 3161 */ 3162 3163 tmo = DATA_PROGRESS_TIMEOUT * 1000; 3164 if (sfdcsasl(&mci->mci_in, 3165 &mci->mci_out, 3166 mci->mci_conn, tmo) == 0) 3167 { 3168 mci_clr_extensions(mci); 3169 mci->mci_flags |= MCIF_AUTHACT| 3170 MCIF_ONLY_EHLO; 3171 goto reconnect; 3172 } 3173 syserr("AUTH TLS switch failed in client"); 3174 } 3175 /* else? XXX */ 3176 mci->mci_flags |= MCIF_AUTHACT; 3177 3178 } 3179 else if (ret == EX_TEMPFAIL) 3180 { 3181 if (LogLevel > 8) 3182 sm_syslog(LOG_ERR, NOQID, 3183 "AUTH=client, relay=%.100s, temporary failure, connection abort", 3184 mci->mci_host); 3185 smtpquit(m, mci, e); 3186 3187 /* avoid bogus error msg */ 3188 mci->mci_errno = 0; 3189 rcode = EX_TEMPFAIL; 3190 mci_setstat(mci, rcode, "4.3.0", p); 3191 3192 /* 3193 ** hack to get the error message into 3194 ** the envelope (done in giveresponse()) 3195 */ 3196 3197 (void) sm_strlcpy(SmtpError, 3198 "Temporary AUTH failure", 3199 sizeof(SmtpError)); 3200 } 3201 } 3202 # endif /* SASL */ 3203 } 3204 3205 3206 do_transfer: 3207 /* clear out per-message flags from connection structure */ 3208 mci->mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7); 3209 3210 if (bitset(EF_HAS8BIT, e->e_flags) && 3211 !bitset(EF_DONT_MIME, e->e_flags) && 3212 bitnset(M_7BITS, m->m_flags)) 3213 mci->mci_flags |= MCIF_CVT8TO7; 3214 3215 #if MIME7TO8 3216 if (bitnset(M_MAKE8BIT, m->m_flags) && 3217 !bitset(MCIF_7BIT, mci->mci_flags) && 3218 (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL && 3219 (sm_strcasecmp(p, "quoted-printable") == 0 || 3220 sm_strcasecmp(p, "base64") == 0) && 3221 (p = hvalue("Content-Type", e->e_header)) != NULL) 3222 { 3223 /* may want to convert 7 -> 8 */ 3224 /* XXX should really parse it here -- and use a class XXX */ 3225 if (sm_strncasecmp(p, "text/plain", 10) == 0 && 3226 (p[10] == '\0' || p[10] == ' ' || p[10] == ';')) 3227 mci->mci_flags |= MCIF_CVT7TO8; 3228 } 3229 #endif /* MIME7TO8 */ 3230 3231 if (tTd(11, 1)) 3232 { 3233 sm_dprintf("openmailer: "); 3234 mci_dump(sm_debug_file(), mci, false); 3235 } 3236 3237 #if _FFR_CLIENT_SIZE 3238 /* 3239 ** See if we know the maximum size and 3240 ** abort if the message is too big. 3241 ** 3242 ** NOTE: _FFR_CLIENT_SIZE is untested. 3243 */ 3244 3245 if (bitset(MCIF_SIZE, mci->mci_flags) && 3246 mci->mci_maxsize > 0 && 3247 e->e_msgsize > mci->mci_maxsize) 3248 { 3249 e->e_flags |= EF_NO_BODY_RETN; 3250 if (bitnset(M_LOCALMAILER, m->m_flags)) 3251 e->e_status = "5.2.3"; 3252 else 3253 e->e_status = "5.3.4"; 3254 3255 usrerrenh(e->e_status, 3256 "552 Message is too large; %ld bytes max", 3257 mci->mci_maxsize); 3258 rcode = EX_DATAERR; 3259 3260 /* Need an e_message for error */ 3261 (void) sm_snprintf(SmtpError, sizeof(SmtpError), 3262 "Message is too large; %ld bytes max", 3263 mci->mci_maxsize); 3264 goto give_up; 3265 } 3266 #endif /* _FFR_CLIENT_SIZE */ 3267 3268 if (mci->mci_state != MCIS_OPEN) 3269 { 3270 /* couldn't open the mailer */ 3271 rcode = mci->mci_exitstat; 3272 errno = mci->mci_errno; 3273 SM_SET_H_ERRNO(mci->mci_herrno); 3274 if (rcode == EX_OK) 3275 { 3276 /* shouldn't happen */ 3277 syserr("554 5.3.5 deliver: mci=%lx rcode=%d errno=%d state=%d sig=%s", 3278 (unsigned long) mci, rcode, errno, 3279 mci->mci_state, firstsig); 3280 mci_dump_all(smioout, true); 3281 rcode = EX_SOFTWARE; 3282 } 3283 else if (nummxhosts > hostnum) 3284 { 3285 /* try next MX site */ 3286 goto tryhost; 3287 } 3288 } 3289 else if (!clever) 3290 { 3291 bool ok; 3292 3293 /* 3294 ** Format and send message. 3295 */ 3296 3297 rcode = EX_OK; 3298 errno = 0; 3299 ok = putfromline(mci, e); 3300 if (ok) 3301 ok = (*e->e_puthdr)(mci, e->e_header, e, M87F_OUTER); 3302 if (ok) 3303 ok = (*e->e_putbody)(mci, e, NULL); 3304 if (ok && bitset(MCIF_INLONGLINE, mci->mci_flags)) 3305 ok = putline("", mci); 3306 3307 /* 3308 ** Ignore an I/O error that was caused by EPIPE. 3309 ** Some broken mailers don't read the entire body 3310 ** but just exit() thus causing an I/O error. 3311 */ 3312 3313 if (!ok && (sm_io_error(mci->mci_out) && errno == EPIPE)) 3314 ok = true; 3315 3316 /* (always) get the exit status */ 3317 rcode = endmailer(mci, e, pv); 3318 if (!ok) 3319 rcode = EX_TEMPFAIL; 3320 if (rcode == EX_TEMPFAIL && SmtpError[0] == '\0') 3321 { 3322 /* 3323 ** Need an e_message for mailq display. 3324 ** We set SmtpError as 3325 */ 3326 3327 (void) sm_snprintf(SmtpError, sizeof(SmtpError), 3328 "%s mailer (%s) exited with EX_TEMPFAIL", 3329 m->m_name, m->m_mailer); 3330 } 3331 } 3332 else 3333 { 3334 /* 3335 ** Send the MAIL FROM: protocol 3336 */ 3337 3338 /* XXX this isn't pipelined... */ 3339 rcode = smtpmailfrom(m, mci, e); 3340 if (rcode == EX_OK) 3341 { 3342 register int i; 3343 # if PIPELINING 3344 ADDRESS *volatile pchain; 3345 # endif /* PIPELINING */ 3346 3347 /* send the recipient list */ 3348 tobuf[0] = '\0'; 3349 mci->mci_retryrcpt = false; 3350 mci->mci_tolist = tobuf; 3351 # if PIPELINING 3352 pchain = NULL; 3353 mci->mci_nextaddr = NULL; 3354 # endif /* PIPELINING */ 3355 3356 for (to = tochain; to != NULL; to = to->q_tchain) 3357 { 3358 if (!QS_IS_UNMARKED(to->q_state)) 3359 continue; 3360 3361 /* mark recipient state as "ok so far" */ 3362 to->q_state = QS_OK; 3363 e->e_to = to->q_paddr; 3364 # if STARTTLS 3365 i = rscheck("tls_rcpt", to->q_user, NULL, e, 3366 RSF_RMCOMM|RSF_COUNT, 3, 3367 mci->mci_host, e->e_id, NULL); 3368 if (i != EX_OK) 3369 { 3370 markfailure(e, to, mci, i, false); 3371 giveresponse(i, to->q_status, m, mci, 3372 ctladdr, xstart, e, to); 3373 if (i == EX_TEMPFAIL) 3374 { 3375 mci->mci_retryrcpt = true; 3376 to->q_state = QS_RETRY; 3377 } 3378 continue; 3379 } 3380 # endif /* STARTTLS */ 3381 3382 i = smtprcpt(to, m, mci, e, ctladdr, xstart); 3383 # if PIPELINING 3384 if (i == EX_OK && 3385 bitset(MCIF_PIPELINED, mci->mci_flags)) 3386 { 3387 /* 3388 ** Add new element to list of 3389 ** recipients for pipelining. 3390 */ 3391 3392 to->q_pchain = NULL; 3393 if (mci->mci_nextaddr == NULL) 3394 mci->mci_nextaddr = to; 3395 if (pchain == NULL) 3396 pchain = to; 3397 else 3398 { 3399 pchain->q_pchain = to; 3400 pchain = pchain->q_pchain; 3401 } 3402 } 3403 # endif /* PIPELINING */ 3404 if (i != EX_OK) 3405 { 3406 markfailure(e, to, mci, i, false); 3407 giveresponse(i, to->q_status, m, mci, 3408 ctladdr, xstart, e, to); 3409 if (i == EX_TEMPFAIL) 3410 to->q_state = QS_RETRY; 3411 } 3412 } 3413 3414 /* No recipients in list and no missing responses? */ 3415 if (tobuf[0] == '\0' 3416 # if PIPELINING 3417 && bitset(MCIF_PIPELINED, mci->mci_flags) 3418 && mci->mci_nextaddr == NULL 3419 # endif /* PIPELINING */ 3420 ) 3421 { 3422 rcode = EX_OK; 3423 e->e_to = NULL; 3424 if (bitset(MCIF_CACHED, mci->mci_flags)) 3425 smtprset(m, mci, e); 3426 } 3427 else 3428 { 3429 e->e_to = tobuf + 1; 3430 rcode = smtpdata(m, mci, e, ctladdr, xstart); 3431 } 3432 } 3433 if (rcode == EX_TEMPFAIL && nummxhosts > hostnum) 3434 { 3435 /* try next MX site */ 3436 goto tryhost; 3437 } 3438 } 3439 #if NAMED_BIND 3440 if (ConfigLevel < 2) 3441 _res.options |= RES_DEFNAMES | RES_DNSRCH; /* XXX */ 3442 #endif /* NAMED_BIND */ 3443 3444 if (tTd(62, 1)) 3445 checkfds("after delivery"); 3446 3447 /* 3448 ** Do final status disposal. 3449 ** We check for something in tobuf for the SMTP case. 3450 ** If we got a temporary failure, arrange to queue the 3451 ** addressees. 3452 */ 3453 3454 give_up: 3455 if (bitnset(M_LMTP, m->m_flags)) 3456 { 3457 lmtp_rcode = rcode; 3458 tobuf[0] = '\0'; 3459 anyok = false; 3460 strsize = 0; 3461 } 3462 else 3463 anyok = rcode == EX_OK; 3464 3465 for (to = tochain; to != NULL; to = to->q_tchain) 3466 { 3467 /* see if address already marked */ 3468 if (!QS_IS_OK(to->q_state)) 3469 continue; 3470 3471 /* if running LMTP, get the status for each address */ 3472 if (bitnset(M_LMTP, m->m_flags)) 3473 { 3474 if (lmtp_rcode == EX_OK) 3475 rcode = smtpgetstat(m, mci, e); 3476 if (rcode == EX_OK) 3477 { 3478 strsize += sm_strlcat2(tobuf + strsize, ",", 3479 to->q_paddr, 3480 tobufsize - strsize); 3481 SM_ASSERT(strsize < tobufsize); 3482 anyok = true; 3483 } 3484 else 3485 { 3486 e->e_to = to->q_paddr; 3487 markfailure(e, to, mci, rcode, true); 3488 giveresponse(rcode, to->q_status, m, mci, 3489 ctladdr, xstart, e, to); 3490 e->e_to = tobuf + 1; 3491 continue; 3492 } 3493 } 3494 else 3495 { 3496 /* mark bad addresses */ 3497 if (rcode != EX_OK) 3498 { 3499 if (goodmxfound && rcode == EX_NOHOST) 3500 rcode = EX_TEMPFAIL; 3501 markfailure(e, to, mci, rcode, true); 3502 continue; 3503 } 3504 } 3505 3506 /* successful delivery */ 3507 to->q_state = QS_SENT; 3508 to->q_statdate = curtime(); 3509 e->e_nsent++; 3510 3511 /* 3512 ** Checkpoint the send list every few addresses 3513 */ 3514 3515 if (CheckpointInterval > 0 && e->e_nsent >= CheckpointInterval) 3516 { 3517 queueup(e, false, false); 3518 e->e_nsent = 0; 3519 } 3520 3521 if (bitnset(M_LOCALMAILER, m->m_flags) && 3522 bitset(QPINGONSUCCESS, to->q_flags)) 3523 { 3524 to->q_flags |= QDELIVERED; 3525 to->q_status = "2.1.5"; 3526 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, 3527 "%s... Successfully delivered\n", 3528 to->q_paddr); 3529 } 3530 else if (bitset(QPINGONSUCCESS, to->q_flags) && 3531 bitset(QPRIMARY, to->q_flags) && 3532 !bitset(MCIF_DSN, mci->mci_flags)) 3533 { 3534 to->q_flags |= QRELAYED; 3535 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, 3536 "%s... relayed; expect no further notifications\n", 3537 to->q_paddr); 3538 } 3539 else if (IS_DLVR_NOTIFY(e) && 3540 !bitset(MCIF_DLVR_BY, mci->mci_flags) && 3541 bitset(QPRIMARY, to->q_flags) && 3542 (!bitset(QHASNOTIFY, to->q_flags) || 3543 bitset(QPINGONSUCCESS, to->q_flags) || 3544 bitset(QPINGONFAILURE, to->q_flags) || 3545 bitset(QPINGONDELAY, to->q_flags))) 3546 { 3547 /* RFC 2852, 4.1.4.2: no NOTIFY, or not NEVER */ 3548 to->q_flags |= QBYNRELAY; 3549 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, 3550 "%s... Deliver-by notify: relayed\n", 3551 to->q_paddr); 3552 } 3553 else if (IS_DLVR_TRACE(e) && 3554 (!bitset(QHASNOTIFY, to->q_flags) || 3555 bitset(QPINGONSUCCESS, to->q_flags) || 3556 bitset(QPINGONFAILURE, to->q_flags) || 3557 bitset(QPINGONDELAY, to->q_flags)) && 3558 bitset(QPRIMARY, to->q_flags)) 3559 { 3560 /* RFC 2852, 4.1.4: no NOTIFY, or not NEVER */ 3561 to->q_flags |= QBYTRACE; 3562 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, 3563 "%s... Deliver-By trace: relayed\n", 3564 to->q_paddr); 3565 } 3566 } 3567 3568 if (bitnset(M_LMTP, m->m_flags)) 3569 { 3570 /* 3571 ** Global information applies to the last recipient only; 3572 ** clear it out to avoid bogus errors. 3573 */ 3574 3575 rcode = EX_OK; 3576 e->e_statmsg = NULL; 3577 3578 /* reset the mci state for the next transaction */ 3579 if (mci != NULL && 3580 (mci->mci_state == MCIS_MAIL || 3581 mci->mci_state == MCIS_RCPT || 3582 mci->mci_state == MCIS_DATA)) 3583 { 3584 mci->mci_state = MCIS_OPEN; 3585 SmtpPhase = mci->mci_phase = "idle"; 3586 sm_setproctitle(true, e, "%s: %s", CurHostName, 3587 mci->mci_phase); 3588 } 3589 } 3590 3591 if (tobuf[0] != '\0') 3592 { 3593 giveresponse(rcode, NULL, m, mci, ctladdr, xstart, e, tochain); 3594 #if 0 3595 /* 3596 ** This code is disabled for now because I am not 3597 ** sure that copying status from the first recipient 3598 ** to all non-status'ed recipients is a good idea. 3599 */ 3600 3601 if (tochain->q_message != NULL && 3602 !bitnset(M_LMTP, m->m_flags) && rcode != EX_OK) 3603 { 3604 for (to = tochain->q_tchain; to != NULL; 3605 to = to->q_tchain) 3606 { 3607 /* see if address already marked */ 3608 if (QS_IS_QUEUEUP(to->q_state) && 3609 to->q_message == NULL) 3610 to->q_message = sm_rpool_strdup_x(e->e_rpool, 3611 tochain->q_message); 3612 } 3613 } 3614 #endif /* 0 */ 3615 } 3616 if (anyok) 3617 markstats(e, tochain, STATS_NORMAL); 3618 mci_store_persistent(mci); 3619 3620 /* Some recipients were tempfailed, try them on the next host */ 3621 if (mci != NULL && mci->mci_retryrcpt && nummxhosts > hostnum) 3622 { 3623 /* try next MX site */ 3624 goto tryhost; 3625 } 3626 3627 /* now close the connection */ 3628 if (clever && mci != NULL && mci->mci_state != MCIS_CLOSED && 3629 !bitset(MCIF_CACHED, mci->mci_flags)) 3630 smtpquit(m, mci, e); 3631 3632 cleanup: ; 3633 } 3634 SM_FINALLY 3635 { 3636 /* 3637 ** Restore state and return. 3638 */ 3639 #if XDEBUG 3640 char wbuf[MAXLINE]; 3641 3642 /* make absolutely certain 0, 1, and 2 are in use */ 3643 (void) sm_snprintf(wbuf, sizeof(wbuf), 3644 "%s... end of deliver(%s)", 3645 e->e_to == NULL ? "NO-TO-LIST" 3646 : shortenstring(e->e_to, 3647 MAXSHORTSTR), 3648 m->m_name); 3649 checkfd012(wbuf); 3650 #endif /* XDEBUG */ 3651 3652 errno = 0; 3653 3654 /* 3655 ** It was originally necessary to set macro 'g' to NULL 3656 ** because it previously pointed to an auto buffer. 3657 ** We don't do this any more, so this may be unnecessary. 3658 */ 3659 3660 macdefine(&e->e_macro, A_PERM, 'g', (char *) NULL); 3661 e->e_to = NULL; 3662 } 3663 SM_END_TRY 3664 return rcode; 3665 } 3666 3667 /* 3668 ** MARKFAILURE -- mark a failure on a specific address. 3669 ** 3670 ** Parameters: 3671 ** e -- the envelope we are sending. 3672 ** q -- the address to mark. 3673 ** mci -- mailer connection information. 3674 ** rcode -- the code signifying the particular failure. 3675 ** ovr -- override an existing code? 3676 ** 3677 ** Returns: 3678 ** none. 3679 ** 3680 ** Side Effects: 3681 ** marks the address (and possibly the envelope) with the 3682 ** failure so that an error will be returned or 3683 ** the message will be queued, as appropriate. 3684 */ 3685 3686 void 3687 markfailure(e, q, mci, rcode, ovr) 3688 register ENVELOPE *e; 3689 register ADDRESS *q; 3690 register MCI *mci; 3691 int rcode; 3692 bool ovr; 3693 { 3694 int save_errno = errno; 3695 char *status = NULL; 3696 char *rstatus = NULL; 3697 3698 switch (rcode) 3699 { 3700 case EX_OK: 3701 break; 3702 3703 case EX_TEMPFAIL: 3704 case EX_IOERR: 3705 case EX_OSERR: 3706 q->q_state = QS_QUEUEUP; 3707 break; 3708 3709 default: 3710 q->q_state = QS_BADADDR; 3711 break; 3712 } 3713 3714 /* find most specific error code possible */ 3715 if (mci != NULL && mci->mci_status != NULL) 3716 { 3717 status = sm_rpool_strdup_x(e->e_rpool, mci->mci_status); 3718 if (mci->mci_rstatus != NULL) 3719 rstatus = sm_rpool_strdup_x(e->e_rpool, 3720 mci->mci_rstatus); 3721 else 3722 rstatus = NULL; 3723 } 3724 else if (e->e_status != NULL) 3725 { 3726 status = e->e_status; 3727 rstatus = NULL; 3728 } 3729 else 3730 { 3731 switch (rcode) 3732 { 3733 case EX_USAGE: 3734 status = "5.5.4"; 3735 break; 3736 3737 case EX_DATAERR: 3738 status = "5.5.2"; 3739 break; 3740 3741 case EX_NOUSER: 3742 status = "5.1.1"; 3743 break; 3744 3745 case EX_NOHOST: 3746 status = "5.1.2"; 3747 break; 3748 3749 case EX_NOINPUT: 3750 case EX_CANTCREAT: 3751 case EX_NOPERM: 3752 status = "5.3.0"; 3753 break; 3754 3755 case EX_UNAVAILABLE: 3756 case EX_SOFTWARE: 3757 case EX_OSFILE: 3758 case EX_PROTOCOL: 3759 case EX_CONFIG: 3760 status = "5.5.0"; 3761 break; 3762 3763 case EX_OSERR: 3764 case EX_IOERR: 3765 status = "4.5.0"; 3766 break; 3767 3768 case EX_TEMPFAIL: 3769 status = "4.2.0"; 3770 break; 3771 } 3772 } 3773 3774 /* new status? */ 3775 if (status != NULL && *status != '\0' && (ovr || q->q_status == NULL || 3776 *q->q_status == '\0' || *q->q_status < *status)) 3777 { 3778 q->q_status = status; 3779 q->q_rstatus = rstatus; 3780 } 3781 if (rcode != EX_OK && q->q_rstatus == NULL && 3782 q->q_mailer != NULL && q->q_mailer->m_diagtype != NULL && 3783 sm_strcasecmp(q->q_mailer->m_diagtype, "X-UNIX") == 0) 3784 { 3785 char buf[16]; 3786 3787 (void) sm_snprintf(buf, sizeof(buf), "%d", rcode); 3788 q->q_rstatus = sm_rpool_strdup_x(e->e_rpool, buf); 3789 } 3790 3791 q->q_statdate = curtime(); 3792 if (CurHostName != NULL && CurHostName[0] != '\0' && 3793 mci != NULL && !bitset(M_LOCALMAILER, mci->mci_flags)) 3794 q->q_statmta = sm_rpool_strdup_x(e->e_rpool, CurHostName); 3795 3796 /* restore errno */ 3797 errno = save_errno; 3798 } 3799 /* 3800 ** ENDMAILER -- Wait for mailer to terminate. 3801 ** 3802 ** We should never get fatal errors (e.g., segmentation 3803 ** violation), so we report those specially. For other 3804 ** errors, we choose a status message (into statmsg), 3805 ** and if it represents an error, we print it. 3806 ** 3807 ** Parameters: 3808 ** mci -- the mailer connection info. 3809 ** e -- the current envelope. 3810 ** pv -- the parameter vector that invoked the mailer 3811 ** (for error messages). 3812 ** 3813 ** Returns: 3814 ** exit code of mailer. 3815 ** 3816 ** Side Effects: 3817 ** none. 3818 */ 3819 3820 static jmp_buf EndWaitTimeout; 3821 3822 static void 3823 endwaittimeout(ignore) 3824 int ignore; 3825 { 3826 /* 3827 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 3828 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 3829 ** DOING. 3830 */ 3831 3832 errno = ETIMEDOUT; 3833 longjmp(EndWaitTimeout, 1); 3834 } 3835 3836 int 3837 endmailer(mci, e, pv) 3838 register MCI *mci; 3839 register ENVELOPE *e; 3840 char **pv; 3841 { 3842 int st; 3843 int save_errno = errno; 3844 char buf[MAXLINE]; 3845 SM_EVENT *ev = NULL; 3846 3847 3848 mci_unlock_host(mci); 3849 3850 /* close output to mailer */ 3851 if (mci->mci_out != NULL) 3852 { 3853 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT); 3854 mci->mci_out = NULL; 3855 } 3856 3857 /* copy any remaining input to transcript */ 3858 if (mci->mci_in != NULL && mci->mci_state != MCIS_ERROR && 3859 e->e_xfp != NULL) 3860 { 3861 while (sfgets(buf, sizeof(buf), mci->mci_in, 3862 TimeOuts.to_quit, "Draining Input") != NULL) 3863 (void) sm_io_fputs(e->e_xfp, SM_TIME_DEFAULT, buf); 3864 } 3865 3866 #if SASL 3867 /* close SASL connection */ 3868 if (bitset(MCIF_AUTHACT, mci->mci_flags)) 3869 { 3870 sasl_dispose(&mci->mci_conn); 3871 mci->mci_flags &= ~MCIF_AUTHACT; 3872 } 3873 #endif /* SASL */ 3874 3875 #if STARTTLS 3876 /* shutdown TLS */ 3877 (void) endtlsclt(mci); 3878 #endif /* STARTTLS */ 3879 3880 /* now close the input */ 3881 if (mci->mci_in != NULL) 3882 { 3883 (void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT); 3884 mci->mci_in = NULL; 3885 } 3886 mci->mci_state = MCIS_CLOSED; 3887 3888 errno = save_errno; 3889 3890 /* in the IPC case there is nothing to wait for */ 3891 if (mci->mci_pid == 0) 3892 return EX_OK; 3893 3894 /* put a timeout around the wait */ 3895 if (mci->mci_mailer->m_wait > 0) 3896 { 3897 if (setjmp(EndWaitTimeout) == 0) 3898 ev = sm_setevent(mci->mci_mailer->m_wait, 3899 endwaittimeout, 0); 3900 else 3901 { 3902 syserr("endmailer %s: wait timeout (%ld)", 3903 mci->mci_mailer->m_name, 3904 (long) mci->mci_mailer->m_wait); 3905 return EX_TEMPFAIL; 3906 } 3907 } 3908 3909 /* wait for the mailer process, collect status */ 3910 st = waitfor(mci->mci_pid); 3911 save_errno = errno; 3912 if (ev != NULL) 3913 sm_clrevent(ev); 3914 errno = save_errno; 3915 3916 if (st == -1) 3917 { 3918 syserr("endmailer %s: wait", mci->mci_mailer->m_name); 3919 return EX_SOFTWARE; 3920 } 3921 3922 if (WIFEXITED(st)) 3923 { 3924 /* normal death -- return status */ 3925 return (WEXITSTATUS(st)); 3926 } 3927 3928 /* it died a horrid death */ 3929 syserr("451 4.3.0 mailer %s died with signal %d%s", 3930 mci->mci_mailer->m_name, WTERMSIG(st), 3931 WCOREDUMP(st) ? " (core dumped)" : 3932 (WIFSTOPPED(st) ? " (stopped)" : "")); 3933 3934 /* log the arguments */ 3935 if (pv != NULL && e->e_xfp != NULL) 3936 { 3937 register char **av; 3938 3939 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "Arguments:"); 3940 for (av = pv; *av != NULL; av++) 3941 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, " %s", 3942 *av); 3943 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "\n"); 3944 } 3945 3946 ExitStat = EX_TEMPFAIL; 3947 return EX_TEMPFAIL; 3948 } 3949 /* 3950 ** GIVERESPONSE -- Interpret an error response from a mailer 3951 ** 3952 ** Parameters: 3953 ** status -- the status code from the mailer (high byte 3954 ** only; core dumps must have been taken care of 3955 ** already). 3956 ** dsn -- the DSN associated with the address, if any. 3957 ** m -- the mailer info for this mailer. 3958 ** mci -- the mailer connection info -- can be NULL if the 3959 ** response is given before the connection is made. 3960 ** ctladdr -- the controlling address for the recipient 3961 ** address(es). 3962 ** xstart -- the transaction start time, for computing 3963 ** transaction delays. 3964 ** e -- the current envelope. 3965 ** to -- the current recipient (NULL if none). 3966 ** 3967 ** Returns: 3968 ** none. 3969 ** 3970 ** Side Effects: 3971 ** Errors may be incremented. 3972 ** ExitStat may be set. 3973 */ 3974 3975 void 3976 giveresponse(status, dsn, m, mci, ctladdr, xstart, e, to) 3977 int status; 3978 char *dsn; 3979 register MAILER *m; 3980 register MCI *mci; 3981 ADDRESS *ctladdr; 3982 time_t xstart; 3983 ENVELOPE *e; 3984 ADDRESS *to; 3985 { 3986 register const char *statmsg; 3987 int errnum = errno; 3988 int off = 4; 3989 bool usestat = false; 3990 char dsnbuf[ENHSCLEN]; 3991 char buf[MAXLINE]; 3992 char *exmsg; 3993 3994 if (e == NULL) 3995 { 3996 syserr("giveresponse: null envelope"); 3997 /* NOTREACHED */ 3998 SM_ASSERT(0); 3999 } 4000 4001 /* 4002 ** Compute status message from code. 4003 */ 4004 4005 exmsg = sm_sysexmsg(status); 4006 if (status == 0) 4007 { 4008 statmsg = "250 2.0.0 Sent"; 4009 if (e->e_statmsg != NULL) 4010 { 4011 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)", 4012 statmsg, 4013 shortenstring(e->e_statmsg, 403)); 4014 statmsg = buf; 4015 } 4016 } 4017 else if (exmsg == NULL) 4018 { 4019 (void) sm_snprintf(buf, sizeof(buf), 4020 "554 5.3.0 unknown mailer error %d", 4021 status); 4022 status = EX_UNAVAILABLE; 4023 statmsg = buf; 4024 usestat = true; 4025 } 4026 else if (status == EX_TEMPFAIL) 4027 { 4028 char *bp = buf; 4029 4030 (void) sm_strlcpy(bp, exmsg + 1, SPACELEFT(buf, bp)); 4031 bp += strlen(bp); 4032 #if NAMED_BIND 4033 if (h_errno == TRY_AGAIN) 4034 statmsg = sm_errstring(h_errno + E_DNSBASE); 4035 else 4036 #endif /* NAMED_BIND */ 4037 { 4038 if (errnum != 0) 4039 statmsg = sm_errstring(errnum); 4040 else 4041 statmsg = SmtpError; 4042 } 4043 if (statmsg != NULL && statmsg[0] != '\0') 4044 { 4045 switch (errnum) 4046 { 4047 #ifdef ENETDOWN 4048 case ENETDOWN: /* Network is down */ 4049 #endif /* ENETDOWN */ 4050 #ifdef ENETUNREACH 4051 case ENETUNREACH: /* Network is unreachable */ 4052 #endif /* ENETUNREACH */ 4053 #ifdef ENETRESET 4054 case ENETRESET: /* Network dropped connection on reset */ 4055 #endif /* ENETRESET */ 4056 #ifdef ECONNABORTED 4057 case ECONNABORTED: /* Software caused connection abort */ 4058 #endif /* ECONNABORTED */ 4059 #ifdef EHOSTDOWN 4060 case EHOSTDOWN: /* Host is down */ 4061 #endif /* EHOSTDOWN */ 4062 #ifdef EHOSTUNREACH 4063 case EHOSTUNREACH: /* No route to host */ 4064 #endif /* EHOSTUNREACH */ 4065 if (mci != NULL && mci->mci_host != NULL) 4066 { 4067 (void) sm_strlcpyn(bp, 4068 SPACELEFT(buf, bp), 4069 2, ": ", 4070 mci->mci_host); 4071 bp += strlen(bp); 4072 } 4073 break; 4074 } 4075 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ": ", 4076 statmsg); 4077 usestat = true; 4078 } 4079 statmsg = buf; 4080 } 4081 #if NAMED_BIND 4082 else if (status == EX_NOHOST && h_errno != 0) 4083 { 4084 statmsg = sm_errstring(h_errno + E_DNSBASE); 4085 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)", exmsg + 1, 4086 statmsg); 4087 statmsg = buf; 4088 usestat = true; 4089 } 4090 #endif /* NAMED_BIND */ 4091 else 4092 { 4093 statmsg = exmsg; 4094 if (*statmsg++ == ':' && errnum != 0) 4095 { 4096 (void) sm_snprintf(buf, sizeof(buf), "%s: %s", statmsg, 4097 sm_errstring(errnum)); 4098 statmsg = buf; 4099 usestat = true; 4100 } 4101 else if (bitnset(M_LMTP, m->m_flags) && e->e_statmsg != NULL) 4102 { 4103 (void) sm_snprintf(buf, sizeof(buf), "%s (%s)", statmsg, 4104 shortenstring(e->e_statmsg, 403)); 4105 statmsg = buf; 4106 usestat = true; 4107 } 4108 } 4109 4110 /* 4111 ** Print the message as appropriate 4112 */ 4113 4114 if (status == EX_OK || status == EX_TEMPFAIL) 4115 { 4116 extern char MsgBuf[]; 4117 4118 if ((off = isenhsc(statmsg + 4, ' ')) > 0) 4119 { 4120 if (dsn == NULL) 4121 { 4122 (void) sm_snprintf(dsnbuf, sizeof(dsnbuf), 4123 "%.*s", off, statmsg + 4); 4124 dsn = dsnbuf; 4125 } 4126 off += 5; 4127 } 4128 else 4129 { 4130 off = 4; 4131 } 4132 message("%s", statmsg + off); 4133 if (status == EX_TEMPFAIL && e->e_xfp != NULL) 4134 (void) sm_io_fprintf(e->e_xfp, SM_TIME_DEFAULT, "%s\n", 4135 &MsgBuf[4]); 4136 } 4137 else 4138 { 4139 char mbuf[ENHSCLEN + 4]; 4140 4141 Errors++; 4142 if ((off = isenhsc(statmsg + 4, ' ')) > 0 && 4143 off < sizeof(mbuf) - 4) 4144 { 4145 if (dsn == NULL) 4146 { 4147 (void) sm_snprintf(dsnbuf, sizeof(dsnbuf), 4148 "%.*s", off, statmsg + 4); 4149 dsn = dsnbuf; 4150 } 4151 off += 5; 4152 4153 /* copy only part of statmsg to mbuf */ 4154 (void) sm_strlcpy(mbuf, statmsg, off); 4155 (void) sm_strlcat(mbuf, " %s", sizeof(mbuf)); 4156 } 4157 else 4158 { 4159 dsnbuf[0] = '\0'; 4160 (void) sm_snprintf(mbuf, sizeof(mbuf), "%.3s %%s", 4161 statmsg); 4162 off = 4; 4163 } 4164 usrerr(mbuf, &statmsg[off]); 4165 } 4166 4167 /* 4168 ** Final cleanup. 4169 ** Log a record of the transaction. Compute the new 4170 ** ExitStat -- if we already had an error, stick with 4171 ** that. 4172 */ 4173 4174 if (OpMode != MD_VERIFY && !bitset(EF_VRFYONLY, e->e_flags) && 4175 LogLevel > ((status == EX_TEMPFAIL) ? 8 : (status == EX_OK) ? 7 : 6)) 4176 logdelivery(m, mci, dsn, statmsg + off, ctladdr, xstart, e); 4177 4178 if (tTd(11, 2)) 4179 sm_dprintf("giveresponse: status=%d, dsn=%s, e->e_message=%s, errnum=%d\n", 4180 status, 4181 dsn == NULL ? "<NULL>" : dsn, 4182 e->e_message == NULL ? "<NULL>" : e->e_message, 4183 errnum); 4184 4185 if (status != EX_TEMPFAIL) 4186 setstat(status); 4187 if (status != EX_OK && (status != EX_TEMPFAIL || e->e_message == NULL)) 4188 e->e_message = sm_rpool_strdup_x(e->e_rpool, statmsg + off); 4189 if (status != EX_OK && to != NULL && to->q_message == NULL) 4190 { 4191 if (!usestat && e->e_message != NULL) 4192 to->q_message = sm_rpool_strdup_x(e->e_rpool, 4193 e->e_message); 4194 else 4195 to->q_message = sm_rpool_strdup_x(e->e_rpool, 4196 statmsg + off); 4197 } 4198 errno = 0; 4199 SM_SET_H_ERRNO(0); 4200 } 4201 /* 4202 ** LOGDELIVERY -- log the delivery in the system log 4203 ** 4204 ** Care is taken to avoid logging lines that are too long, because 4205 ** some versions of syslog have an unfortunate proclivity for core 4206 ** dumping. This is a hack, to be sure, that is at best empirical. 4207 ** 4208 ** Parameters: 4209 ** m -- the mailer info. Can be NULL for initial queue. 4210 ** mci -- the mailer connection info -- can be NULL if the 4211 ** log is occurring when no connection is active. 4212 ** dsn -- the DSN attached to the status. 4213 ** status -- the message to print for the status. 4214 ** ctladdr -- the controlling address for the to list. 4215 ** xstart -- the transaction start time, used for 4216 ** computing transaction delay. 4217 ** e -- the current envelope. 4218 ** 4219 ** Returns: 4220 ** none 4221 ** 4222 ** Side Effects: 4223 ** none 4224 */ 4225 4226 void 4227 logdelivery(m, mci, dsn, status, ctladdr, xstart, e) 4228 MAILER *m; 4229 register MCI *mci; 4230 char *dsn; 4231 const char *status; 4232 ADDRESS *ctladdr; 4233 time_t xstart; 4234 register ENVELOPE *e; 4235 { 4236 register char *bp; 4237 register char *p; 4238 int l; 4239 time_t now = curtime(); 4240 char buf[1024]; 4241 4242 #if (SYSLOG_BUFSIZE) >= 256 4243 /* ctladdr: max 106 bytes */ 4244 bp = buf; 4245 if (ctladdr != NULL) 4246 { 4247 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", ctladdr=", 4248 shortenstring(ctladdr->q_paddr, 83)); 4249 bp += strlen(bp); 4250 if (bitset(QGOODUID, ctladdr->q_flags)) 4251 { 4252 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)", 4253 (int) ctladdr->q_uid, 4254 (int) ctladdr->q_gid); 4255 bp += strlen(bp); 4256 } 4257 } 4258 4259 /* delay & xdelay: max 41 bytes */ 4260 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", delay=", 4261 pintvl(now - e->e_ctime, true)); 4262 bp += strlen(bp); 4263 4264 if (xstart != (time_t) 0) 4265 { 4266 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", xdelay=", 4267 pintvl(now - xstart, true)); 4268 bp += strlen(bp); 4269 } 4270 4271 /* mailer: assume about 19 bytes (max 10 byte mailer name) */ 4272 if (m != NULL) 4273 { 4274 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", mailer=", 4275 m->m_name); 4276 bp += strlen(bp); 4277 } 4278 4279 /* pri: changes with each delivery attempt */ 4280 (void) sm_snprintf(bp, SPACELEFT(buf, bp), ", pri=%ld", 4281 PRT_NONNEGL(e->e_msgpriority)); 4282 bp += strlen(bp); 4283 4284 /* relay: max 66 bytes for IPv4 addresses */ 4285 if (mci != NULL && mci->mci_host != NULL) 4286 { 4287 extern SOCKADDR CurHostAddr; 4288 4289 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", relay=", 4290 shortenstring(mci->mci_host, 40)); 4291 bp += strlen(bp); 4292 4293 if (CurHostAddr.sa.sa_family != 0) 4294 { 4295 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " [%s]", 4296 anynet_ntoa(&CurHostAddr)); 4297 } 4298 } 4299 else if (strcmp(status, "quarantined") == 0) 4300 { 4301 if (e->e_quarmsg != NULL) 4302 (void) sm_snprintf(bp, SPACELEFT(buf, bp), 4303 ", quarantine=%s", 4304 shortenstring(e->e_quarmsg, 40)); 4305 } 4306 else if (strcmp(status, "queued") != 0) 4307 { 4308 p = macvalue('h', e); 4309 if (p != NULL && p[0] != '\0') 4310 { 4311 (void) sm_snprintf(bp, SPACELEFT(buf, bp), 4312 ", relay=%s", shortenstring(p, 40)); 4313 } 4314 } 4315 bp += strlen(bp); 4316 4317 /* dsn */ 4318 if (dsn != NULL && *dsn != '\0') 4319 { 4320 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", dsn=", 4321 shortenstring(dsn, ENHSCLEN)); 4322 bp += strlen(bp); 4323 } 4324 4325 #if _FFR_LOG_NTRIES 4326 /* ntries */ 4327 if (e->e_ntries >= 0) 4328 { 4329 (void) sm_snprintf(bp, SPACELEFT(buf, bp), 4330 ", ntries=%d", e->e_ntries + 1); 4331 bp += strlen(bp); 4332 } 4333 #endif /* _FFR_LOG_NTRIES */ 4334 4335 # define STATLEN (((SYSLOG_BUFSIZE) - 100) / 4) 4336 # if (STATLEN) < 63 4337 # undef STATLEN 4338 # define STATLEN 63 4339 # endif /* (STATLEN) < 63 */ 4340 # if (STATLEN) > 203 4341 # undef STATLEN 4342 # define STATLEN 203 4343 # endif /* (STATLEN) > 203 */ 4344 4345 /* stat: max 210 bytes */ 4346 if ((bp - buf) > (sizeof(buf) - ((STATLEN) + 20))) 4347 { 4348 /* desperation move -- truncate data */ 4349 bp = buf + sizeof(buf) - ((STATLEN) + 17); 4350 (void) sm_strlcpy(bp, "...", SPACELEFT(buf, bp)); 4351 bp += 3; 4352 } 4353 4354 (void) sm_strlcpy(bp, ", stat=", SPACELEFT(buf, bp)); 4355 bp += strlen(bp); 4356 4357 (void) sm_strlcpy(bp, shortenstring(status, STATLEN), 4358 SPACELEFT(buf, bp)); 4359 4360 /* id, to: max 13 + TOBUFSIZE bytes */ 4361 l = SYSLOG_BUFSIZE - 100 - strlen(buf); 4362 if (l < 0) 4363 l = 0; 4364 p = e->e_to == NULL ? "NO-TO-LIST" : e->e_to; 4365 while (strlen(p) >= l) 4366 { 4367 register char *q; 4368 4369 for (q = p + l; q > p; q--) 4370 { 4371 if (*q == ',') 4372 break; 4373 } 4374 if (p == q) 4375 break; 4376 sm_syslog(LOG_INFO, e->e_id, "to=%.*s [more]%s", 4377 (int) (++q - p), p, buf); 4378 p = q; 4379 } 4380 sm_syslog(LOG_INFO, e->e_id, "to=%.*s%s", l, p, buf); 4381 4382 #else /* (SYSLOG_BUFSIZE) >= 256 */ 4383 4384 l = SYSLOG_BUFSIZE - 85; 4385 if (l < 0) 4386 l = 0; 4387 p = e->e_to == NULL ? "NO-TO-LIST" : e->e_to; 4388 while (strlen(p) >= l) 4389 { 4390 register char *q; 4391 4392 for (q = p + l; q > p; q--) 4393 { 4394 if (*q == ',') 4395 break; 4396 } 4397 if (p == q) 4398 break; 4399 4400 sm_syslog(LOG_INFO, e->e_id, "to=%.*s [more]", 4401 (int) (++q - p), p); 4402 p = q; 4403 } 4404 sm_syslog(LOG_INFO, e->e_id, "to=%.*s", l, p); 4405 4406 if (ctladdr != NULL) 4407 { 4408 bp = buf; 4409 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, "ctladdr=", 4410 shortenstring(ctladdr->q_paddr, 83)); 4411 bp += strlen(bp); 4412 if (bitset(QGOODUID, ctladdr->q_flags)) 4413 { 4414 (void) sm_snprintf(bp, SPACELEFT(buf, bp), " (%d/%d)", 4415 ctladdr->q_uid, ctladdr->q_gid); 4416 bp += strlen(bp); 4417 } 4418 sm_syslog(LOG_INFO, e->e_id, "%s", buf); 4419 } 4420 bp = buf; 4421 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, "delay=", 4422 pintvl(now - e->e_ctime, true)); 4423 bp += strlen(bp); 4424 if (xstart != (time_t) 0) 4425 { 4426 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", xdelay=", 4427 pintvl(now - xstart, true)); 4428 bp += strlen(bp); 4429 } 4430 4431 if (m != NULL) 4432 { 4433 (void) sm_strlcpyn(bp, SPACELEFT(buf, bp), 2, ", mailer=", 4434 m->m_name); 4435 bp += strlen(bp); 4436 } 4437 sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf); 4438 4439 buf[0] = '\0'; 4440 bp = buf; 4441 if (mci != NULL && mci->mci_host != NULL) 4442 { 4443 extern SOCKADDR CurHostAddr; 4444 4445 (void) sm_snprintf(bp, SPACELEFT(buf, bp), "relay=%.100s", 4446 mci->mci_host); 4447 bp += strlen(bp); 4448 4449 if (CurHostAddr.sa.sa_family != 0) 4450 (void) sm_snprintf(bp, SPACELEFT(buf, bp), 4451 " [%.100s]", 4452 anynet_ntoa(&CurHostAddr)); 4453 } 4454 else if (strcmp(status, "quarantined") == 0) 4455 { 4456 if (e->e_quarmsg != NULL) 4457 (void) sm_snprintf(bp, SPACELEFT(buf, bp), 4458 ", quarantine=%.100s", 4459 e->e_quarmsg); 4460 } 4461 else if (strcmp(status, "queued") != 0) 4462 { 4463 p = macvalue('h', e); 4464 if (p != NULL && p[0] != '\0') 4465 (void) sm_snprintf(buf, sizeof(buf), "relay=%.100s", p); 4466 } 4467 if (buf[0] != '\0') 4468 sm_syslog(LOG_INFO, e->e_id, "%.1000s", buf); 4469 4470 sm_syslog(LOG_INFO, e->e_id, "stat=%s", shortenstring(status, 63)); 4471 #endif /* (SYSLOG_BUFSIZE) >= 256 */ 4472 } 4473 /* 4474 ** PUTFROMLINE -- output a UNIX-style from line (or whatever) 4475 ** 4476 ** This can be made an arbitrary message separator by changing $l 4477 ** 4478 ** One of the ugliest hacks seen by human eyes is contained herein: 4479 ** UUCP wants those stupid "remote from <host>" lines. Why oh why 4480 ** does a well-meaning programmer such as myself have to deal with 4481 ** this kind of antique garbage???? 4482 ** 4483 ** Parameters: 4484 ** mci -- the connection information. 4485 ** e -- the envelope. 4486 ** 4487 ** Returns: 4488 ** true iff line was written successfully 4489 ** 4490 ** Side Effects: 4491 ** outputs some text to fp. 4492 */ 4493 4494 bool 4495 putfromline(mci, e) 4496 register MCI *mci; 4497 ENVELOPE *e; 4498 { 4499 char *template = UnixFromLine; 4500 char buf[MAXLINE]; 4501 char xbuf[MAXLINE]; 4502 4503 if (bitnset(M_NHDR, mci->mci_mailer->m_flags)) 4504 return true; 4505 4506 mci->mci_flags |= MCIF_INHEADER; 4507 4508 if (bitnset(M_UGLYUUCP, mci->mci_mailer->m_flags)) 4509 { 4510 char *bang; 4511 4512 expand("\201g", buf, sizeof(buf), e); 4513 bang = strchr(buf, '!'); 4514 if (bang == NULL) 4515 { 4516 char *at; 4517 char hname[MAXNAME]; 4518 4519 /* 4520 ** If we can construct a UUCP path, do so 4521 */ 4522 4523 at = strrchr(buf, '@'); 4524 if (at == NULL) 4525 { 4526 expand("\201k", hname, sizeof(hname), e); 4527 at = hname; 4528 } 4529 else 4530 *at++ = '\0'; 4531 (void) sm_snprintf(xbuf, sizeof(xbuf), 4532 "From %.800s \201d remote from %.100s\n", 4533 buf, at); 4534 } 4535 else 4536 { 4537 *bang++ = '\0'; 4538 (void) sm_snprintf(xbuf, sizeof(xbuf), 4539 "From %.800s \201d remote from %.100s\n", 4540 bang, buf); 4541 template = xbuf; 4542 } 4543 } 4544 expand(template, buf, sizeof(buf), e); 4545 return putxline(buf, strlen(buf), mci, PXLF_HEADER); 4546 } 4547 4548 /* 4549 ** PUTBODY -- put the body of a message. 4550 ** 4551 ** Parameters: 4552 ** mci -- the connection information. 4553 ** e -- the envelope to put out. 4554 ** separator -- if non-NULL, a message separator that must 4555 ** not be permitted in the resulting message. 4556 ** 4557 ** Returns: 4558 ** true iff message was written successfully 4559 ** 4560 ** Side Effects: 4561 ** The message is written onto fp. 4562 */ 4563 4564 /* values for output state variable */ 4565 #define OSTATE_HEAD 0 /* at beginning of line */ 4566 #define OSTATE_CR 1 /* read a carriage return */ 4567 #define OSTATE_INLINE 2 /* putting rest of line */ 4568 4569 bool 4570 putbody(mci, e, separator) 4571 register MCI *mci; 4572 register ENVELOPE *e; 4573 char *separator; 4574 { 4575 bool dead = false; 4576 bool ioerr = false; 4577 int save_errno; 4578 char buf[MAXLINE]; 4579 #if MIME8TO7 4580 char *boundaries[MAXMIMENESTING + 1]; 4581 #endif /* MIME8TO7 */ 4582 4583 /* 4584 ** Output the body of the message 4585 */ 4586 4587 if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags)) 4588 { 4589 char *df = queuename(e, DATAFL_LETTER); 4590 4591 e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, df, 4592 SM_IO_RDONLY_B, NULL); 4593 if (e->e_dfp == NULL) 4594 { 4595 char *msg = "!putbody: Cannot open %s for %s from %s"; 4596 4597 if (errno == ENOENT) 4598 msg++; 4599 syserr(msg, df, e->e_to, e->e_from.q_paddr); 4600 } 4601 4602 } 4603 if (e->e_dfp == NULL) 4604 { 4605 if (bitset(MCIF_INHEADER, mci->mci_flags)) 4606 { 4607 if (!putline("", mci)) 4608 goto writeerr; 4609 mci->mci_flags &= ~MCIF_INHEADER; 4610 } 4611 if (!putline("<<< No Message Collected >>>", mci)) 4612 goto writeerr; 4613 goto endofmessage; 4614 } 4615 4616 if (e->e_dfino == (ino_t) 0) 4617 { 4618 struct stat stbuf; 4619 4620 if (fstat(sm_io_getinfo(e->e_dfp, SM_IO_WHAT_FD, NULL), &stbuf) 4621 < 0) 4622 e->e_dfino = -1; 4623 else 4624 { 4625 e->e_dfdev = stbuf.st_dev; 4626 e->e_dfino = stbuf.st_ino; 4627 } 4628 } 4629 4630 /* paranoia: the data file should always be in a rewound state */ 4631 (void) bfrewind(e->e_dfp); 4632 4633 /* simulate an I/O timeout when used as source */ 4634 if (tTd(84, 101)) 4635 sleep(319); 4636 4637 #if MIME8TO7 4638 if (bitset(MCIF_CVT8TO7, mci->mci_flags)) 4639 { 4640 /* 4641 ** Do 8 to 7 bit MIME conversion. 4642 */ 4643 4644 /* make sure it looks like a MIME message */ 4645 if (hvalue("MIME-Version", e->e_header) == NULL && 4646 !putline("MIME-Version: 1.0", mci)) 4647 goto writeerr; 4648 4649 if (hvalue("Content-Type", e->e_header) == NULL) 4650 { 4651 (void) sm_snprintf(buf, sizeof(buf), 4652 "Content-Type: text/plain; charset=%s", 4653 defcharset(e)); 4654 if (!putline(buf, mci)) 4655 goto writeerr; 4656 } 4657 4658 /* now do the hard work */ 4659 boundaries[0] = NULL; 4660 mci->mci_flags |= MCIF_INHEADER; 4661 if (mime8to7(mci, e->e_header, e, boundaries, M87F_OUTER, 0) == 4662 SM_IO_EOF) 4663 goto writeerr; 4664 } 4665 # if MIME7TO8 4666 else if (bitset(MCIF_CVT7TO8, mci->mci_flags)) 4667 { 4668 if (!mime7to8(mci, e->e_header, e)) 4669 goto writeerr; 4670 } 4671 # endif /* MIME7TO8 */ 4672 else if (MaxMimeHeaderLength > 0 || MaxMimeFieldLength > 0) 4673 { 4674 bool oldsuprerrs = SuprErrs; 4675 4676 /* Use mime8to7 to check multipart for MIME header overflows */ 4677 boundaries[0] = NULL; 4678 mci->mci_flags |= MCIF_INHEADER; 4679 4680 /* 4681 ** If EF_DONT_MIME is set, we have a broken MIME message 4682 ** and don't want to generate a new bounce message whose 4683 ** body propagates the broken MIME. We can't just not call 4684 ** mime8to7() as is done above since we need the security 4685 ** checks. The best we can do is suppress the errors. 4686 */ 4687 4688 if (bitset(EF_DONT_MIME, e->e_flags)) 4689 SuprErrs = true; 4690 4691 if (mime8to7(mci, e->e_header, e, boundaries, 4692 M87F_OUTER|M87F_NO8TO7, 0) == SM_IO_EOF) 4693 goto writeerr; 4694 4695 /* restore SuprErrs */ 4696 SuprErrs = oldsuprerrs; 4697 } 4698 else 4699 #endif /* MIME8TO7 */ 4700 { 4701 int ostate; 4702 register char *bp; 4703 register char *pbp; 4704 register int c; 4705 register char *xp; 4706 int padc; 4707 char *buflim; 4708 int pos = 0; 4709 char peekbuf[12]; 4710 4711 if (bitset(MCIF_INHEADER, mci->mci_flags)) 4712 { 4713 if (!putline("", mci)) 4714 goto writeerr; 4715 mci->mci_flags &= ~MCIF_INHEADER; 4716 } 4717 4718 /* determine end of buffer; allow for short mailer lines */ 4719 buflim = &buf[sizeof(buf) - 1]; 4720 if (mci->mci_mailer->m_linelimit > 0 && 4721 mci->mci_mailer->m_linelimit < sizeof(buf) - 1) 4722 buflim = &buf[mci->mci_mailer->m_linelimit - 1]; 4723 4724 /* copy temp file to output with mapping */ 4725 ostate = OSTATE_HEAD; 4726 bp = buf; 4727 pbp = peekbuf; 4728 while (!sm_io_error(mci->mci_out) && !dead) 4729 { 4730 if (pbp > peekbuf) 4731 c = *--pbp; 4732 else if ((c = sm_io_getc(e->e_dfp, SM_TIME_DEFAULT)) 4733 == SM_IO_EOF) 4734 break; 4735 if (bitset(MCIF_7BIT, mci->mci_flags)) 4736 c &= 0x7f; 4737 switch (ostate) 4738 { 4739 case OSTATE_HEAD: 4740 if (c == '\0' && 4741 bitnset(M_NONULLS, 4742 mci->mci_mailer->m_flags)) 4743 break; 4744 if (c != '\r' && c != '\n' && bp < buflim) 4745 { 4746 *bp++ = c; 4747 break; 4748 } 4749 4750 /* check beginning of line for special cases */ 4751 *bp = '\0'; 4752 pos = 0; 4753 padc = SM_IO_EOF; 4754 if (buf[0] == 'F' && 4755 bitnset(M_ESCFROM, mci->mci_mailer->m_flags) 4756 && strncmp(buf, "From ", 5) == 0) 4757 { 4758 padc = '>'; 4759 } 4760 if (buf[0] == '-' && buf[1] == '-' && 4761 separator != NULL) 4762 { 4763 /* possible separator */ 4764 int sl = strlen(separator); 4765 4766 if (strncmp(&buf[2], separator, sl) 4767 == 0) 4768 padc = ' '; 4769 } 4770 if (buf[0] == '.' && 4771 bitnset(M_XDOT, mci->mci_mailer->m_flags)) 4772 { 4773 padc = '.'; 4774 } 4775 4776 /* now copy out saved line */ 4777 if (TrafficLogFile != NULL) 4778 { 4779 (void) sm_io_fprintf(TrafficLogFile, 4780 SM_TIME_DEFAULT, 4781 "%05d >>> ", 4782 (int) CurrentPid); 4783 if (padc != SM_IO_EOF) 4784 (void) sm_io_putc(TrafficLogFile, 4785 SM_TIME_DEFAULT, 4786 padc); 4787 for (xp = buf; xp < bp; xp++) 4788 (void) sm_io_putc(TrafficLogFile, 4789 SM_TIME_DEFAULT, 4790 (unsigned char) *xp); 4791 if (c == '\n') 4792 (void) sm_io_fputs(TrafficLogFile, 4793 SM_TIME_DEFAULT, 4794 mci->mci_mailer->m_eol); 4795 } 4796 if (padc != SM_IO_EOF) 4797 { 4798 if (sm_io_putc(mci->mci_out, 4799 SM_TIME_DEFAULT, padc) 4800 == SM_IO_EOF) 4801 { 4802 dead = true; 4803 continue; 4804 } 4805 pos++; 4806 } 4807 for (xp = buf; xp < bp; xp++) 4808 { 4809 if (sm_io_putc(mci->mci_out, 4810 SM_TIME_DEFAULT, 4811 (unsigned char) *xp) 4812 == SM_IO_EOF) 4813 { 4814 dead = true; 4815 break; 4816 } 4817 } 4818 if (dead) 4819 continue; 4820 if (c == '\n') 4821 { 4822 if (sm_io_fputs(mci->mci_out, 4823 SM_TIME_DEFAULT, 4824 mci->mci_mailer->m_eol) 4825 == SM_IO_EOF) 4826 break; 4827 pos = 0; 4828 } 4829 else 4830 { 4831 pos += bp - buf; 4832 if (c != '\r') 4833 { 4834 SM_ASSERT(pbp < peekbuf + 4835 sizeof(peekbuf)); 4836 *pbp++ = c; 4837 } 4838 } 4839 4840 bp = buf; 4841 4842 /* determine next state */ 4843 if (c == '\n') 4844 ostate = OSTATE_HEAD; 4845 else if (c == '\r') 4846 ostate = OSTATE_CR; 4847 else 4848 ostate = OSTATE_INLINE; 4849 continue; 4850 4851 case OSTATE_CR: 4852 if (c == '\n') 4853 { 4854 /* got CRLF */ 4855 if (sm_io_fputs(mci->mci_out, 4856 SM_TIME_DEFAULT, 4857 mci->mci_mailer->m_eol) 4858 == SM_IO_EOF) 4859 continue; 4860 4861 if (TrafficLogFile != NULL) 4862 { 4863 (void) sm_io_fputs(TrafficLogFile, 4864 SM_TIME_DEFAULT, 4865 mci->mci_mailer->m_eol); 4866 } 4867 pos = 0; 4868 ostate = OSTATE_HEAD; 4869 continue; 4870 } 4871 4872 /* had a naked carriage return */ 4873 SM_ASSERT(pbp < peekbuf + sizeof(peekbuf)); 4874 *pbp++ = c; 4875 c = '\r'; 4876 ostate = OSTATE_INLINE; 4877 goto putch; 4878 4879 case OSTATE_INLINE: 4880 if (c == '\r') 4881 { 4882 ostate = OSTATE_CR; 4883 continue; 4884 } 4885 if (c == '\0' && 4886 bitnset(M_NONULLS, 4887 mci->mci_mailer->m_flags)) 4888 break; 4889 putch: 4890 if (mci->mci_mailer->m_linelimit > 0 && 4891 pos >= mci->mci_mailer->m_linelimit - 1 && 4892 c != '\n') 4893 { 4894 int d; 4895 4896 /* check next character for EOL */ 4897 if (pbp > peekbuf) 4898 d = *(pbp - 1); 4899 else if ((d = sm_io_getc(e->e_dfp, 4900 SM_TIME_DEFAULT)) 4901 != SM_IO_EOF) 4902 { 4903 SM_ASSERT(pbp < peekbuf + 4904 sizeof(peekbuf)); 4905 *pbp++ = d; 4906 } 4907 4908 if (d == '\n' || d == SM_IO_EOF) 4909 { 4910 if (TrafficLogFile != NULL) 4911 (void) sm_io_putc(TrafficLogFile, 4912 SM_TIME_DEFAULT, 4913 (unsigned char) c); 4914 if (sm_io_putc(mci->mci_out, 4915 SM_TIME_DEFAULT, 4916 (unsigned char) c) 4917 == SM_IO_EOF) 4918 { 4919 dead = true; 4920 continue; 4921 } 4922 pos++; 4923 continue; 4924 } 4925 4926 if (sm_io_putc(mci->mci_out, 4927 SM_TIME_DEFAULT, '!') 4928 == SM_IO_EOF || 4929 sm_io_fputs(mci->mci_out, 4930 SM_TIME_DEFAULT, 4931 mci->mci_mailer->m_eol) 4932 == SM_IO_EOF) 4933 { 4934 dead = true; 4935 continue; 4936 } 4937 4938 if (TrafficLogFile != NULL) 4939 { 4940 (void) sm_io_fprintf(TrafficLogFile, 4941 SM_TIME_DEFAULT, 4942 "!%s", 4943 mci->mci_mailer->m_eol); 4944 } 4945 ostate = OSTATE_HEAD; 4946 SM_ASSERT(pbp < peekbuf + 4947 sizeof(peekbuf)); 4948 *pbp++ = c; 4949 continue; 4950 } 4951 if (c == '\n') 4952 { 4953 if (TrafficLogFile != NULL) 4954 (void) sm_io_fputs(TrafficLogFile, 4955 SM_TIME_DEFAULT, 4956 mci->mci_mailer->m_eol); 4957 if (sm_io_fputs(mci->mci_out, 4958 SM_TIME_DEFAULT, 4959 mci->mci_mailer->m_eol) 4960 == SM_IO_EOF) 4961 continue; 4962 pos = 0; 4963 ostate = OSTATE_HEAD; 4964 } 4965 else 4966 { 4967 if (TrafficLogFile != NULL) 4968 (void) sm_io_putc(TrafficLogFile, 4969 SM_TIME_DEFAULT, 4970 (unsigned char) c); 4971 if (sm_io_putc(mci->mci_out, 4972 SM_TIME_DEFAULT, 4973 (unsigned char) c) 4974 == SM_IO_EOF) 4975 { 4976 dead = true; 4977 continue; 4978 } 4979 pos++; 4980 ostate = OSTATE_INLINE; 4981 } 4982 break; 4983 } 4984 } 4985 4986 /* make sure we are at the beginning of a line */ 4987 if (bp > buf) 4988 { 4989 if (TrafficLogFile != NULL) 4990 { 4991 for (xp = buf; xp < bp; xp++) 4992 (void) sm_io_putc(TrafficLogFile, 4993 SM_TIME_DEFAULT, 4994 (unsigned char) *xp); 4995 } 4996 for (xp = buf; xp < bp; xp++) 4997 { 4998 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, 4999 (unsigned char) *xp) 5000 == SM_IO_EOF) 5001 { 5002 dead = true; 5003 break; 5004 } 5005 } 5006 pos += bp - buf; 5007 } 5008 if (!dead && pos > 0) 5009 { 5010 if (TrafficLogFile != NULL) 5011 (void) sm_io_fputs(TrafficLogFile, 5012 SM_TIME_DEFAULT, 5013 mci->mci_mailer->m_eol); 5014 if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT, 5015 mci->mci_mailer->m_eol) == SM_IO_EOF) 5016 goto writeerr; 5017 } 5018 } 5019 5020 if (sm_io_error(e->e_dfp)) 5021 { 5022 syserr("putbody: %s/%cf%s: read error", 5023 qid_printqueue(e->e_dfqgrp, e->e_dfqdir), 5024 DATAFL_LETTER, e->e_id); 5025 ExitStat = EX_IOERR; 5026 ioerr = true; 5027 } 5028 5029 endofmessage: 5030 /* 5031 ** Since mailfile() uses e_dfp in a child process, 5032 ** the file offset in the stdio library for the 5033 ** parent process will not agree with the in-kernel 5034 ** file offset since the file descriptor is shared 5035 ** between the processes. Therefore, it is vital 5036 ** that the file always be rewound. This forces the 5037 ** kernel offset (lseek) and stdio library (ftell) 5038 ** offset to match. 5039 */ 5040 5041 save_errno = errno; 5042 if (e->e_dfp != NULL) 5043 (void) bfrewind(e->e_dfp); 5044 5045 /* some mailers want extra blank line at end of message */ 5046 if (!dead && bitnset(M_BLANKEND, mci->mci_mailer->m_flags) && 5047 buf[0] != '\0' && buf[0] != '\n') 5048 { 5049 if (!putline("", mci)) 5050 goto writeerr; 5051 } 5052 5053 if (!dead && 5054 (sm_io_flush(mci->mci_out, SM_TIME_DEFAULT) == SM_IO_EOF || 5055 (sm_io_error(mci->mci_out) && errno != EPIPE))) 5056 { 5057 save_errno = errno; 5058 syserr("putbody: write error"); 5059 ExitStat = EX_IOERR; 5060 ioerr = true; 5061 } 5062 5063 errno = save_errno; 5064 return !dead && !ioerr; 5065 5066 writeerr: 5067 return false; 5068 } 5069 5070 /* 5071 ** MAILFILE -- Send a message to a file. 5072 ** 5073 ** If the file has the set-user-ID/set-group-ID bits set, but NO 5074 ** execute bits, sendmail will try to become the owner of that file 5075 ** rather than the real user. Obviously, this only works if 5076 ** sendmail runs as root. 5077 ** 5078 ** This could be done as a subordinate mailer, except that it 5079 ** is used implicitly to save messages in ~/dead.letter. We 5080 ** view this as being sufficiently important as to include it 5081 ** here. For example, if the system is dying, we shouldn't have 5082 ** to create another process plus some pipes to save the message. 5083 ** 5084 ** Parameters: 5085 ** filename -- the name of the file to send to. 5086 ** mailer -- mailer definition for recipient -- if NULL, 5087 ** use FileMailer. 5088 ** ctladdr -- the controlling address header -- includes 5089 ** the userid/groupid to be when sending. 5090 ** sfflags -- flags for opening. 5091 ** e -- the current envelope. 5092 ** 5093 ** Returns: 5094 ** The exit code associated with the operation. 5095 ** 5096 ** Side Effects: 5097 ** none. 5098 */ 5099 5100 # define RETURN(st) exit(st); 5101 5102 static jmp_buf CtxMailfileTimeout; 5103 5104 int 5105 mailfile(filename, mailer, ctladdr, sfflags, e) 5106 char *volatile filename; 5107 MAILER *volatile mailer; 5108 ADDRESS *ctladdr; 5109 volatile long sfflags; 5110 register ENVELOPE *e; 5111 { 5112 register SM_FILE_T *f; 5113 register pid_t pid = -1; 5114 volatile int mode; 5115 int len; 5116 off_t curoff; 5117 bool suidwarn = geteuid() == 0; 5118 char *p; 5119 char *volatile realfile; 5120 SM_EVENT *ev; 5121 char buf[MAXPATHLEN]; 5122 char targetfile[MAXPATHLEN]; 5123 5124 if (tTd(11, 1)) 5125 { 5126 sm_dprintf("mailfile %s\n ctladdr=", filename); 5127 printaddr(sm_debug_file(), ctladdr, false); 5128 } 5129 5130 if (mailer == NULL) 5131 mailer = FileMailer; 5132 5133 if (e->e_xfp != NULL) 5134 (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT); 5135 5136 /* 5137 ** Special case /dev/null. This allows us to restrict file 5138 ** delivery to regular files only. 5139 */ 5140 5141 if (sm_path_isdevnull(filename)) 5142 return EX_OK; 5143 5144 /* check for 8-bit available */ 5145 if (bitset(EF_HAS8BIT, e->e_flags) && 5146 bitnset(M_7BITS, mailer->m_flags) && 5147 (bitset(EF_DONT_MIME, e->e_flags) || 5148 !(bitset(MM_MIME8BIT, MimeMode) || 5149 (bitset(EF_IS_MIME, e->e_flags) && 5150 bitset(MM_CVTMIME, MimeMode))))) 5151 { 5152 e->e_status = "5.6.3"; 5153 usrerrenh(e->e_status, 5154 "554 Cannot send 8-bit data to 7-bit destination"); 5155 errno = 0; 5156 return EX_DATAERR; 5157 } 5158 5159 /* Find the actual file */ 5160 if (SafeFileEnv != NULL && SafeFileEnv[0] != '\0') 5161 { 5162 len = strlen(SafeFileEnv); 5163 5164 if (strncmp(SafeFileEnv, filename, len) == 0) 5165 filename += len; 5166 5167 if (len + strlen(filename) + 1 >= sizeof(targetfile)) 5168 { 5169 syserr("mailfile: filename too long (%s/%s)", 5170 SafeFileEnv, filename); 5171 return EX_CANTCREAT; 5172 } 5173 (void) sm_strlcpy(targetfile, SafeFileEnv, sizeof(targetfile)); 5174 realfile = targetfile + len; 5175 if (*filename == '/') 5176 filename++; 5177 if (*filename != '\0') 5178 { 5179 /* paranoia: trailing / should be removed in readcf */ 5180 if (targetfile[len - 1] != '/') 5181 (void) sm_strlcat(targetfile, 5182 "/", sizeof(targetfile)); 5183 (void) sm_strlcat(targetfile, filename, 5184 sizeof(targetfile)); 5185 } 5186 } 5187 else if (mailer->m_rootdir != NULL) 5188 { 5189 expand(mailer->m_rootdir, targetfile, sizeof(targetfile), e); 5190 len = strlen(targetfile); 5191 5192 if (strncmp(targetfile, filename, len) == 0) 5193 filename += len; 5194 5195 if (len + strlen(filename) + 1 >= sizeof(targetfile)) 5196 { 5197 syserr("mailfile: filename too long (%s/%s)", 5198 targetfile, filename); 5199 return EX_CANTCREAT; 5200 } 5201 realfile = targetfile + len; 5202 if (targetfile[len - 1] != '/') 5203 (void) sm_strlcat(targetfile, "/", sizeof(targetfile)); 5204 if (*filename == '/') 5205 (void) sm_strlcat(targetfile, filename + 1, 5206 sizeof(targetfile)); 5207 else 5208 (void) sm_strlcat(targetfile, filename, 5209 sizeof(targetfile)); 5210 } 5211 else 5212 { 5213 if (sm_strlcpy(targetfile, filename, sizeof(targetfile)) >= 5214 sizeof(targetfile)) 5215 { 5216 syserr("mailfile: filename too long (%s)", filename); 5217 return EX_CANTCREAT; 5218 } 5219 realfile = targetfile; 5220 } 5221 5222 /* 5223 ** Fork so we can change permissions here. 5224 ** Note that we MUST use fork, not vfork, because of 5225 ** the complications of calling subroutines, etc. 5226 */ 5227 5228 5229 /* 5230 ** Dispose of SIGCHLD signal catchers that may be laying 5231 ** around so that the waitfor() below will get it. 5232 */ 5233 5234 (void) sm_signal(SIGCHLD, SIG_DFL); 5235 5236 DOFORK(fork); 5237 5238 if (pid < 0) 5239 return EX_OSERR; 5240 else if (pid == 0) 5241 { 5242 /* child -- actually write to file */ 5243 struct stat stb; 5244 MCI mcibuf; 5245 int err; 5246 volatile int oflags = O_WRONLY|O_APPEND; 5247 5248 /* Reset global flags */ 5249 RestartRequest = NULL; 5250 RestartWorkGroup = false; 5251 ShutdownRequest = NULL; 5252 PendingSignal = 0; 5253 CurrentPid = getpid(); 5254 5255 if (e->e_lockfp != NULL) 5256 { 5257 int fd; 5258 5259 fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL); 5260 /* SM_ASSERT(fd >= 0); */ 5261 if (fd >= 0) 5262 (void) close(fd); 5263 } 5264 5265 (void) sm_signal(SIGINT, SIG_DFL); 5266 (void) sm_signal(SIGHUP, SIG_DFL); 5267 (void) sm_signal(SIGTERM, SIG_DFL); 5268 (void) umask(OldUmask); 5269 e->e_to = filename; 5270 ExitStat = EX_OK; 5271 5272 if (setjmp(CtxMailfileTimeout) != 0) 5273 { 5274 RETURN(EX_TEMPFAIL); 5275 } 5276 5277 if (TimeOuts.to_fileopen > 0) 5278 ev = sm_setevent(TimeOuts.to_fileopen, mailfiletimeout, 5279 0); 5280 else 5281 ev = NULL; 5282 5283 /* check file mode to see if set-user-ID */ 5284 if (stat(targetfile, &stb) < 0) 5285 mode = FileMode; 5286 else 5287 mode = stb.st_mode; 5288 5289 /* limit the errors to those actually caused in the child */ 5290 errno = 0; 5291 ExitStat = EX_OK; 5292 5293 /* Allow alias expansions to use the S_IS{U,G}ID bits */ 5294 if ((ctladdr != NULL && !bitset(QALIAS, ctladdr->q_flags)) || 5295 bitset(SFF_RUNASREALUID, sfflags)) 5296 { 5297 /* ignore set-user-ID and set-group-ID bits */ 5298 mode &= ~(S_ISGID|S_ISUID); 5299 if (tTd(11, 20)) 5300 sm_dprintf("mailfile: ignoring set-user-ID/set-group-ID bits\n"); 5301 } 5302 5303 /* we have to open the data file BEFORE setuid() */ 5304 if (e->e_dfp == NULL && bitset(EF_HAS_DF, e->e_flags)) 5305 { 5306 char *df = queuename(e, DATAFL_LETTER); 5307 5308 e->e_dfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, df, 5309 SM_IO_RDONLY_B, NULL); 5310 if (e->e_dfp == NULL) 5311 { 5312 syserr("mailfile: Cannot open %s for %s from %s", 5313 df, e->e_to, e->e_from.q_paddr); 5314 } 5315 } 5316 5317 /* select a new user to run as */ 5318 if (!bitset(SFF_RUNASREALUID, sfflags)) 5319 { 5320 if (bitnset(M_SPECIFIC_UID, mailer->m_flags)) 5321 { 5322 RealUserName = NULL; 5323 if (mailer->m_uid == NO_UID) 5324 RealUid = RunAsUid; 5325 else 5326 RealUid = mailer->m_uid; 5327 if (RunAsUid != 0 && RealUid != RunAsUid) 5328 { 5329 /* Only root can change the uid */ 5330 syserr("mailfile: insufficient privileges to change uid, RunAsUid=%d, RealUid=%d", 5331 (int) RunAsUid, (int) RealUid); 5332 RETURN(EX_TEMPFAIL); 5333 } 5334 } 5335 else if (bitset(S_ISUID, mode)) 5336 { 5337 RealUserName = NULL; 5338 RealUid = stb.st_uid; 5339 } 5340 else if (ctladdr != NULL && ctladdr->q_uid != 0) 5341 { 5342 if (ctladdr->q_ruser != NULL) 5343 RealUserName = ctladdr->q_ruser; 5344 else 5345 RealUserName = ctladdr->q_user; 5346 RealUid = ctladdr->q_uid; 5347 } 5348 else if (mailer != NULL && mailer->m_uid != NO_UID) 5349 { 5350 RealUserName = DefUser; 5351 RealUid = mailer->m_uid; 5352 } 5353 else 5354 { 5355 RealUserName = DefUser; 5356 RealUid = DefUid; 5357 } 5358 5359 /* select a new group to run as */ 5360 if (bitnset(M_SPECIFIC_UID, mailer->m_flags)) 5361 { 5362 if (mailer->m_gid == NO_GID) 5363 RealGid = RunAsGid; 5364 else 5365 RealGid = mailer->m_gid; 5366 if (RunAsUid != 0 && 5367 (RealGid != getgid() || 5368 RealGid != getegid())) 5369 { 5370 /* Only root can change the gid */ 5371 syserr("mailfile: insufficient privileges to change gid, RealGid=%d, RunAsUid=%d, gid=%d, egid=%d", 5372 (int) RealGid, (int) RunAsUid, 5373 (int) getgid(), (int) getegid()); 5374 RETURN(EX_TEMPFAIL); 5375 } 5376 } 5377 else if (bitset(S_ISGID, mode)) 5378 RealGid = stb.st_gid; 5379 else if (ctladdr != NULL && 5380 ctladdr->q_uid == DefUid && 5381 ctladdr->q_gid == 0) 5382 { 5383 /* 5384 ** Special case: This means it is an 5385 ** alias and we should act as DefaultUser. 5386 ** See alias()'s comments. 5387 */ 5388 5389 RealGid = DefGid; 5390 RealUserName = DefUser; 5391 } 5392 else if (ctladdr != NULL && ctladdr->q_uid != 0) 5393 RealGid = ctladdr->q_gid; 5394 else if (mailer != NULL && mailer->m_gid != NO_GID) 5395 RealGid = mailer->m_gid; 5396 else 5397 RealGid = DefGid; 5398 } 5399 5400 /* last ditch */ 5401 if (!bitset(SFF_ROOTOK, sfflags)) 5402 { 5403 if (RealUid == 0) 5404 RealUid = DefUid; 5405 if (RealGid == 0) 5406 RealGid = DefGid; 5407 } 5408 5409 /* set group id list (needs /etc/group access) */ 5410 if (RealUserName != NULL && !DontInitGroups) 5411 { 5412 if (initgroups(RealUserName, RealGid) == -1 && suidwarn) 5413 { 5414 syserr("mailfile: initgroups(%s, %d) failed", 5415 RealUserName, RealGid); 5416 RETURN(EX_TEMPFAIL); 5417 } 5418 } 5419 else 5420 { 5421 GIDSET_T gidset[1]; 5422 5423 gidset[0] = RealGid; 5424 if (setgroups(1, gidset) == -1 && suidwarn) 5425 { 5426 syserr("mailfile: setgroups() failed"); 5427 RETURN(EX_TEMPFAIL); 5428 } 5429 } 5430 5431 /* 5432 ** If you have a safe environment, go into it. 5433 */ 5434 5435 if (realfile != targetfile) 5436 { 5437 char save; 5438 5439 save = *realfile; 5440 *realfile = '\0'; 5441 if (tTd(11, 20)) 5442 sm_dprintf("mailfile: chroot %s\n", targetfile); 5443 if (chroot(targetfile) < 0) 5444 { 5445 syserr("mailfile: Cannot chroot(%s)", 5446 targetfile); 5447 RETURN(EX_CANTCREAT); 5448 } 5449 *realfile = save; 5450 } 5451 5452 if (tTd(11, 40)) 5453 sm_dprintf("mailfile: deliver to %s\n", realfile); 5454 5455 if (chdir("/") < 0) 5456 { 5457 syserr("mailfile: cannot chdir(/)"); 5458 RETURN(EX_CANTCREAT); 5459 } 5460 5461 /* now reset the group and user ids */ 5462 endpwent(); 5463 sm_mbdb_terminate(); 5464 if (setgid(RealGid) < 0 && suidwarn) 5465 { 5466 syserr("mailfile: setgid(%ld) failed", (long) RealGid); 5467 RETURN(EX_TEMPFAIL); 5468 } 5469 vendor_set_uid(RealUid); 5470 if (setuid(RealUid) < 0 && suidwarn) 5471 { 5472 syserr("mailfile: setuid(%ld) failed", (long) RealUid); 5473 RETURN(EX_TEMPFAIL); 5474 } 5475 5476 if (tTd(11, 2)) 5477 sm_dprintf("mailfile: running as r/euid=%d/%d, r/egid=%d/%d\n", 5478 (int) getuid(), (int) geteuid(), 5479 (int) getgid(), (int) getegid()); 5480 5481 5482 /* move into some "safe" directory */ 5483 if (mailer->m_execdir != NULL) 5484 { 5485 char *q; 5486 5487 for (p = mailer->m_execdir; p != NULL; p = q) 5488 { 5489 q = strchr(p, ':'); 5490 if (q != NULL) 5491 *q = '\0'; 5492 expand(p, buf, sizeof(buf), e); 5493 if (q != NULL) 5494 *q++ = ':'; 5495 if (tTd(11, 20)) 5496 sm_dprintf("mailfile: trydir %s\n", 5497 buf); 5498 if (buf[0] != '\0' && chdir(buf) >= 0) 5499 break; 5500 } 5501 } 5502 5503 /* 5504 ** Recheck the file after we have assumed the ID of the 5505 ** delivery user to make sure we can deliver to it as 5506 ** that user. This is necessary if sendmail is running 5507 ** as root and the file is on an NFS mount which treats 5508 ** root as nobody. 5509 */ 5510 5511 #if HASLSTAT 5512 if (bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail)) 5513 err = stat(realfile, &stb); 5514 else 5515 err = lstat(realfile, &stb); 5516 #else /* HASLSTAT */ 5517 err = stat(realfile, &stb); 5518 #endif /* HASLSTAT */ 5519 5520 if (err < 0) 5521 { 5522 stb.st_mode = ST_MODE_NOFILE; 5523 mode = FileMode; 5524 oflags |= O_CREAT|O_EXCL; 5525 } 5526 else if (bitset(S_IXUSR|S_IXGRP|S_IXOTH, mode) || 5527 (!bitnset(DBS_FILEDELIVERYTOHARDLINK, 5528 DontBlameSendmail) && 5529 stb.st_nlink != 1) || 5530 (realfile != targetfile && !S_ISREG(mode))) 5531 exit(EX_CANTCREAT); 5532 else 5533 mode = stb.st_mode; 5534 5535 if (!bitnset(DBS_FILEDELIVERYTOSYMLINK, DontBlameSendmail)) 5536 sfflags |= SFF_NOSLINK; 5537 if (!bitnset(DBS_FILEDELIVERYTOHARDLINK, DontBlameSendmail)) 5538 sfflags |= SFF_NOHLINK; 5539 sfflags &= ~SFF_OPENASROOT; 5540 f = safefopen(realfile, oflags, mode, sfflags); 5541 if (f == NULL) 5542 { 5543 if (transienterror(errno)) 5544 { 5545 usrerr("454 4.3.0 cannot open %s: %s", 5546 shortenstring(realfile, MAXSHORTSTR), 5547 sm_errstring(errno)); 5548 RETURN(EX_TEMPFAIL); 5549 } 5550 else 5551 { 5552 usrerr("554 5.3.0 cannot open %s: %s", 5553 shortenstring(realfile, MAXSHORTSTR), 5554 sm_errstring(errno)); 5555 RETURN(EX_CANTCREAT); 5556 } 5557 } 5558 if (filechanged(realfile, sm_io_getinfo(f, SM_IO_WHAT_FD, NULL), 5559 &stb)) 5560 { 5561 syserr("554 5.3.0 file changed after open"); 5562 RETURN(EX_CANTCREAT); 5563 } 5564 if (fstat(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL), &stb) < 0) 5565 { 5566 syserr("554 5.3.0 cannot fstat %s", 5567 sm_errstring(errno)); 5568 RETURN(EX_CANTCREAT); 5569 } 5570 5571 curoff = stb.st_size; 5572 5573 if (ev != NULL) 5574 sm_clrevent(ev); 5575 5576 memset(&mcibuf, '\0', sizeof(mcibuf)); 5577 mcibuf.mci_mailer = mailer; 5578 mcibuf.mci_out = f; 5579 if (bitnset(M_7BITS, mailer->m_flags)) 5580 mcibuf.mci_flags |= MCIF_7BIT; 5581 5582 /* clear out per-message flags from connection structure */ 5583 mcibuf.mci_flags &= ~(MCIF_CVT7TO8|MCIF_CVT8TO7); 5584 5585 if (bitset(EF_HAS8BIT, e->e_flags) && 5586 !bitset(EF_DONT_MIME, e->e_flags) && 5587 bitnset(M_7BITS, mailer->m_flags)) 5588 mcibuf.mci_flags |= MCIF_CVT8TO7; 5589 5590 #if MIME7TO8 5591 if (bitnset(M_MAKE8BIT, mailer->m_flags) && 5592 !bitset(MCIF_7BIT, mcibuf.mci_flags) && 5593 (p = hvalue("Content-Transfer-Encoding", e->e_header)) != NULL && 5594 (sm_strcasecmp(p, "quoted-printable") == 0 || 5595 sm_strcasecmp(p, "base64") == 0) && 5596 (p = hvalue("Content-Type", e->e_header)) != NULL) 5597 { 5598 /* may want to convert 7 -> 8 */ 5599 /* XXX should really parse it here -- and use a class XXX */ 5600 if (sm_strncasecmp(p, "text/plain", 10) == 0 && 5601 (p[10] == '\0' || p[10] == ' ' || p[10] == ';')) 5602 mcibuf.mci_flags |= MCIF_CVT7TO8; 5603 } 5604 #endif /* MIME7TO8 */ 5605 5606 if (!putfromline(&mcibuf, e) || 5607 !(*e->e_puthdr)(&mcibuf, e->e_header, e, M87F_OUTER) || 5608 !(*e->e_putbody)(&mcibuf, e, NULL) || 5609 !putline("\n", &mcibuf) || 5610 (sm_io_flush(f, SM_TIME_DEFAULT) != 0 || 5611 (SuperSafe != SAFE_NO && 5612 fsync(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL)) < 0) || 5613 sm_io_error(f))) 5614 { 5615 setstat(EX_IOERR); 5616 #if !NOFTRUNCATE 5617 (void) ftruncate(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL), 5618 curoff); 5619 #endif /* !NOFTRUNCATE */ 5620 } 5621 5622 /* reset ISUID & ISGID bits for paranoid systems */ 5623 #if HASFCHMOD 5624 (void) fchmod(sm_io_getinfo(f, SM_IO_WHAT_FD, NULL), 5625 (MODE_T) mode); 5626 #else /* HASFCHMOD */ 5627 (void) chmod(filename, (MODE_T) mode); 5628 #endif /* HASFCHMOD */ 5629 if (sm_io_close(f, SM_TIME_DEFAULT) < 0) 5630 setstat(EX_IOERR); 5631 (void) sm_io_flush(smioout, SM_TIME_DEFAULT); 5632 (void) setuid(RealUid); 5633 exit(ExitStat); 5634 /* NOTREACHED */ 5635 } 5636 else 5637 { 5638 /* parent -- wait for exit status */ 5639 int st; 5640 5641 st = waitfor(pid); 5642 if (st == -1) 5643 { 5644 syserr("mailfile: %s: wait", mailer->m_name); 5645 return EX_SOFTWARE; 5646 } 5647 if (WIFEXITED(st)) 5648 { 5649 errno = 0; 5650 return (WEXITSTATUS(st)); 5651 } 5652 else 5653 { 5654 syserr("mailfile: %s: child died on signal %d", 5655 mailer->m_name, st); 5656 return EX_UNAVAILABLE; 5657 } 5658 /* NOTREACHED */ 5659 } 5660 return EX_UNAVAILABLE; /* avoid compiler warning on IRIX */ 5661 } 5662 5663 static void 5664 mailfiletimeout(ignore) 5665 int ignore; 5666 { 5667 /* 5668 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD 5669 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE 5670 ** DOING. 5671 */ 5672 5673 errno = ETIMEDOUT; 5674 longjmp(CtxMailfileTimeout, 1); 5675 } 5676 /* 5677 ** HOSTSIGNATURE -- return the "signature" for a host. 5678 ** 5679 ** The signature describes how we are going to send this -- it 5680 ** can be just the hostname (for non-Internet hosts) or can be 5681 ** an ordered list of MX hosts. 5682 ** 5683 ** Parameters: 5684 ** m -- the mailer describing this host. 5685 ** host -- the host name. 5686 ** 5687 ** Returns: 5688 ** The signature for this host. 5689 ** 5690 ** Side Effects: 5691 ** Can tweak the symbol table. 5692 */ 5693 5694 #define MAXHOSTSIGNATURE 8192 /* max len of hostsignature */ 5695 5696 char * 5697 hostsignature(m, host) 5698 register MAILER *m; 5699 char *host; 5700 { 5701 register char *p; 5702 register STAB *s; 5703 time_t now; 5704 #if NAMED_BIND 5705 char sep = ':'; 5706 char prevsep = ':'; 5707 int i; 5708 int len; 5709 int nmx; 5710 int hl; 5711 char *hp; 5712 char *endp; 5713 int oldoptions = _res.options; 5714 char *mxhosts[MAXMXHOSTS + 1]; 5715 unsigned short mxprefs[MAXMXHOSTS + 1]; 5716 #endif /* NAMED_BIND */ 5717 5718 if (tTd(17, 3)) 5719 sm_dprintf("hostsignature(%s)\n", host); 5720 5721 /* 5722 ** If local delivery (and not remote), just return a constant. 5723 */ 5724 5725 if (bitnset(M_LOCALMAILER, m->m_flags) && 5726 strcmp(m->m_mailer, "[IPC]") != 0 && 5727 !(m->m_argv[0] != NULL && strcmp(m->m_argv[0], "TCP") == 0)) 5728 return "localhost"; 5729 5730 /* an empty host does not have MX records */ 5731 if (*host == '\0') 5732 return "_empty_"; 5733 5734 /* 5735 ** Check to see if this uses IPC -- if not, it can't have MX records. 5736 */ 5737 5738 if (strcmp(m->m_mailer, "[IPC]") != 0 || 5739 CurEnv->e_sendmode == SM_DEFER) 5740 { 5741 /* just an ordinary mailer or deferred mode */ 5742 return host; 5743 } 5744 #if NETUNIX 5745 else if (m->m_argv[0] != NULL && 5746 strcmp(m->m_argv[0], "FILE") == 0) 5747 { 5748 /* rendezvous in the file system, no MX records */ 5749 return host; 5750 } 5751 #endif /* NETUNIX */ 5752 5753 /* 5754 ** Look it up in the symbol table. 5755 */ 5756 5757 now = curtime(); 5758 s = stab(host, ST_HOSTSIG, ST_ENTER); 5759 if (s->s_hostsig.hs_sig != NULL) 5760 { 5761 if (s->s_hostsig.hs_exp >= now) 5762 { 5763 if (tTd(17, 3)) 5764 sm_dprintf("hostsignature(): stab(%s) found %s\n", host, 5765 s->s_hostsig.hs_sig); 5766 return s->s_hostsig.hs_sig; 5767 } 5768 5769 /* signature is expired: clear it */ 5770 sm_free(s->s_hostsig.hs_sig); 5771 s->s_hostsig.hs_sig = NULL; 5772 } 5773 5774 /* set default TTL */ 5775 s->s_hostsig.hs_exp = now + SM_DEFAULT_TTL; 5776 5777 /* 5778 ** Not already there or expired -- create a signature. 5779 */ 5780 5781 #if NAMED_BIND 5782 if (ConfigLevel < 2) 5783 _res.options &= ~(RES_DEFNAMES | RES_DNSRCH); /* XXX */ 5784 5785 for (hp = host; hp != NULL; hp = endp) 5786 { 5787 #if NETINET6 5788 if (*hp == '[') 5789 { 5790 endp = strchr(hp + 1, ']'); 5791 if (endp != NULL) 5792 endp = strpbrk(endp + 1, ":,"); 5793 } 5794 else 5795 endp = strpbrk(hp, ":,"); 5796 #else /* NETINET6 */ 5797 endp = strpbrk(hp, ":,"); 5798 #endif /* NETINET6 */ 5799 if (endp != NULL) 5800 { 5801 sep = *endp; 5802 *endp = '\0'; 5803 } 5804 5805 if (bitnset(M_NOMX, m->m_flags)) 5806 { 5807 /* skip MX lookups */ 5808 nmx = 1; 5809 mxhosts[0] = hp; 5810 } 5811 else 5812 { 5813 auto int rcode; 5814 int ttl; 5815 5816 nmx = getmxrr(hp, mxhosts, mxprefs, true, &rcode, true, 5817 &ttl); 5818 if (nmx <= 0) 5819 { 5820 int save_errno; 5821 register MCI *mci; 5822 5823 /* update the connection info for this host */ 5824 save_errno = errno; 5825 mci = mci_get(hp, m); 5826 mci->mci_errno = save_errno; 5827 mci->mci_herrno = h_errno; 5828 mci->mci_lastuse = now; 5829 if (rcode == EX_NOHOST) 5830 mci_setstat(mci, rcode, "5.1.2", 5831 "550 Host unknown"); 5832 else 5833 mci_setstat(mci, rcode, NULL, NULL); 5834 5835 /* use the original host name as signature */ 5836 nmx = 1; 5837 mxhosts[0] = hp; 5838 } 5839 if (tTd(17, 3)) 5840 sm_dprintf("hostsignature(): getmxrr() returned %d, mxhosts[0]=%s\n", 5841 nmx, mxhosts[0]); 5842 5843 /* 5844 ** Set new TTL: we use only one! 5845 ** We could try to use the minimum instead. 5846 */ 5847 5848 s->s_hostsig.hs_exp = now + SM_MIN(ttl, SM_DEFAULT_TTL); 5849 } 5850 5851 len = 0; 5852 for (i = 0; i < nmx; i++) 5853 len += strlen(mxhosts[i]) + 1; 5854 if (s->s_hostsig.hs_sig != NULL) 5855 len += strlen(s->s_hostsig.hs_sig) + 1; 5856 if (len < 0 || len >= MAXHOSTSIGNATURE) 5857 { 5858 sm_syslog(LOG_WARNING, NOQID, "hostsignature for host '%s' exceeds maxlen (%d): %d", 5859 host, MAXHOSTSIGNATURE, len); 5860 len = MAXHOSTSIGNATURE; 5861 } 5862 p = sm_pmalloc_x(len); 5863 if (s->s_hostsig.hs_sig != NULL) 5864 { 5865 (void) sm_strlcpy(p, s->s_hostsig.hs_sig, len); 5866 sm_free(s->s_hostsig.hs_sig); /* XXX */ 5867 s->s_hostsig.hs_sig = p; 5868 hl = strlen(p); 5869 p += hl; 5870 *p++ = prevsep; 5871 len -= hl + 1; 5872 } 5873 else 5874 s->s_hostsig.hs_sig = p; 5875 for (i = 0; i < nmx; i++) 5876 { 5877 hl = strlen(mxhosts[i]); 5878 if (len - 1 < hl || len <= 1) 5879 { 5880 /* force to drop out of outer loop */ 5881 len = -1; 5882 break; 5883 } 5884 if (i != 0) 5885 { 5886 if (mxprefs[i] == mxprefs[i - 1]) 5887 *p++ = ','; 5888 else 5889 *p++ = ':'; 5890 len--; 5891 } 5892 (void) sm_strlcpy(p, mxhosts[i], len); 5893 p += hl; 5894 len -= hl; 5895 } 5896 5897 /* 5898 ** break out of loop if len exceeded MAXHOSTSIGNATURE 5899 ** because we won't have more space for further hosts 5900 ** anyway (separated by : in the .cf file). 5901 */ 5902 5903 if (len < 0) 5904 break; 5905 if (endp != NULL) 5906 *endp++ = sep; 5907 prevsep = sep; 5908 } 5909 makelower(s->s_hostsig.hs_sig); 5910 if (ConfigLevel < 2) 5911 _res.options = oldoptions; 5912 #else /* NAMED_BIND */ 5913 /* not using BIND -- the signature is just the host name */ 5914 /* 5915 ** 'host' points to storage that will be freed after we are 5916 ** done processing the current envelope, so we copy it. 5917 */ 5918 s->s_hostsig.hs_sig = sm_pstrdup_x(host); 5919 #endif /* NAMED_BIND */ 5920 if (tTd(17, 1)) 5921 sm_dprintf("hostsignature(%s) = %s\n", host, s->s_hostsig.hs_sig); 5922 return s->s_hostsig.hs_sig; 5923 } 5924 /* 5925 ** PARSE_HOSTSIGNATURE -- parse the "signature" and return MX host array. 5926 ** 5927 ** The signature describes how we are going to send this -- it 5928 ** can be just the hostname (for non-Internet hosts) or can be 5929 ** an ordered list of MX hosts which must be randomized for equal 5930 ** MX preference values. 5931 ** 5932 ** Parameters: 5933 ** sig -- the host signature. 5934 ** mxhosts -- array to populate. 5935 ** mailer -- mailer. 5936 ** 5937 ** Returns: 5938 ** The number of hosts inserted into mxhosts array. 5939 ** 5940 ** Side Effects: 5941 ** Randomizes equal MX preference hosts in mxhosts. 5942 */ 5943 5944 static int 5945 parse_hostsignature(sig, mxhosts, mailer) 5946 char *sig; 5947 char **mxhosts; 5948 MAILER *mailer; 5949 { 5950 unsigned short curpref = 0; 5951 int nmx = 0, i, j; /* NOTE: i, j, and nmx must have same type */ 5952 char *hp, *endp; 5953 unsigned short prefer[MAXMXHOSTS]; 5954 long rndm[MAXMXHOSTS]; 5955 5956 for (hp = sig; hp != NULL; hp = endp) 5957 { 5958 char sep = ':'; 5959 5960 #if NETINET6 5961 if (*hp == '[') 5962 { 5963 endp = strchr(hp + 1, ']'); 5964 if (endp != NULL) 5965 endp = strpbrk(endp + 1, ":,"); 5966 } 5967 else 5968 endp = strpbrk(hp, ":,"); 5969 #else /* NETINET6 */ 5970 endp = strpbrk(hp, ":,"); 5971 #endif /* NETINET6 */ 5972 if (endp != NULL) 5973 { 5974 sep = *endp; 5975 *endp = '\0'; 5976 } 5977 5978 mxhosts[nmx] = hp; 5979 prefer[nmx] = curpref; 5980 if (mci_match(hp, mailer)) 5981 rndm[nmx] = 0; 5982 else 5983 rndm[nmx] = get_random(); 5984 5985 if (endp != NULL) 5986 { 5987 /* 5988 ** Since we don't have the original MX prefs, 5989 ** make our own. If the separator is a ':', that 5990 ** means the preference for the next host will be 5991 ** higher than this one, so simply increment curpref. 5992 */ 5993 5994 if (sep == ':') 5995 curpref++; 5996 5997 *endp++ = sep; 5998 } 5999 if (++nmx >= MAXMXHOSTS) 6000 break; 6001 } 6002 6003 /* sort the records using the random factor for equal preferences */ 6004 for (i = 0; i < nmx; i++) 6005 { 6006 for (j = i + 1; j < nmx; j++) 6007 { 6008 /* 6009 ** List is already sorted by MX preference, only 6010 ** need to look for equal preference MX records 6011 */ 6012 6013 if (prefer[i] < prefer[j]) 6014 break; 6015 6016 if (prefer[i] > prefer[j] || 6017 (prefer[i] == prefer[j] && rndm[i] > rndm[j])) 6018 { 6019 register unsigned short tempp; 6020 register long tempr; 6021 register char *temp1; 6022 6023 tempp = prefer[i]; 6024 prefer[i] = prefer[j]; 6025 prefer[j] = tempp; 6026 temp1 = mxhosts[i]; 6027 mxhosts[i] = mxhosts[j]; 6028 mxhosts[j] = temp1; 6029 tempr = rndm[i]; 6030 rndm[i] = rndm[j]; 6031 rndm[j] = tempr; 6032 } 6033 } 6034 } 6035 return nmx; 6036 } 6037 6038 # if STARTTLS 6039 static SSL_CTX *clt_ctx = NULL; 6040 static bool tls_ok_clt = true; 6041 6042 /* 6043 ** SETCLTTLS -- client side TLS: allow/disallow. 6044 ** 6045 ** Parameters: 6046 ** tls_ok -- should tls be done? 6047 ** 6048 ** Returns: 6049 ** none. 6050 ** 6051 ** Side Effects: 6052 ** sets tls_ok_clt (static variable in this module) 6053 */ 6054 6055 void 6056 setclttls(tls_ok) 6057 bool tls_ok; 6058 { 6059 tls_ok_clt = tls_ok; 6060 return; 6061 } 6062 /* 6063 ** INITCLTTLS -- initialize client side TLS 6064 ** 6065 ** Parameters: 6066 ** tls_ok -- should tls initialization be done? 6067 ** 6068 ** Returns: 6069 ** succeeded? 6070 ** 6071 ** Side Effects: 6072 ** sets tls_ok_clt (static variable in this module) 6073 */ 6074 6075 bool 6076 initclttls(tls_ok) 6077 bool tls_ok; 6078 { 6079 if (!tls_ok_clt) 6080 return false; 6081 tls_ok_clt = tls_ok; 6082 if (!tls_ok_clt) 6083 return false; 6084 if (clt_ctx != NULL) 6085 return true; /* already done */ 6086 tls_ok_clt = inittls(&clt_ctx, TLS_I_CLT, Clt_SSL_Options, false, 6087 CltCertFile, CltKeyFile, 6088 CACertPath, CACertFile, DHParams); 6089 return tls_ok_clt; 6090 } 6091 6092 /* 6093 ** STARTTLS -- try to start secure connection (client side) 6094 ** 6095 ** Parameters: 6096 ** m -- the mailer. 6097 ** mci -- the mailer connection info. 6098 ** e -- the envelope. 6099 ** 6100 ** Returns: 6101 ** success? 6102 ** (maybe this should be some other code than EX_ 6103 ** that denotes which stage failed.) 6104 */ 6105 6106 static int 6107 starttls(m, mci, e) 6108 MAILER *m; 6109 MCI *mci; 6110 ENVELOPE *e; 6111 { 6112 int smtpresult; 6113 int result = 0; 6114 int rfd, wfd; 6115 SSL *clt_ssl = NULL; 6116 time_t tlsstart; 6117 6118 if (clt_ctx == NULL && !initclttls(true)) 6119 return EX_TEMPFAIL; 6120 6121 # if USE_OPENSSL_ENGINE 6122 if (!SSLEngineInitialized && !SSL_set_engine(NULL)) 6123 { 6124 sm_syslog(LOG_ERR, NOQID, 6125 "STARTTLS=client, SSL_set_engine=failed"); 6126 return EX_TEMPFAIL; 6127 } 6128 SSLEngineInitialized = true; 6129 # endif /* USE_OPENSSL_ENGINE */ 6130 6131 smtpmessage("STARTTLS", m, mci); 6132 6133 /* get the reply */ 6134 smtpresult = reply(m, mci, e, TimeOuts.to_starttls, NULL, NULL, 6135 XS_STARTTLS); 6136 6137 /* check return code from server */ 6138 if (REPLYTYPE(smtpresult) == 4) 6139 return EX_TEMPFAIL; 6140 if (smtpresult == 501) 6141 return EX_USAGE; 6142 if (smtpresult == -1) 6143 return smtpresult; 6144 6145 /* not an expected reply but we have to deal with it */ 6146 if (REPLYTYPE(smtpresult) == 5) 6147 return EX_UNAVAILABLE; 6148 if (smtpresult != 220) 6149 return EX_PROTOCOL; 6150 6151 if (LogLevel > 13) 6152 sm_syslog(LOG_INFO, NOQID, "STARTTLS=client, start=ok"); 6153 6154 /* start connection */ 6155 if ((clt_ssl = SSL_new(clt_ctx)) == NULL) 6156 { 6157 if (LogLevel > 5) 6158 { 6159 sm_syslog(LOG_ERR, NOQID, 6160 "STARTTLS=client, error: SSL_new failed"); 6161 if (LogLevel > 9) 6162 tlslogerr(LOG_WARNING, "client"); 6163 } 6164 return EX_SOFTWARE; 6165 } 6166 6167 rfd = sm_io_getinfo(mci->mci_in, SM_IO_WHAT_FD, NULL); 6168 wfd = sm_io_getinfo(mci->mci_out, SM_IO_WHAT_FD, NULL); 6169 6170 /* SSL_clear(clt_ssl); ? */ 6171 if (rfd < 0 || wfd < 0 || 6172 (result = SSL_set_rfd(clt_ssl, rfd)) != 1 || 6173 (result = SSL_set_wfd(clt_ssl, wfd)) != 1) 6174 { 6175 if (LogLevel > 5) 6176 { 6177 sm_syslog(LOG_ERR, NOQID, 6178 "STARTTLS=client, error: SSL_set_xfd failed=%d", 6179 result); 6180 if (LogLevel > 9) 6181 tlslogerr(LOG_WARNING, "client"); 6182 } 6183 return EX_SOFTWARE; 6184 } 6185 SSL_set_connect_state(clt_ssl); 6186 tlsstart = curtime(); 6187 6188 ssl_retry: 6189 if ((result = SSL_connect(clt_ssl)) <= 0) 6190 { 6191 int i, ssl_err; 6192 6193 ssl_err = SSL_get_error(clt_ssl, result); 6194 i = tls_retry(clt_ssl, rfd, wfd, tlsstart, 6195 TimeOuts.to_starttls, ssl_err, "client"); 6196 if (i > 0) 6197 goto ssl_retry; 6198 6199 if (LogLevel > 5) 6200 { 6201 unsigned long l; 6202 const char *sr; 6203 6204 l = ERR_peek_error(); 6205 sr = ERR_reason_error_string(l); 6206 sm_syslog(LOG_WARNING, NOQID, 6207 "STARTTLS=client, error: connect failed=%d, reason=%s, SSL_error=%d, errno=%d, retry=%d", 6208 result, sr == NULL ? "unknown" : sr, ssl_err, 6209 errno, i); 6210 if (LogLevel > 9) 6211 tlslogerr(LOG_WARNING, "client"); 6212 } 6213 6214 SSL_free(clt_ssl); 6215 clt_ssl = NULL; 6216 return EX_SOFTWARE; 6217 } 6218 mci->mci_ssl = clt_ssl; 6219 result = tls_get_info(mci->mci_ssl, false, mci->mci_host, 6220 &mci->mci_macro, true); 6221 6222 /* switch to use TLS... */ 6223 if (sfdctls(&mci->mci_in, &mci->mci_out, mci->mci_ssl) == 0) 6224 return EX_OK; 6225 6226 /* failure */ 6227 SSL_free(clt_ssl); 6228 clt_ssl = NULL; 6229 return EX_SOFTWARE; 6230 } 6231 /* 6232 ** ENDTLSCLT -- shutdown secure connection (client side) 6233 ** 6234 ** Parameters: 6235 ** mci -- the mailer connection info. 6236 ** 6237 ** Returns: 6238 ** success? 6239 */ 6240 6241 static int 6242 endtlsclt(mci) 6243 MCI *mci; 6244 { 6245 int r; 6246 6247 if (!bitset(MCIF_TLSACT, mci->mci_flags)) 6248 return EX_OK; 6249 r = endtls(mci->mci_ssl, "client"); 6250 mci->mci_flags &= ~MCIF_TLSACT; 6251 return r; 6252 } 6253 # endif /* STARTTLS */ 6254 # if STARTTLS || SASL 6255 /* 6256 ** ISCLTFLGSET -- check whether client flag is set. 6257 ** 6258 ** Parameters: 6259 ** e -- envelope. 6260 ** flag -- flag to check in {client_flags} 6261 ** 6262 ** Returns: 6263 ** true iff flag is set. 6264 */ 6265 6266 static bool 6267 iscltflgset(e, flag) 6268 ENVELOPE *e; 6269 int flag; 6270 { 6271 char *p; 6272 6273 p = macvalue(macid("{client_flags}"), e); 6274 if (p == NULL) 6275 return false; 6276 for (; *p != '\0'; p++) 6277 { 6278 /* look for just this one flag */ 6279 if (*p == (char) flag) 6280 return true; 6281 } 6282 return false; 6283 } 6284 # endif /* STARTTLS || SASL */ 6285