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  * i18n by Arnaldo Carvalho de Melo <acme@conectiva.com.br> 7-Nov-1998
  13  */
  14
  15 #include  "config.h"
  16 #include  <stdio.h>
  17 #include  <errno.h>
  18 #include  <string.h>
  19 #include  <signal.h>
  20 #ifdef HAVE_MEMORY_H
  21 #include  <memory.h>
  22 #endif /* HAVE_MEMORY_H */
  23 #if defined(STDC_HEADERS)
  24 #include  <stdlib.h>
  25 #endif
  26 #if defined(HAVE_UNISTD_H)
  27 #include <unistd.h>
  28 #endif
  29 #if defined(HAVE_STDARG_H)
  30 #include  <stdarg.h>
  31 #else
  32 #include  <varargs.h>
  33 #endif
  34
  35 #include  "fetchmail.h"
  36 #include  "socket.h"
  37 #include  "smtp.h"
  38 #include  "i18n.h"
  39
  40 /* BSD portability hack...I know, this is an ugly place to put it */
  41 #if !defined(SIGCHLD) && defined(SIGCLD)
  42 #define SIGCHLD SIGCLD
  43 #endif
  44
  45 static int smtp_open(struct query *ctl)
  46 /* try to open a socket to the appropriate SMTP server for this query */
  47 {
  48     /* maybe it's time to close the socket in order to force delivery */
  49     if (NUM_NONZERO(ctl->batchlimit) && (ctl->smtp_socket != -1) && batchcount++ == ctl->batchlimit)
  50     {
  51         close(ctl->smtp_socket);
  52         ctl->smtp_socket = -1;
  53         batchcount = 0;
  54     }
  55
  56     /* if no socket to any SMTP host is already set up, try to open one */
  57     if (ctl->smtp_socket == -1)
  58     {
  59         /*
  60          * RFC 1123 requires that the domain name in HELO address is a
  61          * "valid principal domain name" for the client host. If we're
  62          * running in invisible mode, violate this with malice
  63          * aforethought in order to make the Received headers and
  64          * logging look right.
  65          *
  66          * In fact this code relies on the RFC1123 requirement that the
  67          * SMTP listener must accept messages even if verification of the
  68          * HELO name fails (RFC1123 section 5.2.5, paragraph 2).
  69          *
  70          * How we compute the true mailhost name to pass to the
  71          * listener doesn't affect behavior on RFC1123- violating
  72          * listeners that check for name match; we're going to lose
  73          * on those anyway because we can never give them a name
  74          * that matches the local machine fetchmail is running on.
  75          * What it will affect is the listener's logging.
  76          */
  77         struct idlist   *idp;
  78         const char *id_me = run.invisible ? ctl->server.truename : fetchmailhost;
  79         int oldphase = phase;
  80
  81         errno = 0;
  82
  83         /*
  84          * Run down the SMTP hunt list looking for a server that's up.
  85          * Use both explicit hunt entries (value TRUE) and implicit
  86          * (default) ones (value FALSE).
  87          */
  88         oldphase = phase;
  89         phase = LISTENER_WAIT;
  90
  91         set_timeout(ctl->server.timeout);
  92         for (idp = ctl->smtphunt; idp; idp = idp->next)
  93         {
  94             char        *cp, *parsed_host;
  95 #ifdef INET6
  96             char        *portnum = SMTP_PORT;
  97 #else
  98             int         portnum = SMTP_PORT;
  99 #endif /* INET6 */
 100
 101             xalloca(parsed_host, char *, strlen(idp->id) + 1);
 102
 103             ctl->smtphost = idp->id;  /* remember last host tried. */
 104
 105             strcpy(parsed_host, idp->id);
 106             if ((cp = strrchr(parsed_host, '/')))
 107             {
 108                 *cp++ = 0;
 109 #ifdef INET6
 110                 portnum = cp;
 111 #else
 112                 portnum = atoi(cp);
 113 #endif /* INET6 */
 114             }
 115
 116             if ((ctl->smtp_socket = SockOpen(parsed_host,portnum,NULL,
 117                                              ctl->server.plugout)) == -1)
 118                 continue;
 119
 120             /* are we doing SMTP or LMTP? */
 121             SMTP_setmode(ctl->listener);
 122
 123             /* first, probe for ESMTP */
 124             if (SMTP_ok(ctl->smtp_socket) == SM_OK &&
 125                     SMTP_ehlo(ctl->smtp_socket, id_me,
 126                           &ctl->server.esmtp_options) == SM_OK)
 127                break;  /* success */
 128
 129             /*
 130              * RFC 1869 warns that some listeners hang up on a failed EHLO,
 131              * so it's safest not to assume the socket will still be good.
 132              */
 133             SockClose(ctl->smtp_socket);
 134             ctl->smtp_socket = -1;
 135
 136             /* if opening for ESMTP failed, try SMTP */
 137             if ((ctl->smtp_socket = SockOpen(parsed_host,portnum,NULL,
 138                                              ctl->server.plugout)) == -1)
 139                 continue;
 140
 141             if (SMTP_ok(ctl->smtp_socket) == SM_OK &&
 142                     SMTP_helo(ctl->smtp_socket, id_me) == SM_OK)
 143                 break;  /* success */
 144
 145             SockClose(ctl->smtp_socket);
 146             ctl->smtp_socket = -1;
 147         }
 148         set_timeout(0);
 149         phase = oldphase;
 150     }
 151
 152     /*
 153      * RFC 1123 requires that the domain name part of the
 154      * RCPT TO address be "canonicalized", that is a FQDN
 155      * or MX but not a CNAME.  Some listeners (like exim)
 156      * enforce this.  Now that we have the actual hostname,
 157      * compute what we should canonicalize with.
 158      */
 159     ctl->destaddr = ctl->smtpaddress ? ctl->smtpaddress : ( ctl->smtphost ? ctl->smtphost : "localhost");
 160
 161     if (outlevel >= O_DEBUG && ctl->smtp_socket != -1)
 162         error(0, 0, _("forwarding to %s"), ctl->smtphost);
 163
 164     return(ctl->smtp_socket);
 165 }
 166
 167 /* these are shared by open_sink and stuffline */
 168 static FILE *sinkfp;
 169 static RETSIGTYPE (*sigchld)(int);
 170
 171 int stuffline(struct query *ctl, char *buf)
 172 /* ship a line to the given control block's output sink (SMTP server or MDA) */
 173 {
 174     int n, oldphase;
 175     char *last;
 176
 177     /* The line may contain NUL characters. Find the last char to use
 178      * -- the real line termination is the sequence "\n\0".
 179      */
 180     last = buf;
 181     while ((last += strlen(last)) && (last[-1] != '\n'))
 182         last++;
 183
 184     /* fix message lines that have only \n termination (for qmail) */
 185     if (ctl->forcecr)
 186     {
 187         if (last - 1 == buf || last[-2] != '\r')
 188         {
 189             last[-1] = '\r';
 190             *last++  = '\n';
 191             *last    = '\0';
 192         }
 193     }
 194
 195     oldphase = phase;
 196     phase = FORWARDING_WAIT;
 197
 198     /*
 199      * SMTP byte-stuffing.  We only do this if the protocol does *not*
 200      * use .<CR><LF> as EOM.  If it does, the server will already have
 201      * decorated any . lines it sends back up.
 202      */
 203     if (*buf == '.')
 204         if (ctl->server.base_protocol->delimited)       /* server has already byte-stuffed */
 205         {
 206             if (ctl->mda)
 207                 ++buf;
 208             else
 209                 /* writing to SMTP, leave the byte-stuffing in place */;
 210         }
 211         else /* if (!protocol->delimited)       -- not byte-stuffed already */
 212         {
 213             if (!ctl->mda)
 214                 SockWrite(ctl->smtp_socket, buf, 1);    /* byte-stuff it */
 215             else
 216                 /* leave it alone */;
 217         }
 218
 219     /* we may need to strip carriage returns */
 220     if (ctl->stripcr)
 221     {
 222         char    *sp, *tp;
 223
 224         for (sp = tp = buf; sp < last; sp++)
 225             if (*sp != '\r')
 226                 *tp++ =  *sp;
 227         *tp = '\0';
 228         last = tp;
 229     }
 230
 231     n = 0;
 232     if (ctl->mda || ctl->bsmtp)
 233         n = fwrite(buf, 1, last - buf, sinkfp);
 234     else if (ctl->smtp_socket != -1)
 235         n = SockWrite(ctl->smtp_socket, buf, last - buf);
 236
 237     phase = oldphase;
 238
 239     return(n);
 240 }
 241
 242 static void sanitize(char *s)
 243 /* replace unsafe shellchars by an _ */
 244 {
 245     const static char *ok_chars = " 1234567890!@%-_=+:,./abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 246     char *cp;
 247
 248     for (cp = s; *(cp += strspn(cp, ok_chars)); /* NO INCREMENT */)
 249         *cp = '_';
 250 }
 251
 252 static int send_bouncemail(struct msgblk *msg,
 253                            char *message, int nerrors, char *errors[])
 254 /* bounce back an error report a la RFC 1892 */
 255 {
 256     char daemon_name[MSGBUFSIZE] = "FETCHMAIL-DAEMON@";
 257     int i, sock;
 258
 259     /* don't bounce  in reply to undeliverable bounces */
 260     if (!msg->return_path[0] || strcmp(msg->return_path, "<>") == 0)
 261         return(FALSE);
 262
 263     SMTP_setmode(SMTP_MODE);
 264
 265     strcat(daemon_name, fetchmailhost);
 266
 267     /* we need only SMTP for this purpose */
 268     if ((sock = SockOpen("localhost", SMTP_PORT, NULL, NULL)) == -1
 269                 || SMTP_ok(sock) != SM_OK
 270                 || SMTP_helo(sock, "localhost") != SM_OK
 271                 || SMTP_from(sock, daemon_name, (char *)NULL) != SM_OK
 272                 || SMTP_rcpt(sock, msg->return_path) != SM_OK
 273                 || SMTP_data(sock) != SM_OK)
 274         return(FALSE);
 275
 276     error(0, 0, "SMTP: (bounce-message body)");
 277
 278     /* bouncemail headers */
 279     SockPrintf(sock, "Return-Path: <>");
 280     SockPrintf(sock, "From: FETCHMAIL-DAEMON@%s\r\n", fetchmailhost);
 281     SockPrintf(sock, "To: %s\n", msg->return_path);
 282     SockPrintf(sock, "MIME-Version: 1.0\r\n");
 283     SockPrintf(sock, "Content-Type: multipart/report report-type=text/plain boundary=\"om-mani-padme-hum\"\r\n");
 284     SockPrintf(sock, "Content-Transfer-Encoding: 7bit\r\n");
 285     SockPrintf(sock, "\r\n");
 286
 287     /* RFC1892 part 1 -- human-readable message */
 288     SockPrintf(sock, "-- om-mani-padme-hum\r\n");
 289     SockPrintf(sock,"Content-Type: text/plain\r\n");
 290     SockPrintf(sock, "\r\n");
 291     SockWrite(sock, message, strlen(message));
 292
 293     /* RFC1892 part 2 -- machine-readable responses */
 294     SockPrintf(sock, "-- om-mani-padme-hum\r\n");
 295     SockPrintf(sock,"Content-Type: message/delivery-status\r\n");
 296     SockPrintf(sock, "\r\n");
 297     for (i = 0; i < nerrors; i++)
 298         SockPrintf(sock, errors[i]);
 299
 300     /* RFC1892 part 3 -- headers of undelivered message */
 301     SockPrintf(sock, "-- om-mani-padme-hum\r\n");
 302     SockPrintf(sock, "Content-Type: text/rfc822-headers\r\n");
 303     SockPrintf(sock, "\r\n");
 304     SockWrite(sock, msg->headers, strlen(msg->headers));
 305     SockPrintf(sock, "-- om-mani-padme-hum --\r\n");
 306
 307     if (SMTP_eom(sock) != SM_OK || SMTP_quit(sock))
 308         return(FALSE);
 309
 310     SockClose(sock);
 311
 312     return(TRUE);
 313 }
 314
 315 int open_sink(struct query *ctl, struct msgblk *msg,
 316               int *good_addresses, int *bad_addresses)
 317 /* set up sinkfp to be an input sink we can ship a message to */
 318 {
 319     struct      idlist *idp;
 320
 321     *bad_addresses = *good_addresses = 0;
 322
 323     if (ctl->bsmtp)             /* dump to a BSMTP batch file */
 324     {
 325         if (strcmp(ctl->bsmtp, "-") == 0)
 326             sinkfp = stdout;
 327         else
 328             sinkfp = fopen(ctl->bsmtp, "a");
 329
 330         /* see the ap computation under the SMTP branch */
 331         fprintf(sinkfp,
 332                 "MAIL FROM: %s", (msg->return_path[0]) ? msg->return_path : user);
 333
 334         if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 335             fputs(" BODY=8BITMIME", sinkfp);
 336         else if (ctl->mimemsg & MSG_IS_7BIT)
 337             fputs(" BODY=7BIT", sinkfp);
 338
 339         fprintf(sinkfp, " SIZE=%ld\r\n", msg->reallen);
 340
 341         /*
 342          * RFC 1123 requires that the domain name part of the
 343          * RCPT TO address be "canonicalized", that is a FQDN
 344          * or MX but not a CNAME.  Some listeners (like exim)
 345          * enforce this.  Now that we have the actual hostname,
 346          * compute what we should canonicalize with.
 347          */
 348         ctl->destaddr = ctl->smtpaddress ? ctl->smtpaddress : "localhost";
 349
 350         *bad_addresses = 0;
 351         for (idp = msg->recipients; idp; idp = idp->next)
 352             if (idp->val.status.mark == XMIT_ACCEPT)
 353             {
 354                 if (strchr(idp->id, '@'))
 355                     fprintf(sinkfp,
 356                                 "RCPT TO: %s\r\n", idp->id);
 357                 else
 358                     fprintf(sinkfp,
 359                                 "RCPT TO: %s@%s\r\n", idp->id, ctl->destaddr);
 360                 *good_addresses = 0;
 361             }
 362
 363         fputs("DATA\r\n", sinkfp);
 364
 365         if (ferror(sinkfp))
 366         {
 367             error(0, -1, _("BSMTP file open or preamble write failed"));
 368             return(PS_BSMTP);
 369         }
 370     }
 371     else if (ctl->mda)          /* we have a declared MDA */
 372     {
 373         int     length = 0, fromlen = 0, nameslen = 0;
 374         char    *names = NULL, *before, *after, *from = NULL;
 375
 376         ctl->destaddr = "localhost";
 377
 378         for (idp = msg->recipients; idp; idp = idp->next)
 379             if (idp->val.status.mark == XMIT_ACCEPT)
 380                 (*good_addresses)++;
 381
 382         length = strlen(ctl->mda);
 383         before = xstrdup(ctl->mda);
 384
 385         /* get user addresses for %T (or %s for backward compatibility) */
 386         if (strstr(before, "%s") || strstr(before, "%T"))
 387         {
 388             /*
 389              * We go through this in order to be able to handle very
 390              * long lists of users and (re)implement %s.
 391              */
 392             nameslen = 0;
 393             for (idp = msg->recipients; idp; idp = idp->next)
 394                 if ((idp->val.status.mark == XMIT_ACCEPT))
 395                     nameslen += (strlen(idp->id) + 1);  /* string + ' ' */
 396             if ((*good_addresses == 0))
 397                 nameslen = strlen(run.postmaster);
 398
 399             names = (char *)xmalloc(nameslen + 1);      /* account for '\0' */
 400             if (*good_addresses == 0)
 401                 strcpy(names, run.postmaster);
 402             else
 403             {
 404                 names[0] = '\0';
 405                 for (idp = msg->recipients; idp; idp = idp->next)
 406                     if (idp->val.status.mark == XMIT_ACCEPT)
 407                     {
 408                         strcat(names, idp->id);
 409                         strcat(names, " ");
 410                     }
 411                 names[--nameslen] = '\0';       /* chop trailing space */
 412             }
 413
 414             /* sanitize names in order to contain only harmless shell chars */
 415             sanitize(names);
 416         }
 417
 418         /* get From address for %F */
 419         if (strstr(before, "%F"))
 420         {
 421             from = xstrdup(msg->return_path);
 422
 423             /* sanitize from in order to contain *only* harmless shell chars */
 424             sanitize(from);
 425
 426             fromlen = strlen(from);
 427         }
 428
 429         /* do we have to build an mda string? */
 430         if (names || from)
 431         {
 432             char        *sp, *dp;
 433
 434             /* find length of resulting mda string */
 435             sp = before;
 436             while ((sp = strstr(sp, "%s"))) {
 437                 length += nameslen - 2; /* subtract %s */
 438                 sp += 2;
 439             }
 440             sp = before;
 441             while ((sp = strstr(sp, "%T"))) {
 442                 length += nameslen - 2; /* subtract %T */
 443                 sp += 2;
 444             }
 445             sp = before;
 446             while ((sp = strstr(sp, "%F"))) {
 447                 length += fromlen - 2;  /* subtract %F */
 448                 sp += 2;
 449             }
 450
 451             after = xmalloc(length + 1);
 452
 453             /* copy mda source string to after, while expanding %[sTF] */
 454             for (dp = after, sp = before; (*dp = *sp); dp++, sp++) {
 455                 if (sp[0] != '%')       continue;
 456
 457                 /* need to expand? BTW, no here overflow, because in
 458                 ** the worst case (end of string) sp[1] == '\0' */
 459                 if (sp[1] == 's' || sp[1] == 'T') {
 460                     strcpy(dp, names);
 461                     dp += nameslen;
 462                     sp++;       /* position sp over [sT] */
 463                     dp--;       /* adjust dp */
 464                 } else if (sp[1] == 'F') {
 465                     strcpy(dp, from);
 466                     dp += fromlen;
 467                     sp++;       /* position sp over F */
 468                     dp--;       /* adjust dp */
 469                 }
 470             }
 471
 472             if (names) {
 473                 free(names);
 474                 names = NULL;
 475             }
 476             if (from) {
 477                 free(from);
 478                 from = NULL;
 479             }
 480
 481             free(before);
 482
 483             before = after;
 484         }
 485
 486
 487         if (outlevel >= O_DEBUG)
 488             error(0, 0, _("about to deliver with: %s"), before);
 489
 490 #ifdef HAVE_SETEUID
 491         /*
 492          * Arrange to run with user's permissions if we're root.
 493          * This will initialize the ownership of any files the
 494          * MDA creates properly.  (The seteuid call is available
 495          * under all BSDs and Linux)
 496          */
 497         seteuid(ctl->uid);
 498 #endif /* HAVE_SETEUID */
 499
 500         sinkfp = popen(before, "w");
 501         free(before);
 502         before = NULL;
 503
 504 #ifdef HAVE_SETEUID
 505         /* this will fail quietly if we didn't start as root */
 506         seteuid(0);
 507 #endif /* HAVE_SETEUID */
 508
 509         if (!sinkfp)
 510         {
 511             error(0, 0, _("MDA open failed"));
 512             return(PS_IOERR);
 513         }
 514
 515         sigchld = signal(SIGCHLD, SIG_DFL);
 516     }
 517     else /* forward to an SMTP or LMTP listener */
 518     {
 519         const char      *ap;
 520         char    options[MSGBUFSIZE], addr[128];
 521
 522         /* build a connection to the SMTP listener */
 523         if ((smtp_open(ctl) == -1))
 524         {
 525             error(0, errno, _("%cMTP connect to %s failed"),
 526                   ctl->listener,
 527                   ctl->smtphost ? ctl->smtphost : "localhost");
 528             return(PS_SMTP);
 529         }
 530
 531         /*
 532          * Compute ESMTP options.
 533          */
 534         options[0] = '\0';
 535         if (ctl->server.esmtp_options & ESMTP_8BITMIME) {
 536              if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 537                 strcpy(options, " BODY=8BITMIME");
 538              else if (ctl->mimemsg & MSG_IS_7BIT)
 539                 strcpy(options, " BODY=7BIT");
 540         }
 541
 542         if ((ctl->server.esmtp_options & ESMTP_SIZE) && msg->reallen > 0)
 543             sprintf(options + strlen(options), " SIZE=%ld", msg->reallen);
 544
 545         /*
 546          * Try to get the SMTP listener to take the Return-Path
 547          * address as MAIL FROM .  If it won't, fall back on the
 548          * calling-user ID.  This won't affect replies, which use the
 549          * header From address anyway.
 550          *
 551          * RFC 1123 requires that the domain name part of the
 552          * MAIL FROM address be "canonicalized", that is a
 553          * FQDN or MX but not a CNAME.  We'll assume the From
 554          * header is already in this form here (it certainly
 555          * is if rewrite is on).  RFC 1123 is silent on whether
 556          * a nonexistent hostname part is considered canonical.
 557          *
 558          * This is a potential problem if the MTAs further upstream
 559          * didn't pass canonicalized From/Return-Path lines, *and* the
 560          * local SMTP listener insists on them.
 561          */
 562         ap = (msg->return_path[0]) ? msg->return_path : user;
 563         if (SMTP_from(ctl->smtp_socket, ap, options) != SM_OK)
 564         {
 565             int smtperr = atoi(smtp_response);
 566             char *responses[1];
 567
 568             responses[0] = smtp_response;
 569
 570             if (str_find(&ctl->antispam, smtperr))
 571             {
 572                 /*
 573                  * SMTP listener explicitly refuses to deliver mail
 574                  * coming from this address, probably due to an
 575                  * anti-spam domain exclusion.  Respect this.  Don't
 576                  * try to ship the message, and don't prevent it from
 577                  * being deleted.  Typical values:
 578                  *
 579                  * 501 = exim's old antispam response
 580                  * 550 = exim's new antispam response (temporary)
 581                  * 553 = sendmail 8.8.7's generic REJECT
 582                  * 571 = sendmail's "unsolicited email refused"
 583                  *
 584                  */
 585                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 586                 send_bouncemail(msg,
 587                                 _("We do not accept mail from you.)\r\n"),
 588                                 1, responses);
 589                 return(PS_REFUSED);
 590             }
 591
 592             /*
 593              * Suppress error message only if the response specifically
 594              * meant `excluded for policy reasons'.  We *should* see
 595              * an error when the return code is less specific.
 596              */
 597             if (smtperr >= 400)
 598                 error(0, -1, _("%cMTP error: %s"),
 599                       ctl->listener,
 600                       smtp_response);
 601
 602             switch (smtperr)
 603             {
 604             case 452: /* insufficient system storage */
 605                 /*
 606                  * Temporary out-of-queue-space condition on the
 607                  * ESMTP server.  Don't try to ship the message,
 608                  * and suppress deletion so it can be retried on
 609                  * a future retrieval cycle.
 610                  *
 611                  * Bouncemail *might* be appropriate here as a delay
 612                  * notification.  But it's not really necessary because
 613                  * this is not an actual failure, we're very likely to be
 614                  * able to recover on the next cycle.
 615                  */
 616                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 617                 return(PS_TRANSIENT);
 618
 619             case 552: /* message exceeds fixed maximum message size */
 620                 /*
 621                  * Permanent no-go condition on the
 622                  * ESMTP server.  Don't try to ship the message,
 623                  * and allow it to be deleted.
 624                  */
 625                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 626                 send_bouncemail(msg,
 627                                 _("This message was too large.\r\n"),
 628                                 1, responses);
 629                 return(PS_REFUSED);
 630
 631             case 553: /* invalid sending domain */
 632                 /*
 633                  * These latter days 553 usually means a spammer is trying to
 634                  * cover his tracks.
 635                  */
 636                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 637                 send_bouncemail(msg,
 638                                 _("Invalid address.\r\n"),
 639                                 1, responses);
 640                 return(PS_REFUSED);
 641
 642             default:    /* retry with postmaster's address */
 643                 if (SMTP_from(ctl->smtp_socket,run.postmaster,options)!=SM_OK)
 644                 {
 645                     error(0, -1, _("%cMTP error: %s"),
 646                           ctl->listener,
 647                           smtp_response);
 648                     return(PS_SMTP);    /* should never happen */
 649                 }
 650             }
 651         }
 652
 653         /*
 654          * Now list the recipient addressees
 655          */
 656         for (idp = msg->recipients; idp; idp = idp->next)
 657             if (idp->val.status.mark == XMIT_ACCEPT)
 658             {
 659                 if (strchr(idp->id, '@'))
 660                     strcpy(addr, idp->id);
 661                 else
 662 #ifdef HAVE_SNPRINTF
 663                     snprintf(addr, sizeof(addr)-1, "%s@%s", idp->id, ctl->destaddr);
 664 #else
 665                     sprintf(addr, "%s@%s", idp->id, ctl->destaddr);
 666 #endif /* HAVE_SNPRINTF */
 667
 668                 if (SMTP_rcpt(ctl->smtp_socket, addr) == SM_OK)
 669                     (*good_addresses)++;
 670                 else
 671                 {
 672                     (*bad_addresses)++;
 673                     idp->val.status.mark = XMIT_ANTISPAM;
 674                     error(0, 0,
 675                           _("%cMTP listener doesn't like recipient address `%s'"),
 676                           ctl->listener, addr);
 677                 }
 678             }
 679         if (!(*good_addresses))
 680         {
 681 #ifdef HAVE_SNPRINTF
 682             snprintf(addr, sizeof(addr)-1, "%s@%s", run.postmaster, ctl->destaddr);
 683 #else
 684             sprintf(addr, "%s@%s", run.postmaster, ctl->destaddr);
 685 #endif /* HAVE_SNPRINTF */
 686
 687             if (SMTP_rcpt(ctl->smtp_socket, addr) != SM_OK)
 688             {
 689                 error(0, 0, _("can't even send to %s!"), run.postmaster);
 690                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 691                 return(PS_SMTP);
 692             }
 693         }
 694
 695         /* tell it we're ready to send data */
 696         SMTP_data(ctl->smtp_socket);
 697     }
 698
 699     /*
 700      * We need to stash this away in order to know how many
 701      * response lines to expect after the LMTP end-of-message.
 702      */
 703     msg->lmtp_responses = *good_addresses;
 704
 705     return(PS_SUCCESS);
 706 }
 707
 708 void release_sink(struct query *ctl)
 709 /* release the per-message output sink, whether it's a pipe or SMTP socket */
 710 {
 711     if (ctl->bsmtp)
 712         fclose(sinkfp);
 713     else if (ctl->mda)
 714     {
 715         if (sinkfp)
 716         {
 717             pclose(sinkfp);
 718             sinkfp = (FILE *)NULL;
 719         }
 720         signal(SIGCHLD, sigchld);
 721     }
 722 }
 723
 724 int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 725 /* perform end-of-message actions on the current output sink */
 726 {
 727     if (ctl->mda)
 728     {
 729         int rc;
 730
 731         /* close the delivery pipe, we'll reopen before next message */
 732         if (sinkfp)
 733         {
 734             rc = pclose(sinkfp);
 735             sinkfp = (FILE *)NULL;
 736         }
 737         else
 738             rc = 0;
 739         signal(SIGCHLD, sigchld);
 740         if (rc)
 741         {
 742             error(0, -1, _("MDA exited abnormally or returned nonzero status"));
 743             return(FALSE);
 744         }
 745     }
 746     else if (ctl->bsmtp)
 747     {
 748         /* implicit disk-full check here... */
 749         fputs("..\r\n", sinkfp);
 750         if (strcmp(ctl->bsmtp, "-"))
 751             fclose(sinkfp);
 752         if (ferror(sinkfp))
 753         {
 754             error(0, -1, _("Message termination or close of BSMTP file failed"));
 755             return(FALSE);
 756         }
 757     }
 758     else if (forward)
 759     {
 760         /* write message terminator */
 761         if (SMTP_eom(ctl->smtp_socket) != SM_OK)
 762         {
 763             error(0, -1, _("SMTP listener refused delivery"));
 764             return(FALSE);
 765         }
 766
 767         /*
 768          * If this is an SMTP connection, SMTP_eom() ate the response.
 769          * But could be this is an LMTP connection, in which case we have to
 770          * interpret either (a) a single 503 response meaning there
 771          * were no successful RCPT TOs, or (b) a variable number of
 772          * responses, one for each successful RCPT TO.  We need to send
 773          * bouncemail on each failed response and then return TRUE anyway,
 774          * otherwise the message will get left in the queue and resent
 775          * to people who got it the first time.
 776          */
 777         if (ctl->listener == LMTP_MODE)
 778             if (msg->lmtp_responses == 0)
 779             {
 780                 SMTP_ok(ctl->smtp_socket);
 781
 782                 /*
 783                  * According to RFC2033, 503 is the only legal response
 784                  * if no RCPT TO commands succeeded.  No error recovery
 785                  * is really possible here, as we have no idea what
 786                  * insane thing the listener might be doing if it doesn't
 787                  * comply.
 788                  */
 789                 if (atoi(smtp_response) == 503)
 790                     error(0, -1, _("LMTP delivery error on EOM"));
 791                 else
 792                     error(0, -1,
 793                           _("Unexpected non-503 response to LMTP EOM: %s"),
 794                           smtp_response);
 795
 796                 /*
 797                  * It's not completely clear what to do here.  We choose to
 798                  * interpret delivery failure here as a transient error,
 799                  * the same way SMTP delivery failure is handled.  If we're
 800                  * wrong, an undead message will get stuck in the queue.
 801                  */
 802                 return(FALSE);
 803             }
 804             else
 805             {
 806                 int     i, errors;
 807                 char    **responses;
 808
 809                 /* eat the RFC2033-required responses, saving errors */
 810                 xalloca(responses, char **, sizeof(char *) * msg->lmtp_responses);
 811                 for (errors = i = 0; i < msg->lmtp_responses; i++)
 812                 {
 813                     if (SMTP_ok(ctl->smtp_socket) == SM_OK)
 814                         responses[i] = (char *)NULL;
 815                     else
 816                     {
 817                         xalloca(responses[errors],
 818                                 char *,
 819                                 strlen(smtp_response)+1);
 820                         strcpy(responses[errors], smtp_response);
 821                         errors++;
 822                     }
 823                 }
 824
 825                 if (errors == 0)
 826                     return(TRUE);       /* all deliveries succeeded */
 827                 else
 828                 {
 829                     /*
 830                      * One or more deliveries failed.
 831                      * If we can bounce a failures list back to the sender,
 832                      * return TRUE, deleting the message from the server so
 833                      * it won't be re-forwarded on subsequent poll
 834                      * cycles.
 835                      */
 836                     return(send_bouncemail(msg,
 837                                    "LSMTP partial delivery failure.\r\n",
 838                                    errors, responses));
 839                 }
 840             }
 841     }
 842
 843     return(TRUE);
 844 }
 845
 846 int open_warning_by_mail(struct query *ctl, struct msgblk *msg)
 847 /* set up output sink for a mailed warning to calling user */
 848 {
 849     int good, bad;
 850
 851     /*
 852      * Dispatching warning email is a little complicated.  The problem is
 853      * that we have to deal with three distinct cases:
 854      *
 855      * 1. Single-drop running from user account.  Warning mail should
 856      * go to the local name for which we're collecting (coincides
 857      * with calling user).
 858      *
 859      * 2. Single-drop running from root or other privileged ID, with rc
 860      * file generated on the fly (Ken Estes's weird setup...)  Mail
 861      * should go to the local name for which we're collecting (does not
 862      * coincide with calling user).
 863      *
 864      * 3. Multidrop.  Mail must go to postmaster.  We leave the recipients
 865      * member null so this message will fall through to run.postmaster.
 866      *
 867      * The zero in the reallen element means we won't pass a SIZE
 868      * option to ESMTP; the message length would be more trouble than
 869      * it's worth to compute.
 870      */
 871     struct msgblk reply = {NULL, NULL, "FETCHMAIL-DAEMON", 0};
 872
 873     if (!MULTIDROP(ctl))                /* send to calling user */
 874     {
 875         int status;
 876
 877         save_str(&reply.recipients, ctl->localnames->id, XMIT_ACCEPT);
 878         status = open_sink(ctl, &reply, &good, &bad);
 879         free_str_list(&reply.recipients);
 880         return(status);
 881     }
 882     else                                /* send to postmaster  */
 883         return(open_sink(ctl, &reply, &good, &bad));
 884 }
 885
 886 #if defined(HAVE_STDARG_H)
 887 void stuff_warning(struct query *ctl, const char *fmt, ... )
 888 #else
 889 void stuff_warning(struct query *ctl, fmt, va_alist)
 890 struct query *ctl;
 891 const char *fmt;        /* printf-style format */
 892 va_dcl
 893 #endif
 894 /* format and ship a warning message line by mail */
 895 {
 896     char        buf[POPBUFSIZE];
 897     va_list ap;
 898
 899     /*
 900      * stuffline() requires its input to be writeable (for CR stripping),
 901      * so we needed to copy the message to a writeable buffer anyway in
 902      * case it was a string constant.  We make a virtue of that necessity
 903      * here by supporting stdargs/varargs.
 904      */
 905 #if defined(HAVE_STDARG_H)
 906     va_start(ap, fmt) ;
 907 #else
 908     va_start(ap);
 909 #endif
 910 #ifdef HAVE_VSNPRINTF
 911     vsnprintf(buf, sizeof(buf), fmt, ap);
 912 #else
 913     vsprintf(buf, fmt, ap);
 914 #endif
 915     va_end(ap);
 916
 917     strcat(buf, "\r\n");
 918
 919     stuffline(ctl, buf);
 920 }
 921
 922 void close_warning_by_mail(struct query *ctl, struct msgblk *msg)
 923 /* sign and send mailed warnings */
 924 {
 925     stuff_warning(ctl, "--\r\n\t\t\t\tThe Fetchmail Daemon\r\n");
 926     close_sink(ctl, msg, TRUE);
 927 }
 928
 929 /* sink.c ends here */