Pileus Git - ~andy/fetchmail/blob - sink.c

   1 /*
   2  * sink.c -- forwarding/delivery support for fetchmail
   3  *
   4  * The interface of this module (open_sink(), stuff_line(), close_sink(),
   5  * release_sink()) seals off the delivery logic from the protocol machine,
   6  * so the latter won't have to care whether it's shipping to an [SL]MTP
   7  * listener daemon or an MDA pipe.
   8  *
   9  * Copyright 1998 by Eric S. Raymond
  10  * For license terms, see the file COPYING in this directory.
  11  */
  12
  13 #include  "config.h"
  14 #include  <stdio.h>
  15 #include  <errno.h>
  16 #include  <string.h>
  17 #include  <signal.h>
  18 #ifdef HAVE_MEMORY_H
  19 #include  <memory.h>
  20 #endif /* HAVE_MEMORY_H */
  21 #if defined(STDC_HEADERS)
  22 #include  <stdlib.h>
  23 #endif
  24 #if defined(HAVE_UNISTD_H)
  25 #include  <unistd.h>
  26 #endif
  27 #if defined(HAVE_STDARG_H)
  28 #include  <stdarg.h>
  29 #else
  30 #include  <varargs.h>
  31 #endif
  32 #include  <ctype.h>
  33 #include  <langinfo.h>
  34
  35 #include  "fetchmail.h"
  36
  37 /* for W* macros after pclose() */
  38 #define _USE_BSD
  39 #include <sys/types.h>
  40 #include <sys/resource.h>
  41 #include <sys/wait.h>
  42
  43 #include  "socket.h"
  44 #include  "smtp.h"
  45 #include  "i18n.h"
  46
  47 /* BSD portability hack...I know, this is an ugly place to put it */
  48 #if !defined(SIGCHLD) && defined(SIGCLD)
  49 #define SIGCHLD SIGCLD
  50 #endif
  51
  52 /* makes the open_sink()/close_sink() pair non-reentrant */
  53 static int lmtp_responses;
  54
  55 void smtp_close(struct query *ctl, int sayquit)
  56 /* close the socket to SMTP server */
  57 {
  58     if (ctl->smtp_socket != -1)
  59     {
  60         if (sayquit)
  61             SMTP_quit(ctl->smtp_socket, ctl->smtphostmode);
  62         SockClose(ctl->smtp_socket);
  63         ctl->smtp_socket = -1;
  64     }
  65     batchcount = 0;
  66 }
  67
  68 int smtp_open(struct query *ctl)
  69 /* try to open a socket to the appropriate SMTP server for this query */
  70 {
  71     /* maybe it's time to close the socket in order to force delivery */
  72     if (last_smtp_ok > 0 && time((time_t *)NULL) - last_smtp_ok > mytimeout)
  73     {
  74         smtp_close(ctl, 1);
  75         last_smtp_ok = 0;
  76     }
  77     if (NUM_NONZERO(ctl->batchlimit)) {
  78         if (batchcount == ctl->batchlimit)
  79             smtp_close(ctl, 1);
  80         batchcount++;
  81     }
  82
  83     /* if no socket to any SMTP host is already set up, try to open one */
  84     if (ctl->smtp_socket == -1)
  85     {
  86         /*
  87          * RFC 1123 requires that the domain name in HELO address is a
  88          * "valid principal domain name" for the client host. If we're
  89          * running in invisible mode, violate this with malice
  90          * aforethought in order to make the Received headers and
  91          * logging look right.
  92          *
  93          * In fact this code relies on the RFC1123 requirement that the
  94          * SMTP listener must accept messages even if verification of the
  95          * HELO name fails (RFC1123 section 5.2.5, paragraph 2).
  96          *
  97          * How we compute the true mailhost name to pass to the
  98          * listener doesn't affect behavior on RFC1123-violating
  99          * listeners that check for name match; we're going to lose
 100          * on those anyway because we can never give them a name
 101          * that matches the local machine fetchmail is running on.
 102          * What it will affect is the listener's logging.
 103          */
 104         struct idlist   *idp;
 105         const char *id_me = run.invisible ? ctl->server.truename : fetchmailhost;
 106         int oldphase = phase;
 107         char *parsed_host = NULL;
 108
 109         errno = 0;
 110
 111         /*
 112          * Run down the SMTP hunt list looking for a server that's up.
 113          * Use both explicit hunt entries (value TRUE) and implicit
 114          * (default) ones (value FALSE).
 115          */
 116         oldphase = phase;
 117         phase = LISTENER_WAIT;
 118
 119         set_timeout(ctl->server.timeout);
 120         for (idp = ctl->smtphunt; idp; idp = idp->next)
 121         {
 122             char        *cp;
 123             char        *portnum = SMTP_PORT;
 124
 125             ctl->smtphost = idp->id;  /* remember last host tried. */
 126             if (ctl->smtphost[0]=='/')
 127             {
 128                 ctl->smtphostmode = LMTP_MODE;
 129                 xfree(parsed_host);
 130                 if ((ctl->smtp_socket = UnixOpen(ctl->smtphost))==-1)
 131                     continue;
 132             }
 133             else
 134             {
 135                 ctl->smtphostmode = ctl->listener;
 136                 parsed_host = xstrdup(idp->id);
 137                 if ((cp = strrchr(parsed_host, '/')))
 138                 {
 139                     *cp++ = 0;
 140                     if (cp[0])
 141                         portnum = cp;
 142                 }
 143                 if ((ctl->smtp_socket = SockOpen(parsed_host,portnum,
 144                                 ctl->server.plugout, &ai1)) == -1)
 145                 {
 146                     xfree(parsed_host);
 147                     continue;
 148                 }
 149             }
 150
 151             /* return immediately for ODMR */
 152             if (ctl->server.protocol == P_ODMR)
 153             {
 154                 set_timeout(0);
 155                 phase = oldphase;
 156                 xfree(parsed_host);
 157                 return(ctl->smtp_socket); /* success */
 158             }
 159
 160             /* first, probe for ESMTP */
 161             if (SMTP_ok(ctl->smtp_socket, ctl->smtphostmode) == SM_OK &&
 162                     SMTP_ehlo(ctl->smtp_socket, ctl->smtphostmode, id_me,
 163                         ctl->server.esmtp_name, ctl->server.esmtp_password,
 164                         &ctl->server.esmtp_options) == SM_OK)
 165                 break;  /* success */
 166
 167             /*
 168              * RFC 1869 warns that some listeners hang up on a failed EHLO,
 169              * so it's safest not to assume the socket will still be good.
 170              */
 171             smtp_close(ctl, 0);
 172
 173             /* if opening for ESMTP failed, try SMTP */
 174             if (ctl->smtphost[0]=='/')
 175             {
 176                 if ((ctl->smtp_socket = UnixOpen(ctl->smtphost))==-1)
 177                     continue;
 178             }
 179             else
 180             {
 181                 if ((ctl->smtp_socket = SockOpen(parsed_host,portnum,
 182                                 ctl->server.plugout, &ai1)) == -1)
 183                 {
 184                     xfree(parsed_host);
 185                     continue;
 186                 }
 187             }
 188
 189             if (SMTP_ok(ctl->smtp_socket, ctl->smtphostmode) == SM_OK &&
 190                     SMTP_helo(ctl->smtp_socket, ctl->smtphostmode, id_me) == SM_OK)
 191                 break;  /* success */
 192
 193             smtp_close(ctl, 0);
 194         }
 195         set_timeout(0);
 196         phase = oldphase;
 197
 198         /*
 199          * RFC 1123 requires that the domain name part of the
 200          * RCPT TO address be "canonicalized", that is a FQDN
 201          * or MX but not a CNAME.  Some listeners (like exim)
 202          * enforce this.  Now that we have the actual hostname,
 203          * compute what we should canonicalize with.
 204          */
 205         xfree(ctl->destaddr);
 206         if (ctl->smtpaddress)
 207             ctl->destaddr = xstrdup(ctl->smtpaddress);
 208         /* parsed_host is smtphost without the /port */
 209         else if (parsed_host && parsed_host[0] != 0)
 210             ctl->destaddr = xstrdup(parsed_host);
 211         /* No smtphost is specified or it is a UNIX socket, then use
 212            localhost as a domain part. */
 213         else
 214             ctl->destaddr = xstrdup("localhost");
 215         xfree(parsed_host);
 216     }
 217     /* end if (ctl->smtp_socket == -1) */
 218
 219     if (outlevel >= O_DEBUG && ctl->smtp_socket != -1)
 220         report(stdout, GT_("forwarding to %s\n"), ctl->smtphost);
 221
 222     return(ctl->smtp_socket);
 223 }
 224
 225 static void sanitize(char *s)
 226 /* replace ' by _ */
 227 {
 228     char *cp;
 229
 230     for (cp = s; (cp = strchr (cp, '\'')); cp++)
 231         *cp = '_';
 232 }
 233
 234 char *rcpt_address(struct query *ctl, const char *id,
 235                           int usesmtpname)
 236 {
 237     static char addr[HOSTLEN+USERNAMELEN+1];
 238     if (strchr(id, '@'))
 239     {
 240         snprintf(addr, sizeof (addr), "%s", id);
 241     }
 242     else if (usesmtpname && ctl->smtpname)
 243     {
 244         snprintf(addr, sizeof (addr), "%s", ctl->smtpname);
 245     }
 246     else
 247     {
 248         snprintf(addr, sizeof (addr), "%s@%s", id, ctl->destaddr);
 249     }
 250     return addr;
 251 }
 252
 253 static int send_bouncemail(struct query *ctl, struct msgblk *msg,
 254                            int userclass, char *message,
 255                            int nerrors, char *errors[])
 256 /* bounce back an error report a la RFC 1892 */
 257 {
 258     char daemon_name[15 + HOSTLEN] = "MAILER-DAEMON@";
 259     char boundary[BUFSIZ], *bounce_to;
 260     int sock;
 261     static char *fqdn_of_host = NULL;
 262     const char *md1 = "MAILER-DAEMON", *md2 = "MAILER-DAEMON@";
 263
 264     /* don't bounce in reply to undeliverable bounces */
 265     if (!msg->return_path[0] ||
 266         strcmp(msg->return_path, "<>") == 0 ||
 267         strcasecmp(msg->return_path, md1) == 0 ||
 268         strncasecmp(msg->return_path, md2, strlen(md2)) == 0)
 269         return(TRUE);
 270
 271     bounce_to = (run.bouncemail ? msg->return_path : run.postmaster);
 272
 273     /* can't just use fetchmailhost here, it might be localhost */
 274     if (fqdn_of_host == NULL)
 275         fqdn_of_host = host_fqdn(0); /* can't afford to bail out and
 276                                         lose the NDN here */
 277     strlcat(daemon_name, fqdn_of_host, sizeof(daemon_name));
 278
 279     /* we need only SMTP for this purpose */
 280     /* XXX FIXME: hardcoding localhost is nonsense if smtphost can be
 281      * configured */
 282     if ((sock = SockOpen("localhost", SMTP_PORT, NULL, &ai1)) == -1)
 283         return(FALSE);
 284
 285     if (SMTP_ok(sock, SMTP_MODE) != SM_OK)
 286     {
 287         SockClose(sock);
 288         return FALSE;
 289     }
 290
 291     if (SMTP_helo(sock, SMTP_MODE, fetchmailhost) != SM_OK
 292         || SMTP_from(sock, SMTP_MODE, "<>", (char *)NULL) != SM_OK
 293         || SMTP_rcpt(sock, SMTP_MODE, bounce_to) != SM_OK
 294         || SMTP_data(sock, SMTP_MODE) != SM_OK)
 295     {
 296         SMTP_quit(sock, SMTP_MODE);
 297         SockClose(sock);
 298         return(FALSE);
 299     }
 300
 301     /* our first duty is to keep the sacred foo counters turning... */
 302     snprintf(boundary, sizeof(boundary), "foo-mani-padme-hum-%ld-%ld-%ld",
 303             (long)getpid(), (long)getppid(), (long)time(NULL));
 304
 305     if (outlevel >= O_VERBOSE)
 306         report(stdout, GT_("SMTP: (bounce-message body)\n"));
 307     else
 308         /* this will usually go to sylog... */
 309         report(stderr, GT_("mail from %s bounced to %s\n"),
 310                daemon_name, bounce_to);
 311
 312
 313     /* bouncemail headers */
 314     SockPrintf(sock, "Subject: Mail delivery failed: returning message to sender\r\n");
 315     SockPrintf(sock, "From: Mail Delivery System <%s>\r\n", daemon_name);
 316     SockPrintf(sock, "To: %s\r\n", bounce_to);
 317     SockPrintf(sock, "MIME-Version: 1.0\r\n");
 318     SockPrintf(sock, "Content-Type: multipart/report; report-type=delivery-status;\r\n\tboundary=\"%s\"\r\n", boundary);
 319     SockPrintf(sock, "\r\n");
 320
 321     /* RFC1892 part 1 -- human-readable message */
 322     SockPrintf(sock, "--%s\r\n", boundary);
 323     SockPrintf(sock,"Content-Type: text/plain\r\n");
 324     SockPrintf(sock, "\r\n");
 325     SockPrintf(sock, "This message was created automatically by mail delivery software.\r\n\r\n");
 326     SockPrintf(sock, "A message that you sent could not be delivered to one or more of its\r\n");
 327     SockPrintf(sock, "recipients. This is a permanent error. The following address(es) failed:\r\n");
 328     SockPrintf(sock, "\r\n");
 329
 330     if (nerrors)
 331     {
 332         struct idlist   *idp;
 333         int             nusers;
 334
 335         nusers = 0;
 336         for (idp = msg->recipients; idp; idp = idp->next)
 337         {
 338             if (idp->val.status.mark == userclass)
 339             {
 340                 char    *error;
 341                 SockPrintf(sock, "%s\r\n", rcpt_address (ctl, idp->id, 1));
 342
 343                 if (nerrors == 1) error = errors[0];
 344                 else if (nerrors <= nusers)
 345                 {
 346                     SockPrintf(sock, "Internal error: SMTP error count doesn't match number of recipients.\r\n");
 347                     break;
 348                 }
 349                 else error = errors[nusers++];
 350
 351                 SockPrintf(sock, "   SMTP error: %s\r\n\r\n", error);
 352             }
 353         }
 354
 355         /* RFC1892 part 2 -- machine-readable responses */
 356         SockPrintf(sock, "--%s\r\n", boundary);
 357         SockPrintf(sock,"Content-Type: message/delivery-status\r\n");
 358         SockPrintf(sock, "\r\n");
 359         SockPrintf(sock, "Reporting-MTA: dns; %s\r\n", fqdn_of_host);
 360
 361         nusers = 0;
 362         for (idp = msg->recipients; idp; idp = idp->next)
 363             if (idp->val.status.mark == userclass)
 364             {
 365                 char    *error;
 366                 /* Minimum RFC1894 compliance + Diagnostic-Code field */
 367                 SockPrintf(sock, "\r\n");
 368                 SockPrintf(sock, "Final-Recipient: rfc822; %s\r\n",
 369                            rcpt_address (ctl, idp->id, 1));
 370                 SockPrintf(sock, "Last-Attempt-Date: %s\r\n", rfc822timestamp());
 371                 SockPrintf(sock, "Action: failed\r\n");
 372
 373                 if (nerrors == 1)
 374                     /* one error applies to all users */
 375                     error = errors[0];
 376                 else if (nerrors <= nusers)
 377                 {
 378                     SockPrintf(sock, "Internal error: SMTP error count doesn't match number of recipients.\r\n");
 379                     break;
 380                 }
 381                 else
 382                     /* errors correspond 1-1 to selected users */
 383                     error = errors[nusers++];
 384
 385                 if (strlen(error) > 9 && isdigit((unsigned char)error[4])
 386                         && error[5] == '.' && isdigit((unsigned char)error[6])
 387                         && error[7] == '.' && isdigit((unsigned char)error[8]))
 388                     /* Enhanced status code available, use it */
 389                     SockPrintf(sock, "Status: %5.5s\r\n", &(error[4]));
 390                 else
 391                     /* Enhanced status code not available, fake one */
 392                     SockPrintf(sock, "Status: %c.0.0\r\n", error[0]);
 393                 SockPrintf(sock, "Diagnostic-Code: %s\r\n", error);
 394             }
 395         SockPrintf(sock, "\r\n");
 396     }
 397
 398     /* RFC1892 part 3 -- headers of undelivered message */
 399     SockPrintf(sock, "--%s\r\n", boundary);
 400     SockPrintf(sock, "Content-Type: text/rfc822-headers\r\n");
 401     SockPrintf(sock, "\r\n");
 402     if (msg->headers)
 403     {
 404         SockWrite(sock, msg->headers, strlen(msg->headers));
 405         SockPrintf(sock, "\r\n");
 406     }
 407     SockPrintf(sock, "--%s--\r\n", boundary);
 408
 409     if (SMTP_eom(sock, SMTP_MODE) != SM_OK
 410             || SMTP_quit(sock, SMTP_MODE) != SM_OK)
 411     {
 412         SockClose(sock);
 413         return(FALSE);
 414     }
 415
 416     SockClose(sock);
 417
 418     return(TRUE);
 419 }
 420
 421 static int handle_smtp_report(struct query *ctl, struct msgblk *msg)
 422 /* handle SMTP errors based on the content of SMTP_response */
 423 /* returns either PS_REFUSED (to delete message from the server),
 424  *             or PS_TRANSIENT (keeps the message on the server) */
 425 {
 426     int smtperr = atoi(smtp_response);
 427     char *responses[1];
 428     struct idlist *walk;
 429     int found = 0;
 430
 431     responses[0] = xstrdup(smtp_response);
 432
 433 #ifdef __UNUSED__
 434     /*
 435      * Don't do this!  It can really mess you up if, for example, you're
 436      * reporting an error with a single RCPT TO address among several;
 437      * RSET discards the message body and it doesn't get sent to the
 438      * valid recipients.
 439      */
 440     SMTP_rset(ctl->smtp_socket);    /* stay on the safe side */
 441     if (outlevel >= O_DEBUG)
 442         report(stdout, GT_("Saved error is still %d\n"), smtperr);
 443 #endif /* __UNUSED */
 444
 445     /*
 446      * Note: send_bouncemail message strings are not made subject
 447      * to gettext translation because (a) they're going to be
 448      * embedded in a text/plain 7bit part, and (b) they're
 449      * going to be associated with listener error-response
 450      * messages, which are probably in English (none of the
 451      * MTAs I know about are internationalized).
 452      */
 453     for( walk = ctl->antispam; walk; walk = walk->next )
 454         if ( walk->val.status.num == smtperr )
 455         {
 456                 found=1;
 457                 break;
 458         }
 459
 460     /* if (str_find(&ctl->antispam, smtperr)) */
 461     if ( found )
 462     {
 463         /*
 464          * SMTP listener explicitly refuses to deliver mail
 465          * coming from this address, probably due to an
 466          * anti-spam domain exclusion.  Respect this.  Don't
 467          * try to ship the message, and don't prevent it from
 468          * being deleted.  There's no point in bouncing the
 469          * email either since most spammers don't put their
 470          * real return email address anywhere in the headers
 471          * (unless the user insists with the SET SPAMBOUNCE
 472          * config option).
 473          *
 474          * Default values:
 475          *
 476          * 571 = sendmail's "unsolicited email refused"
 477          * 550 = exim's new antispam response (temporary)
 478          * 501 = exim's old antispam response
 479          * 554 = Postfix antispam response.
 480          *
 481          */
 482         if (run.spambounce)
 483         {
 484             char rejmsg[160];
 485             snprintf(rejmsg, sizeof(rejmsg),
 486                     "spam filter or virus scanner rejected message because:\r\n"
 487                     "%s\r\n", responses[0]);
 488
 489             send_bouncemail(ctl, msg, XMIT_ACCEPT,
 490                     rejmsg, 1, responses);
 491         }
 492         free(responses[0]);
 493         return(PS_REFUSED);
 494     }
 495
 496     /*
 497      * Suppress error message only if the response specifically
 498      * meant `excluded for policy reasons'.  We *should* see
 499      * an error when the return code is less specific.
 500      */
 501     if (smtperr >= 400)
 502         report(stderr, GT_("%cMTP error: %s\n"),
 503               ctl->smtphostmode,
 504               responses[0]);
 505
 506     switch (smtperr)
 507     {
 508     case 552: /* message exceeds fixed maximum message size */
 509         /*
 510          * Permanent no-go condition on the
 511          * ESMTP server.  Don't try to ship the message,
 512          * and allow it to be deleted.
 513          */
 514         if (run.bouncemail)
 515             send_bouncemail(ctl, msg, XMIT_ACCEPT,
 516                         "This message was too large (SMTP error 552).\r\n",
 517                         1, responses);
 518         free(responses[0]);
 519         return(PS_REFUSED);
 520
 521     case 553: /* invalid sending domain */
 522         /*
 523          * These latter days 553 usually means a spammer is trying to
 524          * cover his tracks.  We never bouncemail on these, because
 525          * (a) the return address is invalid by definition, and
 526          * (b) we wouldn't want spammers to get confirmation that
 527          * this address is live, anyway.
 528          */
 529 #ifdef __DONT_FEED_THE_SPAMMERS__
 530         if (run.bouncemail)
 531             send_bouncemail(ctl, msg, XMIT_ACCEPT,
 532                         "Invalid address in MAIL FROM (SMTP error 553).\r\n",
 533                         1, responses);
 534 #endif /* __DONT_FEED_THE_SPAMMERS__ */
 535         free(responses[0]);
 536         return(PS_REFUSED);
 537
 538     default:
 539         /* bounce non-transient errors back to the sender */
 540         if (smtperr >= 500 && smtperr <= 599)
 541         {
 542             if (run.bouncemail)
 543                 send_bouncemail(ctl, msg, XMIT_ACCEPT,
 544                                 "General SMTP/ESMTP error.\r\n",
 545                                 1, responses);
 546             free(responses[0]);
 547             return(PS_REFUSED);
 548         }
 549         /*
 550          * We're going to end up here on 4xx errors, like:
 551          *
 552          * 451: temporarily unable to identify sender (exim)
 553          * 452: temporary out-of-queue-space condition on the ESMTP server.
 554          *
 555          * These are temporary errors.  Don't try to ship the message,
 556          * and suppress deletion so it can be retried on a future
 557          * retrieval cycle.
 558          *
 559          * Bouncemail *might* be appropriate here as a delay
 560          * notification (note; if we ever add this, we must make
 561          * sure the RFC1894 Action field is "delayed" rather than
 562          * "failed").  But it's not really necessary because
 563          * these are not actual failures, we're very likely to be
 564          * able to recover on the next cycle.
 565          */
 566         free(responses[0]);
 567         return(PS_TRANSIENT);
 568     }
 569 }
 570
 571 static int handle_smtp_report_without_bounce(struct query *ctl, struct msgblk *msg)
 572 /* handle SMTP errors based on the content of SMTP_response */
 573 /* atleast one PS_TRANSIENT: do not send the bounce mail, keep the mail;
 574  * no PS_TRANSIENT, atleast one PS_SUCCESS: send the bounce mail, delete the mail;
 575  * no PS_TRANSIENT, no PS_SUCCESS: do not send the bounce mail, delete the mail */
 576 {
 577     int smtperr = atoi(smtp_response);
 578
 579     if (str_find(&ctl->antispam, smtperr))
 580     {
 581         if (run.spambounce)
 582          return(PS_SUCCESS);
 583         return(PS_REFUSED);
 584     }
 585
 586     if (smtperr >= 400)
 587         report(stderr, GT_("%cMTP error: %s\n"),
 588               ctl->smtphostmode,
 589               smtp_response);
 590
 591     switch (smtperr)
 592     {
 593     case 552: /* message exceeds fixed maximum message size */
 594         if (run.bouncemail)
 595             return(PS_SUCCESS);
 596         return(PS_REFUSED);
 597
 598     case 553: /* invalid sending domain */
 599 #ifdef __DONT_FEED_THE_SPAMMERS__
 600         if (run.bouncemail)
 601             return(PS_SUCCESS);
 602 #endif /* __DONT_FEED_THE_SPAMMERS__ */
 603         return(PS_REFUSED);
 604
 605     default:
 606         /* bounce non-transient errors back to the sender */
 607         if (smtperr >= 500 && smtperr <= 599)
 608             return(PS_SUCCESS);
 609         return(PS_TRANSIENT);
 610     }
 611 }
 612
 613 /* these are shared by open_sink and stuffline */
 614 static FILE *sinkfp;
 615
 616 int stuffline(struct query *ctl, char *buf)
 617 /* ship a line to the given control block's output sink (SMTP server or MDA) */
 618 {
 619     int n, oldphase;
 620     char *last;
 621
 622     /* The line may contain NUL characters. Find the last char to use
 623      * -- the real line termination is the sequence "\n\0".
 624      */
 625     last = buf + 1; /* last[-1] must be valid! */
 626     while ((last += strlen(last)) && (last[-1] != '\n'))
 627         last++;
 628
 629     /* fix message lines that have only \n termination (for qmail) */
 630     if (ctl->forcecr)
 631     {
 632         if (last - 1 == buf || last[-2] != '\r')
 633         {
 634             last[-1] = '\r';
 635             *last++  = '\n';
 636             *last    = '\0';
 637         }
 638     }
 639
 640     oldphase = phase;
 641     phase = FORWARDING_WAIT;
 642
 643     /*
 644      * SMTP byte-stuffing.  We only do this if the protocol does *not*
 645      * use .<CR><LF> as EOM.  If it does, the server will already have
 646      * decorated any . lines it sends back up.
 647      */
 648     if (*buf == '.')
 649     {
 650         if (ctl->server.base_protocol->delimited)       /* server has already byte-stuffed */
 651         {
 652             if (ctl->mda) {
 653                 /* writing to MDA, undo byte-stuffing */
 654                 ++buf;
 655             } else {
 656                 /* writing to SMTP, leave the byte-stuffing in place */;
 657             }
 658         }
 659         else /* if (!protocol->delimited)       -- not byte-stuffed already */
 660         {
 661             /* byte-stuff it */
 662             if (!ctl->mda)  {
 663                 if (!ctl->bsmtp) {
 664                     n = SockWrite(ctl->smtp_socket, buf, 1);
 665                 } else {
 666                     n = fwrite(buf, 1, 1, sinkfp);
 667                     if (ferror(sinkfp)) n = -1;
 668                 }
 669                 if (n < 0)
 670                     return n;
 671             }
 672         }
 673     }
 674
 675     /* we may need to strip carriage returns */
 676     if (ctl->stripcr)
 677     {
 678         char    *sp, *tp;
 679
 680         for (sp = tp = buf; sp < last; sp++)
 681             if (*sp != '\r')
 682                 *tp++ =  *sp;
 683         *tp = '\0';
 684         last = tp;
 685     }
 686
 687     n = 0;
 688     if (ctl->mda || ctl->bsmtp) {
 689         n = fwrite(buf, last - buf, 1, sinkfp);
 690         if (ferror(sinkfp)) n = -1;
 691     } else if (ctl->smtp_socket != -1)
 692         n = SockWrite(ctl->smtp_socket, buf, last - buf);
 693
 694     phase = oldphase;
 695
 696     return(n);
 697 }
 698
 699 static int open_bsmtp_sink(struct query *ctl, struct msgblk *msg,
 700               int *good_addresses, int *bad_addresses)
 701 /* open a BSMTP stream */
 702 {
 703     struct      idlist *idp;
 704     int         need_anglebrs;
 705
 706     if (strcmp(ctl->bsmtp, "-") == 0)
 707         sinkfp = stdout;
 708     else
 709         sinkfp = fopen(ctl->bsmtp, "a");
 710
 711     /* see the ap computation under the SMTP branch */
 712     need_anglebrs = (msg->return_path[0] != '<');
 713     fprintf(sinkfp,
 714             "MAIL FROM:%s%s%s",
 715             need_anglebrs ? "<" : "",
 716             (msg->return_path[0]) ? msg->return_path : user,
 717             need_anglebrs ? ">" : "");
 718
 719     if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 720         fputs(" BODY=8BITMIME", sinkfp);
 721     else if (ctl->mimemsg & MSG_IS_7BIT)
 722         fputs(" BODY=7BIT", sinkfp);
 723
 724     /* exim's BSMTP processor does not handle SIZE */
 725     /* fprintf(sinkfp, " SIZE=%d", msg->reallen); */
 726
 727     fprintf(sinkfp, "\r\n");
 728
 729     /*
 730      * RFC 1123 requires that the domain name part of the
 731      * RCPT TO address be "canonicalized", that is a FQDN
 732      * or MX but not a CNAME.  Some listeners (like exim)
 733      * enforce this.  Now that we have the actual hostname,
 734      * compute what we should canonicalize with.
 735      */
 736     xfree(ctl->destaddr);
 737     ctl->destaddr = xstrdup(ctl->smtpaddress ? ctl->smtpaddress : "localhost");
 738
 739     *bad_addresses = 0;
 740     for (idp = msg->recipients; idp; idp = idp->next)
 741         if (idp->val.status.mark == XMIT_ACCEPT)
 742         {
 743             fprintf(sinkfp, "RCPT TO:<%s>\r\n",
 744                 rcpt_address (ctl, idp->id, 1));
 745             (*good_addresses)++;
 746         }
 747
 748     fputs("DATA\r\n", sinkfp);
 749
 750     if (ferror(sinkfp))
 751     {
 752         report(stderr, GT_("BSMTP file open or preamble write failed\n"));
 753         return(PS_BSMTP);
 754     }
 755
 756     return(PS_SUCCESS);
 757 }
 758
 759 /* this is experimental and will be removed if double bounces are reported */
 760 #define EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 761
 762
 763 static const char *is_quad(const char *q)
 764 /* Check if the string passed in points to what could be one quad of a
 765  * dotted-quad IP address.  Requirements are that the string is not a
 766  * NULL pointer, begins with a period (which is skipped) or a digit
 767  * and ends with a period or a NULL.  If these requirements are met, a
 768  * pointer to the last character (the period or the NULL character) is
 769  * returned; otherwise NULL.
 770  */
 771 {
 772   const char *r;
 773
 774   if (!q || !*q)
 775     return NULL;
 776   if (*q == '.')
 777     q++;
 778   for(r=q;isdigit((unsigned char)*r);r++)
 779     ;
 780   if ( ((*r) && (*r != '.')) || ((r-q) < 1) || ((r-q)>3) )
 781     return NULL;
 782   /* Make sure quad is < 255 */
 783   if ( (r-q) == 3)
 784   {
 785     if (*q > '2')
 786       return NULL;
 787     else if (*q == '2')
 788     {
 789       if (*(q+1) > '5')
 790         return NULL;
 791       else if (*(q+1) == '5')
 792       {
 793         if (*(q+2) > '5')
 794           return NULL;
 795       }
 796     }
 797   }
 798   return r;
 799 }
 800
 801 static int is_dottedquad(const char *hostname)
 802 /* Returns a true value if the passed in string looks like an IP
 803  *  address in dotted-quad form, and a false value otherwise.
 804  */
 805
 806 {
 807   return ((hostname=is_quad(is_quad(is_quad(is_quad(hostname))))) != NULL) &&
 808     (*hostname == '\0');
 809 }
 810
 811 static int open_smtp_sink(struct query *ctl, struct msgblk *msg,
 812               int *good_addresses, int *bad_addresses /* this must be signed, to prevent endless loop in from_addresses */)
 813 /* open an SMTP stream */
 814 {
 815     const char  *ap;
 816     struct      idlist *idp;
 817     char                options[MSGBUFSIZE];
 818     char                addr[HOSTLEN+USERNAMELEN+1];
 819 #ifdef EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 820     char                **from_responses;
 821 #endif /* EXPLICIT_BOUNCE_ON_BAD_ADDRESS */
 822     int         total_addresses;
 823     int         force_transient_error = 0;
 824     int         smtp_err;
 825
 826     /*
 827      * Compute ESMTP options.
 828      */
 829     options[0] = '\0';
 830     if (ctl->server.esmtp_options & ESMTP_8BITMIME) {
 831          if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 832             strcpy(options, " BODY=8BITMIME");
 833          else if (ctl->mimemsg & MSG_IS_7BIT)
 834             strcpy(options, " BODY=7BIT");
 835     }
 836
 837     if ((ctl->server.esmtp_options & ESMTP_SIZE) && msg->reallen > 0)
 838         sprintf(options + strlen(options), " SIZE=%d", msg->reallen);
 839
 840     /*
 841      * Try to get the SMTP listener to take the Return-Path
 842      * address as MAIL FROM.  If it won't, fall back on the
 843      * remotename and mailserver host.  This won't affect replies,
 844      * which use the header From address anyway; the MAIL FROM
 845      * address is a place for the SMTP listener to send
 846      * bouncemail.  The point is to guarantee a FQDN in the MAIL
 847      * FROM line -- some SMTP listeners, like smail, become
 848      * unhappy otherwise.
 849      *
 850      * RFC 1123 requires that the domain name part of the
 851      * MAIL FROM address be "canonicalized", that is a
 852      * FQDN or MX but not a CNAME.  We'll assume the Return-Path
 853      * header is already in this form here (it certainly
 854      * is if rewrite is on).  RFC 1123 is silent on whether
 855      * a nonexistent hostname part is considered canonical.
 856      *
 857      * This is a potential problem if the MTAs further upstream
 858      * didn't pass canonicalized From/Return-Path lines, *and* the
 859      * local SMTP listener insists on them.
 860      *
 861      * Handle the case where an upstream MTA is setting a return
 862      * path equal to "@".  Ghod knows why anyone does this, but
 863      * it's been reported to happen in mail from Amazon.com and
 864      * Motorola.
 865      *
 866      * Also, if the hostname is a dotted quad, wrap it in square brackets.
 867      * Apparently this is required by RFC2821, section 4.1.3.
 868      */
 869     if (!msg->return_path[0] || (msg->return_path[0] == '@'))
 870     {
 871       if (strchr(ctl->remotename,'@') || strchr(ctl->remotename,'!'))
 872       {
 873         snprintf(addr, sizeof(addr), "%s", ctl->remotename);
 874       }
 875       else if (is_dottedquad(ctl->server.truename))
 876       {
 877         snprintf(addr, sizeof(addr), "%s@[%s]", ctl->remotename,
 878                 ctl->server.truename);
 879       }
 880       else
 881       {
 882         snprintf(addr, sizeof(addr),
 883               "%s@%s", ctl->remotename, ctl->server.truename);
 884       }
 885         ap = addr;
 886     }
 887     else if (strchr(msg->return_path,'@') || strchr(msg->return_path,'!'))
 888         ap = msg->return_path;
 889     /* in case Return-Path was "<>" we want to preserve that */
 890     else if (strcmp(msg->return_path,"<>") == 0)
 891         ap = msg->return_path;
 892     else                /* in case Return-Path existed but was local */
 893     {
 894       if (is_dottedquad(ctl->server.truename))
 895       {
 896         snprintf(addr, sizeof(addr), "%s@[%s]", msg->return_path,
 897                 ctl->server.truename);
 898       }
 899       else
 900       {
 901         snprintf(addr, sizeof(addr), "%s@%s",
 902                 msg->return_path, ctl->server.truename);
 903       }
 904         ap = addr;
 905     }
 906
 907     if ((smtp_err = SMTP_from(ctl->smtp_socket, ctl->smtphostmode,
 908                     ap, options)) == SM_UNRECOVERABLE)
 909     {
 910         smtp_close(ctl, 0);
 911         return(PS_TRANSIENT);
 912     }
 913     if (smtp_err != SM_OK)
 914     {
 915         int err = handle_smtp_report(ctl, msg); /* map to PS_TRANSIENT or PS_REFUSED */
 916
 917         SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);    /* stay on the safe side */
 918         return(err);
 919     }
 920
 921     /*
 922      * Now list the recipient addressees
 923      */
 924     total_addresses = 0;
 925     for (idp = msg->recipients; idp; idp = idp->next)
 926         total_addresses++;
 927 #ifdef EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 928     from_responses = (char **)xmalloc(sizeof(char *) * total_addresses);
 929 #endif /* EXPLICIT_BOUNCE_ON_BAD_ADDRESS */
 930     for (idp = msg->recipients; idp; idp = idp->next)
 931         if (idp->val.status.mark == XMIT_ACCEPT)
 932         {
 933             const char *address;
 934             address = rcpt_address (ctl, idp->id, 1);
 935             if ((smtp_err = SMTP_rcpt(ctl->smtp_socket, ctl->smtphostmode,
 936                             address)) == SM_UNRECOVERABLE)
 937             {
 938                 smtp_close(ctl, 0);
 939 transient:
 940 #ifdef EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 941                 while (*bad_addresses)
 942                     free(from_responses[--*bad_addresses]);
 943                 free(from_responses);
 944 #endif /* EXPLICIT_BOUNCE_ON_BAD_ADDRESS */
 945                 return(PS_TRANSIENT);
 946             }
 947             if (smtp_err == SM_OK)
 948                 (*good_addresses)++;
 949             else
 950             {
 951                 switch (handle_smtp_report_without_bounce(ctl, msg))
 952                 {
 953                     case PS_TRANSIENT:
 954                     force_transient_error = 1;
 955                     break;
 956
 957                     case PS_SUCCESS:
 958 #ifdef EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 959                     from_responses[*bad_addresses] = xstrdup(smtp_response);
 960                     strcpy(from_responses[*bad_addresses], smtp_response);
 961 #endif /* EXPLICIT_BOUNCE_ON_BAD_ADDRESS */
 962
 963                     (*bad_addresses)++;
 964                     idp->val.status.mark = XMIT_RCPTBAD;
 965                     if (outlevel >= O_VERBOSE)
 966                         report(stderr,
 967                               GT_("%cMTP listener doesn't like recipient address `%s'\n"),
 968                               ctl->smtphostmode, address);
 969                     break;
 970
 971                     case PS_REFUSED:
 972                     if (outlevel >= O_VERBOSE)
 973                         report(stderr,
 974                               GT_("%cMTP listener doesn't really like recipient address `%s'\n"),
 975                               ctl->smtphostmode, address);
 976                     break;
 977                 }
 978             }
 979         }
 980
 981     if (force_transient_error) {
 982             /* do not risk dataloss due to overengineered multidrop
 983              * crap. If one of the recipients returned PS_TRANSIENT,
 984              * we return exactly that.
 985              */
 986             SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);        /* required by RFC1870 */
 987             goto transient;
 988     }
 989 #ifdef EXPLICIT_BOUNCE_ON_BAD_ADDRESS
 990     /*
 991      * This should not be necessary, because the SMTP listener itself
 992      * should generate a bounce for the bad address.
 993      *
 994      * XXX FIXME 2006-01-19: is this comment true? I don't think
 995      * it is, because the SMTP listener isn't required to accept bogus
 996      * messages. There appears to be general SMTP<->MDA and
 997      * responsibility confusion.
 998      */
 999     if (*bad_addresses)
