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[18 + HOSTLEN] = "FETCHMAIL-DAEMON@";
 257     char boundary[BUFSIZ];
 258     int i, sock;
 259
 260     /* don't bounce  in reply to undeliverable bounces */
 261     if (!msg->return_path[0] || strcmp(msg->return_path, "<>") == 0)
 262         return(FALSE);
 263
 264     SMTP_setmode(SMTP_MODE);
 265
 266     strcat(daemon_name, fetchmailhost);
 267
 268     /* we need only SMTP for this purpose */
 269     if ((sock = SockOpen("localhost", SMTP_PORT, NULL, NULL)) == -1
 270                 || SMTP_ok(sock) != SM_OK
 271                 || SMTP_helo(sock, "localhost") != SM_OK
 272                 || SMTP_from(sock, daemon_name, (char *)NULL) != SM_OK
 273                 || SMTP_rcpt(sock, msg->return_path) != SM_OK
 274                 || SMTP_data(sock) != SM_OK)
 275         return(FALSE);
 276
 277     sprintf(boundary,
 278             "om-mani-padme-hum-%d-%d-%ld",
 279             getpid(), getppid(), time((time_t *)NULL));
 280
 281     if (outlevel >= O_VERBOSE)
 282         error(0, 0, "SMTP: (bounce-message body)");
 283
 284     /* bouncemail headers */
 285     SockPrintf(sock, "Return-Path: <>");
 286     SockPrintf(sock, "From: FETCHMAIL-DAEMON@%s\r\n", fetchmailhost);
 287     SockPrintf(sock, "To: %s\n", msg->return_path);
 288     SockPrintf(sock, "MIME-Version: 1.0\r\n");
 289     SockPrintf(sock, "Content-Type: multipart/report; report-type=delivery-status boundary=\"%s\"\r\n", boundary);
 290     SockPrintf(sock, "\r\n");
 291     SockPrintf(sock, "Content-Transfer-Encoding: 7bit\r\n");
 292     SockPrintf(sock, "\r\n");
 293
 294     /* RFC1892 part 1 -- human-readable message */
 295     SockPrintf(sock, "--%s\r\n", boundary);
 296     SockPrintf(sock,"Content-Type: text/plain\r\n");
 297     SockPrintf(sock, "\r\n");
 298     SockWrite(sock, message, strlen(message));
 299     SockPrintf(sock, "\r\n");
 300
 301     if (nerrors)
 302     {
 303         /* RFC1892 part 2 -- machine-readable responses */
 304         SockPrintf(sock, "--%s\r\n", boundary);
 305         SockPrintf(sock,"Content-Type: message/delivery-status\r\n");
 306         SockPrintf(sock, "\r\n");
 307         for (i = 0; i < nerrors; i++)
 308             SockPrintf(sock, errors[i]);
 309         SockPrintf(sock, "\r\n");
 310     }
 311
 312     /* RFC1892 part 3 -- headers of undelivered message */
 313     SockPrintf(sock, "--%s\r\n", boundary);
 314     SockPrintf(sock, "Content-Type: text/rfc822-headers\r\n");
 315     SockPrintf(sock, "\r\n");
 316     SockWrite(sock, msg->headers, strlen(msg->headers));
 317     SockPrintf(sock, "\r\n");
 318     SockPrintf(sock, "--%s--\r\n", boundary);
 319
 320     if (SMTP_eom(sock) != SM_OK || SMTP_quit(sock))
 321         return(FALSE);
 322
 323     SockClose(sock);
 324
 325     return(TRUE);
 326 }
 327
 328 int open_sink(struct query *ctl, struct msgblk *msg,
 329               int *good_addresses, int *bad_addresses)
 330 /* set up sinkfp to be an input sink we can ship a message to */
 331 {
 332     struct      idlist *idp;
 333
 334     *bad_addresses = *good_addresses = 0;
 335
 336     if (ctl->bsmtp)             /* dump to a BSMTP batch file */
 337     {
 338         if (strcmp(ctl->bsmtp, "-") == 0)
 339             sinkfp = stdout;
 340         else
 341             sinkfp = fopen(ctl->bsmtp, "a");
 342
 343         /* see the ap computation under the SMTP branch */
 344         fprintf(sinkfp,
 345                 "MAIL FROM: %s", (msg->return_path[0]) ? msg->return_path : user);
 346
 347         if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 348             fputs(" BODY=8BITMIME", sinkfp);
 349         else if (ctl->mimemsg & MSG_IS_7BIT)
 350             fputs(" BODY=7BIT", sinkfp);
 351
 352         fprintf(sinkfp, " SIZE=%ld\r\n", msg->reallen);
 353
 354         /*
 355          * RFC 1123 requires that the domain name part of the
 356          * RCPT TO address be "canonicalized", that is a FQDN
 357          * or MX but not a CNAME.  Some listeners (like exim)
 358          * enforce this.  Now that we have the actual hostname,
 359          * compute what we should canonicalize with.
 360          */
 361         ctl->destaddr = ctl->smtpaddress ? ctl->smtpaddress : "localhost";
 362
 363         *bad_addresses = 0;
 364         for (idp = msg->recipients; idp; idp = idp->next)
 365             if (idp->val.status.mark == XMIT_ACCEPT)
 366             {
 367                 if (strchr(idp->id, '@'))
 368                     fprintf(sinkfp,
 369                                 "RCPT TO: %s\r\n", idp->id);
 370                 else
 371                     fprintf(sinkfp,
 372                                 "RCPT TO: %s@%s\r\n", idp->id, ctl->destaddr);
 373                 *good_addresses = 0;
 374             }
 375
 376         fputs("DATA\r\n", sinkfp);
 377
 378         if (ferror(sinkfp))
 379         {
 380             error(0, -1, _("BSMTP file open or preamble write failed"));
 381             return(PS_BSMTP);
 382         }
 383     }
 384     else if (ctl->mda)          /* we have a declared MDA */
 385     {
 386         int     length = 0, fromlen = 0, nameslen = 0;
 387         char    *names = NULL, *before, *after, *from = NULL;
 388
 389         ctl->destaddr = "localhost";
 390
 391         for (idp = msg->recipients; idp; idp = idp->next)
 392             if (idp->val.status.mark == XMIT_ACCEPT)
 393                 (*good_addresses)++;
 394
 395         length = strlen(ctl->mda);
 396         before = xstrdup(ctl->mda);
 397
 398         /* get user addresses for %T (or %s for backward compatibility) */
 399         if (strstr(before, "%s") || strstr(before, "%T"))
 400         {
 401             /*
 402              * We go through this in order to be able to handle very
 403              * long lists of users and (re)implement %s.
 404              */
 405             nameslen = 0;
 406             for (idp = msg->recipients; idp; idp = idp->next)
 407                 if ((idp->val.status.mark == XMIT_ACCEPT))
 408                     nameslen += (strlen(idp->id) + 1);  /* string + ' ' */
 409             if ((*good_addresses == 0))
 410                 nameslen = strlen(run.postmaster);
 411
 412             names = (char *)xmalloc(nameslen + 1);      /* account for '\0' */
 413             if (*good_addresses == 0)
 414                 strcpy(names, run.postmaster);
 415             else
 416             {
 417                 names[0] = '\0';
 418                 for (idp = msg->recipients; idp; idp = idp->next)
 419                     if (idp->val.status.mark == XMIT_ACCEPT)
 420                     {
 421                         strcat(names, idp->id);
 422                         strcat(names, " ");
 423                     }
 424                 names[--nameslen] = '\0';       /* chop trailing space */
 425             }
 426
 427             /* sanitize names in order to contain only harmless shell chars */
 428             sanitize(names);
 429         }
 430
 431         /* get From address for %F */
 432         if (strstr(before, "%F"))
 433         {
 434             from = xstrdup(msg->return_path);
 435
 436             /* sanitize from in order to contain *only* harmless shell chars */
 437             sanitize(from);
 438
 439             fromlen = strlen(from);
 440         }
 441
 442         /* do we have to build an mda string? */
 443         if (names || from)
 444         {
 445             char        *sp, *dp;
 446
 447             /* find length of resulting mda string */
 448             sp = before;
 449             while ((sp = strstr(sp, "%s"))) {
 450                 length += nameslen - 2; /* subtract %s */
 451                 sp += 2;
 452             }
 453             sp = before;
 454             while ((sp = strstr(sp, "%T"))) {
 455                 length += nameslen - 2; /* subtract %T */
 456                 sp += 2;
 457             }
 458             sp = before;
 459             while ((sp = strstr(sp, "%F"))) {
 460                 length += fromlen - 2;  /* subtract %F */
 461                 sp += 2;
 462             }
 463
 464             after = xmalloc(length + 1);
 465
 466             /* copy mda source string to after, while expanding %[sTF] */
 467             for (dp = after, sp = before; (*dp = *sp); dp++, sp++) {
 468                 if (sp[0] != '%')       continue;
 469
 470                 /* need to expand? BTW, no here overflow, because in
 471                 ** the worst case (end of string) sp[1] == '\0' */
 472                 if (sp[1] == 's' || sp[1] == 'T') {
 473                     strcpy(dp, names);
 474                     dp += nameslen;
 475                     sp++;       /* position sp over [sT] */
 476                     dp--;       /* adjust dp */
 477                 } else if (sp[1] == 'F') {
 478                     strcpy(dp, from);
 479                     dp += fromlen;
 480                     sp++;       /* position sp over F */
 481                     dp--;       /* adjust dp */
 482                 }
 483             }
 484
 485             if (names) {
 486                 free(names);
 487                 names = NULL;
 488             }
 489             if (from) {
 490                 free(from);
 491                 from = NULL;
 492             }
 493
 494             free(before);
 495
 496             before = after;
 497         }
 498
 499
 500         if (outlevel >= O_DEBUG)
 501             error(0, 0, _("about to deliver with: %s"), before);
 502
 503 #ifdef HAVE_SETEUID
 504         /*
 505          * Arrange to run with user's permissions if we're root.
 506          * This will initialize the ownership of any files the
 507          * MDA creates properly.  (The seteuid call is available
 508          * under all BSDs and Linux)
 509          */
 510         seteuid(ctl->uid);
 511 #endif /* HAVE_SETEUID */
 512
 513         sinkfp = popen(before, "w");
 514         free(before);
 515         before = NULL;
 516
 517 #ifdef HAVE_SETEUID
 518         /* this will fail quietly if we didn't start as root */
 519         seteuid(0);
 520 #endif /* HAVE_SETEUID */
 521
 522         if (!sinkfp)
 523         {
 524             error(0, 0, _("MDA open failed"));
 525             return(PS_IOERR);
 526         }
 527
 528         sigchld = signal(SIGCHLD, SIG_DFL);
 529     }
 530     else /* forward to an SMTP or LMTP listener */
 531     {
 532         const char      *ap;
 533         char    options[MSGBUFSIZE], addr[128];
 534
 535         /* build a connection to the SMTP listener */
 536         if ((smtp_open(ctl) == -1))
 537         {
 538             error(0, errno, _("%cMTP connect to %s failed"),
 539                   ctl->listener,
 540                   ctl->smtphost ? ctl->smtphost : "localhost");
 541             return(PS_SMTP);
 542         }
 543
 544         /*
 545          * Compute ESMTP options.
 546          */
 547         options[0] = '\0';
 548         if (ctl->server.esmtp_options & ESMTP_8BITMIME) {
 549              if (ctl->pass8bits || (ctl->mimemsg & MSG_IS_8BIT))
 550                 strcpy(options, " BODY=8BITMIME");
 551              else if (ctl->mimemsg & MSG_IS_7BIT)
 552                 strcpy(options, " BODY=7BIT");
 553         }
 554
 555         if ((ctl->server.esmtp_options & ESMTP_SIZE) && msg->reallen > 0)
 556             sprintf(options + strlen(options), " SIZE=%ld", msg->reallen);
 557
 558         /*
 559          * Try to get the SMTP listener to take the Return-Path
 560          * address as MAIL FROM .  If it won't, fall back on the
 561          * calling-user ID.  This won't affect replies, which use the
 562          * header From address anyway.
 563          *
 564          * RFC 1123 requires that the domain name part of the
 565          * MAIL FROM address be "canonicalized", that is a
 566          * FQDN or MX but not a CNAME.  We'll assume the From
 567          * header is already in this form here (it certainly
 568          * is if rewrite is on).  RFC 1123 is silent on whether
 569          * a nonexistent hostname part is considered canonical.
 570          *
 571          * This is a potential problem if the MTAs further upstream
 572          * didn't pass canonicalized From/Return-Path lines, *and* the
 573          * local SMTP listener insists on them.
 574          *
 575          * Note: send_bouncemail message strings are not made subject
 576          * to gettext translation because (a) they're going to be
 577          * embedded in a text/plain 7bit part, and (b) they're
 578          * going to be associated with listener error-response
 579          * messages, which are probably in English (none of the
 580          * MTAs I know about are internationalized).
 581          */
 582         ap = (msg->return_path[0]) ? msg->return_path : user;
 583         if (SMTP_from(ctl->smtp_socket, ap, options) != SM_OK)
 584         {
 585             int smtperr = atoi(smtp_response);
 586             char *responses[1];
 587
 588             responses[0] = smtp_response;
 589
 590             /* required by RFC1870; sets us up to be able to send bouncemail */
 591             SMTP_rset(ctl->smtp_socket);
 592
 593             if (str_find(&ctl->antispam, smtperr))
 594             {
 595                 /*
 596                  * SMTP listener explicitly refuses to deliver mail
 597                  * coming from this address, probably due to an
 598                  * anti-spam domain exclusion.  Respect this.  Don't
 599                  * try to ship the message, and don't prevent it from
 600                  * being deleted.  Typical values:
 601                  *
 602                  * 501 = exim's old antispam response
 603                  * 550 = exim's new antispam response (temporary)
 604                  * 553 = sendmail 8.8.7's generic REJECT
 605                  * 571 = sendmail's "unsolicited email refused"
 606                  *
 607                  */
 608                 send_bouncemail(msg,
 609                                 "We do not accept mail from you.\r\n",
 610                                 1, responses);
 611                 return(PS_REFUSED);
 612             }
 613
 614             /*
 615              * Suppress error message only if the response specifically
 616              * meant `excluded for policy reasons'.  We *should* see
 617              * an error when the return code is less specific.
 618              */
 619             if (smtperr >= 400)
 620                 error(0, -1, _("%cMTP error: %s"),
 621                       ctl->listener,
 622                       smtp_response);
 623
 624             switch (smtperr)
 625             {
 626             case 452: /* insufficient system storage */
 627                 /*
 628                  * Temporary out-of-queue-space condition on the
 629                  * ESMTP server.  Don't try to ship the message,
 630                  * and suppress deletion so it can be retried on
 631                  * a future retrieval cycle.
 632                  *
 633                  * Bouncemail *might* be appropriate here as a delay
 634                  * notification.  But it's not really necessary because
 635                  * this is not an actual failure, we're very likely to be
 636                  * able to recover on the next cycle.
 637                  */
 638                 return(PS_TRANSIENT);
 639
 640             case 552: /* message exceeds fixed maximum message size */
 641                 /*
 642                  * Permanent no-go condition on the
 643                  * ESMTP server.  Don't try to ship the message,
 644                  * and allow it to be deleted.
 645                  */
 646                 send_bouncemail(msg,
 647                                 "This message was too large.\r\n",
 648                                 1, responses);
 649                 return(PS_REFUSED);
 650
 651             case 553: /* invalid sending domain */
 652                 /*
 653                  * These latter days 553 usually means a spammer is trying to
 654                  * cover his tracks.
 655                  */
 656                 send_bouncemail(msg,
 657                                 "Invalid address.\r\n",
 658                                 1, responses);
 659                 return(PS_REFUSED);
 660
 661             default:    /* bounce the error back to the sender */
 662                 send_bouncemail(msg,
 663                                 "General SMTP/ESMTP error.\r\n",
 664                                 1, responses);
 665                 return(PS_REFUSED);
 666             }
 667         }
 668
 669         /*
 670          * Now list the recipient addressees
 671          */
 672         for (idp = msg->recipients; idp; idp = idp->next)
 673             if (idp->val.status.mark == XMIT_ACCEPT)
 674             {
 675                 if (strchr(idp->id, '@'))
 676                     strcpy(addr, idp->id);
 677                 else
 678 #ifdef HAVE_SNPRINTF
 679                     snprintf(addr, sizeof(addr)-1, "%s@%s", idp->id, ctl->destaddr);
 680 #else
 681                     sprintf(addr, "%s@%s", idp->id, ctl->destaddr);
 682 #endif /* HAVE_SNPRINTF */
 683
 684                 if (SMTP_rcpt(ctl->smtp_socket, addr) == SM_OK)
 685                     (*good_addresses)++;
 686                 else
 687                 {
 688                     (*bad_addresses)++;
 689                     idp->val.status.mark = XMIT_ANTISPAM;
 690                     error(0, 0,
 691                           _("%cMTP listener doesn't like recipient address `%s'"),
 692                           ctl->listener, addr);
 693                 }
 694             }
 695         if (!(*good_addresses))
 696         {
 697 #ifdef HAVE_SNPRINTF
 698             snprintf(addr, sizeof(addr)-1, "%s@%s", run.postmaster, ctl->destaddr);
 699 #else
 700             sprintf(addr, "%s@%s", run.postmaster, ctl->destaddr);
 701 #endif /* HAVE_SNPRINTF */
 702
 703             if (SMTP_rcpt(ctl->smtp_socket, addr) != SM_OK)
 704             {
 705                 error(0, 0, _("can't even send to %s!"), run.postmaster);
 706                 SMTP_rset(ctl->smtp_socket);    /* required by RFC1870 */
 707                 return(PS_SMTP);
 708             }
 709         }
 710
 711         /* tell it we're ready to send data */
 712         SMTP_data(ctl->smtp_socket);
 713     }
 714
 715     /*
 716      * We need to stash this away in order to know how many
 717      * response lines to expect after the LMTP end-of-message.
 718      */
 719     msg->lmtp_responses = *good_addresses;
 720
 721     return(PS_SUCCESS);
 722 }
 723
 724 void release_sink(struct query *ctl)
 725 /* release the per-message output sink, whether it's a pipe or SMTP socket */
 726 {
 727     if (ctl->bsmtp)
 728         fclose(sinkfp);
 729     else if (ctl->mda)
 730     {
 731         if (sinkfp)
 732         {
 733             pclose(sinkfp);
 734             sinkfp = (FILE *)NULL;
 735         }
 736         signal(SIGCHLD, sigchld);
 737     }
 738 }
 739
 740 int close_sink(struct query *ctl, struct msgblk *msg, flag forward)
 741 /* perform end-of-message actions on the current output sink */
 742 {
 743     if (ctl->mda)
 744     {
 745         int rc;
 746
 747         /* close the delivery pipe, we'll reopen before next message */
 748         if (sinkfp)
 749         {
 750             rc = pclose(sinkfp);
 751             sinkfp = (FILE *)NULL;
 752         }
 753         else
 754             rc = 0;
 755         signal(SIGCHLD, sigchld);
 756         if (rc)
 757         {
 758             error(0, -1, _("MDA exited abnormally or returned nonzero status"));
 759             return(FALSE);
 760         }
 761     }
 762     else if (ctl->bsmtp)
 763     {
 764         /* implicit disk-full check here... */
 765         fputs("..\r\n", sinkfp);
 766         if (strcmp(ctl->bsmtp, "-"))
 767             fclose(sinkfp);
 768         if (ferror(sinkfp))
 769         {
 770             error(0, -1, _("Message termination or close of BSMTP file failed"));
 771             return(FALSE);
 772         }
 773     }
 774     else if (forward)
 775     {
 776         /* write message terminator */
 777         if (SMTP_eom(ctl->smtp_socket) != SM_OK)
 778         {
 779             error(0, -1, _("SMTP listener refused delivery"));
 780             return(FALSE);
 781         }
 782
 783         /*
 784          * If this is an SMTP connection, SMTP_eom() ate the response.
 785          * But could be this is an LMTP connection, in which case we have to
 786          * interpret either (a) a single 503 response meaning there
 787          * were no successful RCPT TOs, or (b) a variable number of
 788          * responses, one for each successful RCPT TO.  We need to send
 789          * bouncemail on each failed response and then return TRUE anyway,
 790          * otherwise the message will get left in the queue and resent
 791          * to people who got it the first time.
 792          */
 793         if (ctl->listener == LMTP_MODE)
 794             if (msg->lmtp_responses == 0)
 795             {
 796                 SMTP_ok(ctl->smtp_socket);
 797
 798                 /*
 799                  * According to RFC2033, 503 is the only legal response
 800                  * if no RCPT TO commands succeeded.  No error recovery
 801                  * is really possible here, as we have no idea what
 802                  * insane thing the listener might be doing if it doesn't
 803                  * comply.
 804                  */
 805                 if (atoi(smtp_response) == 503)
 806                     error(0, -1, _("LMTP delivery error on EOM"));
 807                 else
 808                     error(0, -1,
 809                           _("Unexpected non-503 response to LMTP EOM: %s"),
 810                           smtp_response);
 811
 812                 /*
 813                  * It's not completely clear what to do here.  We choose to
 814                  * interpret delivery failure here as a transient error,
 815                  * the same way SMTP delivery failure is handled.  If we're
 816                  * wrong, an undead message will get stuck in the queue.
 817                  */
 818                 return(FALSE);
 819             }
 820             else
 821             {
 822                 int     i, errors;
 823                 char    **responses;
 824
 825                 /* eat the RFC2033-required responses, saving errors */
 826                 xalloca(responses, char **, sizeof(char *) * msg->lmtp_responses);
 827                 for (errors = i = 0; i < msg->lmtp_responses; i++)
 828                 {
 829                     if (SMTP_ok(ctl->smtp_socket) == SM_OK)
 830                         responses[i] = (char *)NULL;
 831                     else
 832                     {
 833                         xalloca(responses[errors],
 834                                 char *,
 835                                 strlen(smtp_response)+1);
 836                         strcpy(responses[errors], smtp_response);
 837                         errors++;
 838                     }
 839                 }
 840
 841                 if (errors == 0)
 842                     return(TRUE);       /* all deliveries succeeded */
 843                 else
 844                     /*
 845                      * One or more deliveries failed.
 846                      * If we can bounce a failures list back to the sender,
 847                      * return TRUE, deleting the message from the server so
 848                      * it won't be re-forwarded on subsequent poll cycles.
 849                      */
 850                     return(send_bouncemail(msg,
 851                                    "LSMTP partial delivery failure.\r\n",
 852                                    errors, responses));
 853             }
 854     }
 855
 856     return(TRUE);
 857 }
 858
 859 int open_warning_by_mail(struct query *ctl, struct msgblk *msg)
 860 /* set up output sink for a mailed warning to calling user */
 861 {
 862     int good, bad;
 863
 864     /*
 865      * Dispatching warning email is a little complicated.  The problem is
 866      * that we have to deal with three distinct cases:
 867      *
 868      * 1. Single-drop running from user account.  Warning mail should
 869      * go to the local name for which we're collecting (coincides
 870      * with calling user).
 871      *
 872      * 2. Single-drop running from root or other privileged ID, with rc
 873      * file generated on the fly (Ken Estes's weird setup...)  Mail
 874      * should go to the local name for which we're collecting (does not
 875      * coincide with calling user).
 876      *
 877      * 3. Multidrop.  Mail must go to postmaster.  We leave the recipients
 878      * member null so this message will fall through to run.postmaster.
 879      *
 880      * The zero in the reallen element means we won't pass a SIZE
 881      * option to ESMTP; the message length would be more trouble than
 882      * it's worth to compute.
 883      */
 884     struct msgblk reply = {NULL, NULL, "FETCHMAIL-DAEMON", 0};
 885
 886     if (!MULTIDROP(ctl))                /* send to calling user */
 887     {
 888         int status;
 889
 890         save_str(&reply.recipients, ctl->localnames->id, XMIT_ACCEPT);
 891         status = open_sink(ctl, &reply, &good, &bad);
 892         free_str_list(&reply.recipients);
 893         return(status);
 894     }
 895     else                                /* send to postmaster  */
 896         return(open_sink(ctl, &reply, &good, &bad));
 897 }
 898
 899 #if defined(HAVE_STDARG_H)
 900 void stuff_warning(struct query *ctl, const char *fmt, ... )
 901 #else
 902 void stuff_warning(struct query *ctl, fmt, va_alist)
 903 struct query *ctl;
 904 const char *fmt;        /* printf-style format */
 905 va_dcl
 906 #endif
 907 /* format and ship a warning message line by mail */
 908 {
 909     char        buf[POPBUFSIZE];
 910     va_list ap;
 911
 912     /*
 913      * stuffline() requires its input to be writeable (for CR stripping),
 914      * so we needed to copy the message to a writeable buffer anyway in
 915      * case it was a string constant.  We make a virtue of that necessity
 916      * here by supporting stdargs/varargs.
 917      */
 918 #if defined(HAVE_STDARG_H)
 919     va_start(ap, fmt) ;
 920 #else
 921     va_start(ap);
 922 #endif
 923 #ifdef HAVE_VSNPRINTF
 924     vsnprintf(buf, sizeof(buf), fmt, ap);
 925 #else
 926     vsprintf(buf, fmt, ap);
 927 #endif
 928     va_end(ap);
 929
 930     strcat(buf, "\r\n");
 931
 932     stuffline(ctl, buf);
 933 }
 934
 935 void close_warning_by_mail(struct query *ctl, struct msgblk *msg)
 936 /* sign and send mailed warnings */
 937 {
 938     stuff_warning(ctl, "--\r\n\t\t\t\tThe Fetchmail Daemon\r\n");
 939     close_sink(ctl, msg, TRUE);
 940 }
 941
 942 /* sink.c ends here */