1000         send_bouncemail(ctl, msg, XMIT_RCPTBAD,
1001                         "Some addresses were rejected by the MDA fetchmail forwards to.\r\n",
1002                         *bad_addresses, from_responses);
1003     while (*bad_addresses)
1004         free(from_responses[--*bad_addresses]);
1005     free(from_responses);
1006 #endif /* EXPLICIT_BOUNCE_ON_BAD_ADDRESS */
1007
1008     /*
1009      * It's tempting to do local notification only if bouncemail was
1010      * insufficient -- that is, to add && total_addresses > *bad_addresses
1011      * to the test here.  The problem with this theory is that it would
1012      * make initial diagnosis of a broken multidrop configuration very
1013      * hard -- most single-recipient messages would just invisibly bounce.
1014      */
1015     if (!(*good_addresses))
1016     {
1017         if (!run.postmaster[0])
1018         {
1019             if (outlevel >= O_VERBOSE)
1020                 report(stderr, GT_("no address matches; no postmaster set.\n"));
1021             SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);     /* required by RFC1870 */
1022             return(PS_REFUSED);
1023         }
1024         if ((smtp_err = SMTP_rcpt(ctl->smtp_socket, ctl->smtphostmode,
1025                 rcpt_address (ctl, run.postmaster, 0))) == SM_UNRECOVERABLE)
1026         {
1027             smtp_close(ctl, 0);
1028             return(PS_TRANSIENT);
1029         }
1030         if (smtp_err != SM_OK)
1031         {
1032             report(stderr, GT_("can't even send to %s!\n"), run.postmaster);
1033             SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);     /* required by RFC1870 */
1034             return(PS_REFUSED);
1035         }
1036
1037         if (outlevel >= O_VERBOSE)
1038             report(stderr, GT_("no address matches; forwarding to %s.\n"), run.postmaster);
1039     }
1040
1041     /*
1042      * Tell the listener we're ready to send data.
1043      * Some listeners (like zmailer) may return antispam errors here.
1044      */
1045     if ((smtp_err = SMTP_data(ctl->smtp_socket, ctl->smtphostmode))
1046             == SM_UNRECOVERABLE)
1047     {
1048         smtp_close(ctl, 0);
1049         return(PS_TRANSIENT);
1050     }
1051     if (smtp_err != SM_OK)
1052     {
1053         int err = handle_smtp_report(ctl, msg);
1054         SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);    /* stay on the safe side */
1055         return(err);
1056     }
1057
1058     /*
1059      * We need to stash this away in order to know how many
1060      * response lines to expect after the LMTP end-of-message.
1061      */
1062     lmtp_responses = *good_addresses;
1063
1064     return(PS_SUCCESS);
1065 }
1066
1067 static int open_mda_sink(struct query *ctl, struct msgblk *msg,
1068               int *good_addresses, int *bad_addresses)
1069 /* open a stream to a local MDA */
1070 {
1071 #ifdef HAVE_SETEUID
1072     uid_t orig_uid;
1073 #endif /* HAVE_SETEUID */
1074     struct      idlist *idp;
1075     int length = 0, fromlen = 0, nameslen = 0;
1076     char        *names = NULL, *before, *after, *from = NULL;
1077
1078     (void)bad_addresses;
1079     xfree(ctl->destaddr);
1080     ctl->destaddr = xstrdup("localhost");
1081
1082     for (idp = msg->recipients; idp; idp = idp->next)
1083         if (idp->val.status.mark == XMIT_ACCEPT)
1084             (*good_addresses)++;
1085
1086     length = strlen(ctl->mda);
1087     before = xstrdup(ctl->mda);
1088
1089     /* get user addresses for %T (or %s for backward compatibility) */
1090     if (strstr(before, "%s") || strstr(before, "%T"))
1091     {
1092         /*
1093          * We go through this in order to be able to handle very
1094          * long lists of users and (re)implement %s.
1095          */
1096         nameslen = 0;
1097         for (idp = msg->recipients; idp; idp = idp->next)
1098             if ((idp->val.status.mark == XMIT_ACCEPT))
1099                 nameslen += (strlen(idp->id) + 1);      /* string + ' ' */
1100         if ((*good_addresses == 0))
1101             nameslen = strlen(run.postmaster);
1102
1103         names = (char *)xmalloc(nameslen + 1);  /* account for '\0' */
1104         if (*good_addresses == 0)
1105             strcpy(names, run.postmaster);
1106         else
1107         {
1108             names[0] = '\0';
1109             for (idp = msg->recipients; idp; idp = idp->next)
1110                 if (idp->val.status.mark == XMIT_ACCEPT)
1111                 {
1112                     strcat(names, idp->id);
1113                     strcat(names, " ");
1114                 }
1115             names[--nameslen] = '\0';   /* chop trailing space */
1116         }
1117
1118         sanitize(names);
1119     }
1120
1121     /* get From address for %F */
1122     if (strstr(before, "%F"))
1123     {
1124         from = xstrdup(msg->return_path);
1125
1126         sanitize(from);
1127
1128         fromlen = strlen(from);
1129     }
1130
1131     /* do we have to build an mda string? */
1132     if (names || from)
1133     {
1134         char    *sp, *dp;
1135
1136         /* find length of resulting mda string */
1137         sp = before;
1138         while ((sp = strstr(sp, "%s"))) {
1139             length += nameslen; /* subtract %s and add '' */
1140             sp += 2;
1141         }
1142         sp = before;
1143         while ((sp = strstr(sp, "%T"))) {
1144             length += nameslen; /* subtract %T and add '' */
1145             sp += 2;
1146         }
1147         sp = before;
1148         while ((sp = strstr(sp, "%F"))) {
1149             length += fromlen;  /* subtract %F and add '' */
1150             sp += 2;
1151         }
1152
1153         after = xmalloc(length + 1);
1154
1155         /* copy mda source string to after, while expanding %[sTF] */
1156         for (dp = after, sp = before; (*dp = *sp); dp++, sp++) {
1157             if (sp[0] != '%')   continue;
1158
1159             /* need to expand? BTW, no here overflow, because in
1160             ** the worst case (end of string) sp[1] == '\0' */
1161             if (sp[1] == 's' || sp[1] == 'T') {
1162                 *dp++ = '\'';
1163                 strcpy(dp, names);
1164                 dp += nameslen;
1165                 *dp++ = '\'';
1166                 sp++;   /* position sp over [sT] */
1167                 dp--;   /* adjust dp */
1168             } else if (sp[1] == 'F') {
1169                 *dp++ = '\'';
1170                 strcpy(dp, from);
1171                 dp += fromlen;
1172                 *dp++ = '\'';
1173                 sp++;   /* position sp over F */
1174                 dp--;   /* adjust dp */
1175             }
1176         }
1177
1178         if (names) {
1179             free(names);
1180             names = NULL;
1181         }
1182         if (from) {
1183             free(from);
1184             from = NULL;
1185         }
1186
1187         free(before);
1188
1189         before = after;
1190     }
1191
1192
1193     if (outlevel >= O_DEBUG)
1194         report(stdout, GT_("about to deliver with: %s\n"), before);
1195
1196 #ifdef HAVE_SETEUID
1197     /*
1198      * Arrange to run with user's permissions if we're root.
1199      * This will initialize the ownership of any files the
1200      * MDA creates properly.  (The seteuid call is available
1201      * under all BSDs and Linux)
1202      */
1203     orig_uid = getuid();
1204     seteuid(ctl->uid);
1205 #endif /* HAVE_SETEUID */
1206
1207     sinkfp = popen(before, "w");
1208     free(before);
1209     before = NULL;
1210
1211 #ifdef HAVE_SETEUID
1212     /* this will fail quietly if we didn't start as root */
1213     seteuid(orig_uid);
1214 #endif /* HAVE_SETEUID */
1215
1216     if (!sinkfp)
1217     {
1218         report(stderr, GT_("MDA open failed\n"));
1219         return(PS_IOERR);
1220     }
1221
1222     /*
1223      * We need to disable the normal SIGCHLD handling here because
1224      * sigchld_handler() would reap away the error status, returning
1225      * error status instead of 0 for successful completion.
1226      */
1227     set_signal_handler(SIGCHLD, SIG_DFL);
1228
1229     return(PS_SUCCESS);
1230 }
1231
1232 int open_sink(struct query *ctl, struct msgblk *msg,
1233               int *good_addresses, int *bad_addresses)
1234 /* set up sinkfp to be an input sink we can ship a message to */
1235 {
1236     *bad_addresses = *good_addresses = 0;
1237
1238     if (ctl->bsmtp)             /* dump to a BSMTP batch file */
1239         return(open_bsmtp_sink(ctl, msg, good_addresses, bad_addresses));
1240     /*
1241      * Try to forward to an SMTP or LMTP listener.  If the attempt to
1242      * open a socket fails, fall through to attempt delivery via
1243      * local MDA.
1244      */
1245     else if (!ctl->mda && smtp_open(ctl) != -1)
1246         return(open_smtp_sink(ctl, msg, good_addresses, bad_addresses));
1247
1248     /*
1249      * Awkward case.  User didn't specify an MDA.  Our attempt to get a
1250      * listener socket failed.  Try to cope anyway -- initial configuration
1251      * may have found procmail.
1252      */
1253     else if (!ctl->mda)
1254     {
1255         report(stderr, GT_("%cMTP connect to %s failed\n"),
1256                ctl->smtphostmode,
1257                ctl->smtphost ? ctl->smtphost : "localhost");
1258
1259 #ifndef FALLBACK_MDA
1260         /* No fallback MDA declared.  Bail out. */
1261         return(PS_SMTP);
1262 #else
1263         /*
1264          * If user had things set up to forward offsite, no way
1265          * we want to deliver locally!
1266          */
1267         if (ctl->smtphost && strcmp(ctl->smtphost, "localhost"))
1268             return(PS_SMTP);
1269
1270         /*
1271          * User was delivering locally.  We have a fallback MDA.
1272          * Latch it in place, logging the error, and fall through.
1273          * Set stripcr as we would if MDA had been the initial transport
1274          */
1275         ctl->mda = FALLBACK_MDA;
1276         if (!ctl->forcecr)
1277             ctl->stripcr = TRUE;
1278
1279         report(stderr, GT_("can't raise the listener; falling back to %s"),
1280                          FALLBACK_MDA);
1281 #endif
1282     }
1283
1284     if (ctl->mda)               /* must deliver through an MDA */
1285         return(open_mda_sink(ctl, msg, good_addresses, bad_addresses));
1286
1287     return(PS_SUCCESS);
1288 }
1289
1290 void release_sink(struct query *ctl)
1291 /* release the per-message output sink, whether it's a pipe or SMTP socket */
1292 {
1293     if (ctl->bsmtp && sinkfp)
1294     {
1295         if (strcmp(ctl->bsmtp, "-"))
1296         {
1297             fclose(sinkfp);
1298             sinkfp = (FILE *)NULL;
1299         }
1300     }
1301     else if (ctl->mda)
1302     {
1303         if (sinkfp)
1304         {
1305             pclose(sinkfp);
1306             sinkfp = (FILE *)NULL;
1307         }
1308         deal_with_sigchld(); /* Restore SIGCHLD handling to reap zombies */
1309     }
1310 }
1311
1312 int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
1313 /* perform end-of-message actions on the current output sink */
1314 {
1315     int smtp_err;
1316     if (ctl->mda)
1317     {
1318         int rc,e,e2,err = 0;
1319
1320         /* close the delivery pipe, we'll reopen before next message */
1321         if (sinkfp)
1322         {
1323             if (ferror(sinkfp))
1324                 err = 1, e2 = errno;
1325             if ((fflush(sinkfp)))
1326                 err = 1, e2 = errno;
1327
1328             errno = 0;
1329             rc = pclose(sinkfp);
1330             e = errno;
1331             sinkfp = (FILE *)NULL;
1332         }
1333         else
1334             rc = e = 0;
1335
1336         deal_with_sigchld(); /* Restore SIGCHLD handling to reap zombies */
1337
1338         if (rc || err)
1339         {
1340             if (err) {
1341                 report(stderr, GT_("Error writing to MDA: %s\n"), strerror(e2));
1342             } else if (WIFSIGNALED(rc)) {
1343                 report(stderr,
1344                         GT_("MDA died of signal %d\n"), WTERMSIG(rc));
1345             } else if (WIFEXITED(rc)) {
1346                 report(stderr,
1347                         GT_("MDA returned nonzero status %d\n"), WEXITSTATUS(rc));
1348             } else {
1349                 report(stderr,
1350                         GT_("Strange: MDA pclose returned %d and errno %d/%s, cannot handle at %s:%d\n"),
1351                         rc, e, strerror(e), __FILE__, __LINE__);
1352             }
1353
1354             return(FALSE);
1355         }
1356     }
1357     else if (ctl->bsmtp && sinkfp)
1358     {
1359         int error;
1360
1361         /* implicit disk-full check here... */
1362         fputs(".\r\n", sinkfp);
1363         error = ferror(sinkfp);
1364         if (strcmp(ctl->bsmtp, "-"))
1365         {
1366             if (fclose(sinkfp) == EOF) error = 1;
1367             sinkfp = (FILE *)NULL;
1368         }
1369         if (error)
1370         {
1371             report(stderr,
1372                    GT_("Message termination or close of BSMTP file failed\n"));
1373             return(FALSE);
1374         }
1375     }
1376     else if (forward)
1377     {
1378         /* write message terminator */
1379         if ((smtp_err = SMTP_eom(ctl->smtp_socket, ctl->smtphostmode))
1380                 == SM_UNRECOVERABLE)
1381         {
1382             smtp_close(ctl, 0);
1383             return(FALSE);
1384         }
1385         if (smtp_err != SM_OK)
1386         {
1387             if (handle_smtp_report(ctl, msg) != PS_REFUSED)
1388             {
1389                 SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);    /* stay on the safe side */
1390                 return(FALSE);
1391             }
1392             else
1393             {
1394                 report(stderr, GT_("SMTP listener refused delivery\n"));
1395                 SMTP_rset(ctl->smtp_socket, ctl->smtphostmode);    /* stay on the safe side */
1396                 return(TRUE);
1397             }
1398         }
1399
1400         /*
1401          * If this is an SMTP connection, SMTP_eom() ate the response.
1402          * But could be this is an LMTP connection, in which case we have to
1403          * interpret either (a) a single 503 response meaning there
1404          * were no successful RCPT TOs, or (b) a variable number of
1405          * responses, one for each successful RCPT TO.  We need to send
1406          * bouncemail on each failed response and then return TRUE anyway,
1407          * otherwise the message will get left in the queue and resent
1408          * to people who got it the first time.
1409          */
1410         if (ctl->smtphostmode == LMTP_MODE)
1411         {
1412             if (lmtp_responses == 0)
1413             {
1414                 SMTP_ok(ctl->smtp_socket, ctl->smtphostmode);
1415
1416                 /*
1417                  * According to RFC2033, 503 is the only legal response
1418                  * if no RCPT TO commands succeeded.  No error recovery
1419                  * is really possible here, as we have no idea what
1420                  * insane thing the listener might be doing if it doesn't
1421                  * comply.
1422                  */
1423                 if (atoi(smtp_response) == 503)
1424                     report(stderr, GT_("LMTP delivery error on EOM\n"));
1425                 else
1426                     report(stderr,
1427                           GT_("Unexpected non-503 response to LMTP EOM: %s\n"),
1428                           smtp_response);
1429
1430                 /*
1431                  * It's not completely clear what to do here.  We choose to
1432                  * interpret delivery failure here as a transient error,
1433                  * the same way SMTP delivery failure is handled.  If we're
1434                  * wrong, an undead message will get stuck in the queue.
1435                  */
1436                 return(FALSE);
1437             }
1438             else
1439             {
1440                 int     i, errors, rc = FALSE;
1441                 char    **responses;
1442
1443                 /* eat the RFC2033-required responses, saving errors */
1444                 responses = (char **)xmalloc(sizeof(char *) * lmtp_responses);
1445                 for (errors = i = 0; i < lmtp_responses; i++)
1446                 {
1447                     if ((smtp_err = SMTP_ok(ctl->smtp_socket, ctl->smtphostmode))
1448                             == SM_UNRECOVERABLE)
1449                     {
1450                         smtp_close(ctl, 0);
1451                         goto unrecov;
1452                     }
1453                     if (smtp_err != SM_OK)
1454                     {
1455                         responses[errors] = xstrdup(smtp_response);
1456                         errors++;
1457                     }
1458                 }
1459
1460                 if (errors == 0)
1461                     rc = TRUE;  /* all deliveries succeeded */
1462                 else
1463                     /*
1464                      * One or more deliveries failed.
1465                      * If we can bounce a failures list back to the
1466                      * sender, and the postmaster does not want to
1467                      * deal with the bounces return TRUE, deleting the
1468                      * message from the server so it won't be
1469                      * re-forwarded on subsequent poll cycles.
1470                      */
1471                     rc = send_bouncemail(ctl, msg, XMIT_ACCEPT,
1472                             "LMTP partial delivery failure.\r\n",
1473                             errors, responses);
1474
1475 unrecov:
1476                 for (i = 0; i < errors; i++)
1477                     free(responses[i]);
1478                 free(responses);
1479                 return rc;
1480             }
1481         }
1482     }
1483
1484     return(TRUE);
1485 }
1486
1487 int open_warning_by_mail(struct query *ctl)
1488 /* set up output sink for a mailed warning to calling user */
1489 {
1490     int good, bad;
1491
1492     /*
1493      * Dispatching warning email is a little complicated.  The problem is
1494      * that we have to deal with three distinct cases:
1495      *
1496      * 1. Single-drop running from user account.  Warning mail should
1497      * go to the local name for which we're collecting (coincides
1498      * with calling user).
1499      *
1500      * 2. Single-drop running from root or other privileged ID, with rc
1501      * file generated on the fly (Ken Estes's weird setup...)  Mail
1502      * should go to the local name for which we're collecting (does not
1503      * coincide with calling user).
1504      *
1505      * 3. Multidrop.  Mail must go to postmaster.  We leave the recipients
1506      * member null so this message will fall through to run.postmaster.
1507      *
1508      * The zero in the reallen element means we won't pass a SIZE
1509      * option to ESMTP; the message length would be more trouble than
1510      * it's worth to compute.
1511      */
1512     struct msgblk reply = {NULL, NULL, "FETCHMAIL-DAEMON@", 0, 0};
1513     int status;
1514
1515     strlcat(reply.return_path, ctl->smtpaddress ? ctl->smtpaddress :
1516             fetchmailhost, sizeof(reply.return_path));
1517
1518     if (!MULTIDROP(ctl))                /* send to calling user */
1519     {
1520         save_str(&reply.recipients, ctl->localnames->id, XMIT_ACCEPT);
1521         status = open_sink(ctl, &reply, &good, &bad);
1522         free_str_list(&reply.recipients);
1523     }
1524     else                                /* send to postmaster  */
1525         status = open_sink(ctl, &reply, &good, &bad);
1526     if (status == 0) {
1527         stuff_warning(NULL, ctl, "From: FETCHMAIL-DAEMON@%s",
1528                 ctl->smtpaddress ? ctl->smtpaddress : fetchmailhost);
1529         stuff_warning(NULL, ctl, "Date: %s", rfc822timestamp());
1530         stuff_warning(NULL, ctl, "MIME-Version: 1.0");
1531         stuff_warning(NULL, ctl, "Content-Transfer-Encoding: 8bit");
1532         stuff_warning(NULL, ctl, "Content-Type: text/plain; charset=\"%s\"", iana_charset);
1533     }
1534     return(status);
1535 }
1536
1537 /* format and ship a warning message line by mail */
1538 /* if rfc2047charset is non-NULL, encode the line (that is assumed to be
1539  * a header line) as per RFC-2047 using rfc2047charset as the character
1540  * set field */
1541 #if defined(HAVE_STDARG_H)
1542 void stuff_warning(const char *rfc2047charset, struct query *ctl, const char *fmt, ... )
1543 #else
1544 void stuff_warning(rfc2047charset, ctl, fmt, va_alist)
1545 const char *charset;
1546 struct query *ctl;
1547 const char *fmt;        /* printf-style format */
1548 va_dcl
1549 #endif
1550 {
1551     /* make huge -- i18n can bulk up error messages a lot */
1552     char        buf[2*MSGBUFSIZE+4];
1553     va_list ap;
1554
1555     /*
1556      * stuffline() requires its input to be writeable (for CR stripping),
1557      * so we needed to copy the message to a writeable buffer anyway in
1558      * case it was a string constant.  We make a virtue of that necessity
1559      * here by supporting stdargs/varargs.
1560      */
1561 #if defined(HAVE_STDARG_H)
1562     va_start(ap, fmt) ;
1563 #else
1564     va_start(ap);
1565 #endif
1566     vsnprintf(buf, sizeof(buf) - 2, fmt, ap);
1567     va_end(ap);
1568
1569     snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), "\r\n");
1570
1571     /* guard against very long lines */
1572     buf[MSGBUFSIZE+1] = '\r';
1573     buf[MSGBUFSIZE+2] = '\n';
1574     buf[MSGBUFSIZE+3] = '\0';
1575
1576     stuffline(ctl, rfc2047charset != NULL ? rfc2047e(buf, rfc2047charset) : buf);
1577 }
1578
1579 void close_warning_by_mail(struct query *ctl, struct msgblk *msg)
1580 /* sign and send mailed warnings */
1581 {
1582     stuff_warning(NULL, ctl, GT_("-- \nThe Fetchmail Daemon"));
1583     close_sink(ctl, msg, TRUE);
1584 }
1585
1586 /* sink.c ends here */