2 * driver.c -- generic driver for mail fetch method protocols
4 * Copyright 1997 by Eric S. Raymond
5 * For license terms, see the file COPYING in this directory.
16 #endif /* HAVE_MEMORY_H */
17 #if defined(STDC_HEADERS)
20 #if defined(HAVE_UNISTD_H)
23 #if defined(HAVE_STDARG_H)
28 #if defined(HAVE_SYS_ITIMER_H)
29 #include <sys/itimer.h>
34 #ifdef HAVE_NET_SOCKET_H
35 #include <net/socket.h>
38 #ifdef HAVE_RES_SEARCH
41 #endif /* HAVE_RES_SEARCH */
45 #include <netinet/in.h>
47 #endif /* KERBEROS_V4 */
52 #include "fetchmail.h"
55 /* throw types for runtime errors */
56 #define THROW_TIMEOUT 1 /* server timed out */
57 #define THROW_SIGPIPE 2 /* SIGPIPE on stream socket */
59 #ifndef strstr /* glibc-2.1 declares this as a macro */
60 extern char *strstr(); /* needed on sysV68 R3V7.1. */
63 int batchcount; /* count of messages sent in current batch */
64 flag peek_capable; /* can we peek for better error recovery? */
65 int pass; /* how many times have we re-polled? */
66 int stage; /* where are we? */
67 int phase; /* where are we, for error-logging purposes? */
68 int mytimeout; /* value of nonreponse timeout */
69 int suppress_tags; /* emit tags? */
70 char shroud[PASSWORDLEN]; /* string to shroud in debug output */
72 static const struct method *protocol;
73 static jmp_buf restart;
77 #define GENSYM (sprintf(tag, "A%04d", ++tagnum % TAGMOD), tag)
79 static int timeoutcount; /* count consecutive timeouts */
80 static int msglen; /* actual message length */
82 void set_timeout(int timeleft)
83 /* reset the nonresponse-timeout */
85 #if !defined(__EMX__) && !defined(__BEOS__)
86 struct itimerval ntimeout;
91 ntimeout.it_interval.tv_sec = ntimeout.it_interval.tv_usec = 0;
92 ntimeout.it_value.tv_sec = timeleft;
93 ntimeout.it_value.tv_usec = 0;
94 setitimer(ITIMER_REAL, &ntimeout, (struct itimerval *)NULL);
98 static void timeout_handler (int signal)
99 /* handle SIGALRM signal indicating a server timeout */
102 longjmp(restart, THROW_TIMEOUT);
105 static void sigpipe_handler (int signal)
106 /* handle SIGPIPE signal indicating a broken stream socket */
108 longjmp(restart, THROW_SIGPIPE);
111 static int accept_count, reject_count;
113 static void map_name(const char *name, struct query *ctl, struct idlist **xmit_names)
114 /* add given name to xmit_names if it matches declared localnames */
115 /* name: name to map */
116 /* ctl: list of permissible aliases */
117 /* xmit_names: list of recipient names parsed out */
122 lname = idpair_find(&ctl->localnames, name+off);
123 if (!lname && ctl->wildcard)
126 if (lname != (char *)NULL)
128 if (outlevel >= O_DEBUG)
129 report(stdout, _("mapped %s to local %s\n"), name, lname);
130 save_str(xmit_names, lname, XMIT_ACCEPT);
135 static void find_server_names(const char *hdr,
137 struct idlist **xmit_names)
138 /* parse names out of a RFC822 header into an ID list */
139 /* hdr: RFC822 header in question */
140 /* ctl: list of permissible aliases */
141 /* xmit_names: list of recipient names parsed out */
143 if (hdr == (char *)NULL)
149 for (cp = nxtaddr(hdr);
156 * If the name of the user begins with a qmail virtual
157 * domain prefix, ignore the prefix. Doing this here
158 * means qvirtual will work either with ordinary name
159 * mapping or with a localdomains option.
161 if (ctl->server.qvirtual)
163 int sl = strlen(ctl->server.qvirtual);
165 if (!strncasecmp(cp, ctl->server.qvirtual, sl))
169 if ((atsign = strchr(cp, '@'))) {
173 * Does a trailing segment of the hostname match something
174 * on the localdomains list? If so, save the whole name
177 for (idp = ctl->server.localdomains; idp; idp = idp->next) {
180 rhs = atsign + (strlen(atsign) - strlen(idp->id));
182 (rhs[-1] == '.' || rhs[-1] == '@') &&
183 strcasecmp(rhs, idp->id) == 0)
185 if (outlevel >= O_DEBUG)
186 report(stdout, _("passed through %s matching %s\n"),
188 save_str(xmit_names, cp, XMIT_ACCEPT);
194 /* if we matched a local domain, idp != NULL */
198 * Check to see if the right-hand part is an alias
199 * or MX equivalent of the mailserver. If it's
200 * not, skip this name. If it is, we'll keep
201 * going and try to find a mapping to a client name.
203 if (!is_host_alias(atsign+1, ctl))
205 save_str(xmit_names, cp, XMIT_REJECT);
211 map_name(cp, ctl, xmit_names);
219 * Return zero on a syntactically invalid address, nz on a valid one.
221 * This used to be strchr(a, '.'), but it turns out that lines like this
223 * Received: from punt-1.mail.demon.net by mailstore for markb@ordern.com
224 * id 938765929:10:27223:2; Fri, 01 Oct 99 08:18:49 GMT
226 * are not uncommon. So now we just check that the following token is
227 * not itself an email address.
229 #define VALID_ADDRESS(a) !strchr(a, '@')
231 static char *parse_received(struct query *ctl, char *bufp)
232 /* try to extract real address from the Received line */
233 /* If a valid Received: line is found, we return the full address in
234 * a buffer which can be parsed from nxtaddr(). This is to ansure that
235 * the local domain part of the address can be passed along in
236 * find_server_names() if it contains one.
237 * Note: We should return a dummy header containing the address
238 * which makes nxtaddr() behave correctly.
241 char *base, *ok = (char *)NULL;
242 static char rbuf[HOSTLEN + USERNAMELEN + 4];
245 * Try to extract the real envelope addressee. We look here
246 * specifically for the mailserver's Received line.
247 * Note: this will only work for sendmail, or an MTA that
248 * shares sendmail's convention for embedding the envelope
249 * address in the Received line. Sendmail itself only
250 * does this when the mail has a single recipient.
252 if (outlevel >= O_DEBUG)
253 report(stdout, _("analyzing Received line:\n%s"), bufp);
255 /* search for whitepace-surrounded "by" followed by valid address */
256 for (base = bufp; ; base = ok + 2)
258 if (!(ok = strstr(base, "by")))
260 else if (!isspace(ok[-1]) || !isspace(ok[2]))
266 /* extract space-delimited token after "by" */
267 for (sp = ok + 2; isspace(*sp); sp++)
270 for (; !isspace(*sp); sp++)
274 /* look for valid address */
275 if (VALID_ADDRESS(rbuf))
278 ok = sp - 1; /* arrange to skip this token */
284 * If it's a DNS name of the mail server, look for the
285 * recipient name after a following "for". Otherwise
288 if (is_host_alias(rbuf, ctl))
290 if (outlevel >= O_DEBUG)
292 _("line accepted, %s is an alias of the mailserver\n"), rbuf);
296 if (outlevel >= O_DEBUG)
298 _("line rejected, %s is not an alias of the mailserver\n"),
303 /* search for whitepace-surrounded "for" followed by xxxx@yyyy */
304 for (base = ok + 4 + strlen(rbuf); ; base = ok + 2)
306 if (!(ok = strstr(base, "for")))
308 else if (!isspace(ok[-1]) || !isspace(ok[3]))
314 /* extract space-delimited token after "for" */
315 for (sp = ok + 3; isspace(*sp); sp++)
318 for (; !isspace(*sp); sp++)
322 if (strchr(rbuf, '@'))
325 ok = sp - 1; /* arrange to skip this token */
330 flag want_gt = FALSE;
333 /* char after "for" could be space or a continuation newline */
334 for (sp = ok + 4; isspace(*sp); sp++)
337 *tp++ = ':'; /* Here is the hack. This is to be friends */
338 *tp++ = ' '; /* with nxtaddr()... */
344 while (*sp == '@') /* skip routes */
345 while (*sp && *sp++ != ':')
348 && (want_gt ? (*sp != '>') : !isspace(*sp))
354 /* uh oh -- whitespace here can't be right! */
360 if (strlen(rbuf) <= 3) /* apparently nothing has been found */
368 if (outlevel >= O_DEBUG)
369 report(stdout, _("no Received address found\n"));
374 if (outlevel >= O_DEBUG) {
375 char *lf = rbuf + strlen(rbuf)-1;
377 if (outlevel >= O_DEBUG)
378 report(stdout, _("found Received address `%s'\n"), rbuf+2);
385 /* shared by readheaders and readbody */
386 static int sizeticker;
387 static struct msgblk msgblk;
389 #define EMPTYLINE(s) ((s)[0] == '\r' && (s)[1] == '\n' && (s)[2] == '\0')
391 static int readheaders(int sock,
396 /* read message headers and ship to SMTP or MDA */
397 /* sock: to which the server is connected */
398 /* fetchlen: length of message according to fetch response */
399 /* reallen: length of message according to getsizes */
400 /* ctl: query control record */
401 /* num: index of message */
406 struct addrblk *next;
408 struct addrblk *to_addrchain = NULL;
409 struct addrblk **to_chainptr = &to_addrchain;
410 struct addrblk *resent_to_addrchain = NULL;
411 struct addrblk **resent_to_chainptr = &resent_to_addrchain;
413 char buf[MSGBUFSIZE+1];
414 int from_offs, reply_to_offs, resent_from_offs;
415 int app_from_offs, sender_offs, resent_sender_offs;
417 char *received_for, *rcv, *cp, *delivered_to;
418 int n, linelen, oldlen, ch, remaining, skipcount;
420 flag no_local_matches = FALSE;
421 flag headers_ok, has_nuls;
422 int olderrs, good_addresses, bad_addresses;
425 has_nuls = headers_ok = FALSE;
426 msgblk.return_path[0] = '\0';
427 olderrs = ctl->errcount;
429 /* read message headers */
430 msgblk.reallen = reallen;
433 * We used to free the header block unconditionally at the end of
434 * readheaders, but it turns out that if close_sink() hits an error
435 * condition the code for sending bouncemail will actually look
436 * at the freed storage and coredump...
439 free(msgblk.headers);
441 msgblk.headers = received_for = delivered_to = NULL;
442 from_offs = reply_to_offs = resent_from_offs = app_from_offs =
443 sender_offs = resent_sender_offs = env_offs = -1;
449 for (remaining = fetchlen; remaining > 0 || protocol->delimited; remaining -= linelen)
453 line = xmalloc(sizeof(buf));
457 set_timeout(mytimeout);
458 if ((n = SockRead(sock, buf, sizeof(buf)-1)) == -1) {
461 free(msgblk.headers);
462 msgblk.headers = NULL;
469 /* lines may not be properly CRLF terminated; fix this for qmail */
472 cp = buf + strlen(buf) - 1;
473 if (*cp == '\n' && (cp == buf || cp[-1] != '\r'))
482 * Decode MIME encoded headers. We MUST do this before
483 * looking at the Content-Type / Content-Transfer-Encoding
484 * headers (RFC 2046).
489 line = (char *) realloc(line, strlen(line) + strlen(buf) +1);
493 /* check for end of headers */
497 has_nuls = (linelen != strlen(line));
499 goto process_headers;
503 * Check for end of message immediately. If one of your folders
504 * has been mangled, the delimiter may occur directly after the
507 if (protocol->delimited && line[0] == '.' && EMPTYLINE(line+1))
510 has_nuls = (linelen != strlen(line));
511 goto process_headers;
515 * At least one brain-dead website (netmind.com) is known to
516 * send out robotmail that's missing the RFC822 delimiter blank
517 * line before the body! Without this check fetchmail segfaults.
518 * With it, we treat such messages as though they had the missing
521 if (!isspace(line[0]) && !strchr(line, ':'))
525 has_nuls = (linelen != strlen(line));
526 goto process_headers;
529 /* check for RFC822 continuations */
530 set_timeout(mytimeout);
534 (ch == ' ' || ch == '\t'); /* continuation to next line? */
536 /* write the message size dots */
537 if ((outlevel > O_SILENT && outlevel < O_VERBOSE) && linelen > 0)
539 sizeticker += linelen;
540 while (sizeticker >= SIZETICKER)
542 if ((!run.use_syslog && !isafile(1)) || run.showdots)
547 sizeticker -= SIZETICKER;
551 /* we see an ordinary (non-header, non-message-delimiter line */
552 has_nuls = (linelen != strlen(line));
555 * When mail delivered to a multidrop mailbox on the server is
556 * addressed to multiple people on the client machine, there
557 * will be one copy left in the box for each recipient. Thus,
558 * if the mail is addressed to N people, each recipient will
559 * get N copies. This is bad when N > 1.
561 * Foil this by suppressing all but one copy of a message with
562 * a given Message-ID. The accept_count test ensures that
563 * multiple pieces of email with the same Message-ID, each
564 * with a *single* addressee (the N == 1 case), won't be
567 * Note: This implementation only catches runs of successive
568 * messages with the same ID, but that should be good
569 * enough. A more general implementation would have to store
570 * ever-growing lists of seen message-IDs; in a long-running
571 * daemon this would turn into a memory leak even if the
572 * implementation were perfect.
574 * Don't mess with this code casually. It would be way too easy
575 * to break it in a way that blackholed mail. Better to pass
576 * the occasional duplicate than to do that...
578 if (MULTIDROP(ctl) && !strncasecmp(line, "Message-ID:", 11))
580 if (ctl->lastid && !strcasecmp(ctl->lastid, line))
582 if (accept_count > 1)
589 ctl->lastid = strdup(line);
594 * The University of Washington IMAP server (the reference
595 * implementation of IMAP4 written by Mark Crispin) relies
596 * on being able to keep base-UID information in a special
597 * message at the head of the mailbox. This message should
598 * neither be deleted nor forwarded.
602 * We disable this check under POP2 because there's no way to
603 * prevent deletion of the message. So at least we ought to
604 * forward it to the user so he or she will have some clue
605 * that things have gone awry.
608 if (strncmp(protocol->service, "pop2", 4))
609 #else /* INET6_ENABLE */
610 if (protocol->port != 109)
611 #endif /* INET6_ENABLE */
612 #endif /* POP2_ENABLE */
613 if (num == 1 && !strncasecmp(line, "X-IMAP:", 7)) {
615 free(msgblk.headers);
616 msgblk.headers = NULL;
621 * This code prevents fetchmail from becoming an accessory after
622 * the fact to upstream sendmails with the `E' option on. It also
623 * copes with certain brain-dead POP servers (like NT's) that pass
624 * through Unix from_ lines.
626 * Either of these bugs can result in a non-RFC822 line at the
627 * beginning of the headers. If fetchmail just passes it
628 * through, the client listener may think the message has *no*
629 * headers (since the first) line it sees doesn't look
630 * RFC822-conformant) and fake up a set.
632 * What the user would see in this case is bogus (synthesized)
633 * headers, followed by a blank line, followed by the >From,
634 * followed by the real headers, followed by a blank line,
637 * We forestall this lossage by tossing anything that looks
638 * like an escaped or passed-through From_ line in headers.
639 * These aren't RFC822 so our conscience is clear...
641 if (!strncasecmp(line, ">From ", 6) || !strncasecmp(line, "From ", 5))
648 * We remove all Delivered-To: headers.
650 * This is to avoid false mail loops messages when delivering
651 * local messages to and from a Postfix/qmail mailserver.
653 if (ctl->dropdelivered && !strncasecmp(line, "Delivered-To:", 13))
663 * If we see a Status line, it may have been inserted by an MUA
664 * on the mail host, or it may have been inserted by the server
665 * program after the headers in the transaction stream. This
666 * can actually hose some new-mail notifiers such as xbuffy,
667 * which assumes any Status line came from a *local* MDA and
668 * therefore indicates that the message has been seen.
670 * Some buggy POP servers (including at least the 3.3(20)
671 * version of the one distributed with IMAP) insert empty
672 * Status lines in the transaction stream; we'll chuck those
673 * unconditionally. Nonempty ones get chucked if the user
674 * turns on the dropstatus flag.
679 if (!strncasecmp(line, "Status:", 7))
681 else if (!strncasecmp(line, "X-Mozilla-Status:", 17))
686 while (*cp && isspace(*cp)) cp++;
687 if (!*cp || ctl->dropstatus)
696 line = reply_hack(line, ctl->server.truename);
699 * OK, this is messy. If we're forwarding by SMTP, it's the
700 * SMTP-receiver's job (according to RFC821, page 22, section
701 * 4.1.1) to generate a Return-Path line on final delivery.
702 * The trouble is, we've already got one because the
703 * mailserver's SMTP thought *it* was responsible for final
706 * Stash away the contents of Return-Path (as modified by reply_hack)
707 * for use in generating MAIL FROM later on, then prevent the header
708 * from being saved with the others. In effect, we strip it off here.
710 * If the SMTP server conforms to the standards, and fetchmail gets the
711 * envelope sender from the Return-Path, the new Return-Path should be
712 * exactly the same as the original one.
714 * We do *not* want to ignore empty Return-Path headers. These should
715 * be passed through as a way of indicating that a message should
716 * not trigger bounces if delivery fails. What we *do* need to do is
717 * make sure we never try to rewrite such a blank Return-Path. We
718 * handle this with a check for <> in the rewrite logic above.
720 if (!strncasecmp("Return-Path:", line, 12) && (cp = nxtaddr(line)))
722 strcpy(msgblk.return_path, cp);
731 oldlen = strlen(line);
732 msgblk.headers = xmalloc(oldlen + 1);
733 (void) strcpy(msgblk.headers, line);
735 line = msgblk.headers;
742 newlen = oldlen + strlen(line);
743 newhdrs = (char *) realloc(msgblk.headers, newlen + 1);
744 if (newhdrs == NULL) {
748 msgblk.headers = newhdrs;
749 strcpy(msgblk.headers + oldlen, line);
751 line = msgblk.headers + oldlen;
755 if (!strncasecmp("From:", line, 5))
756 from_offs = (line - msgblk.headers);
757 else if (!strncasecmp("Reply-To:", line, 9))
758 reply_to_offs = (line - msgblk.headers);
759 else if (!strncasecmp("Resent-From:", line, 12))
760 resent_from_offs = (line - msgblk.headers);
761 else if (!strncasecmp("Apparently-From:", line, 16))
762 app_from_offs = (line - msgblk.headers);
764 * Netscape 4.7 puts "Sender: zap" in mail headers. Perverse...
766 * But a literal reading of RFC822 sec. 4.4.2 supports the idea
767 * that Sender: *doesn't* have to be a working email address.
769 * The definition of the Sender header in RFC822 says, in
770 * part, "The Sender mailbox specification includes a word
771 * sequence which must correspond to a specific agent (i.e., a
772 * human user or a computer program) rather than a standard
773 * address." That implies that the contents of the Sender
774 * field don't need to be a legal email address at all So
775 * ignore any Sender or Resent-Semnder lines unless they
778 * (RFC2822 says the condents of Sender must be a valid mailbox
779 * address, which is also what RFC822 4.4.4 implies.)
781 else if (!strncasecmp("Sender:", line, 7) && strchr(line, '@'))
782 sender_offs = (line - msgblk.headers);
783 else if (!strncasecmp("Resent-Sender:", line, 14) && strchr(line, '@'))
784 resent_sender_offs = (line - msgblk.headers);
787 else if (!strncasecmp("Message-Id:", line, 11))
789 if (ctl->server.uidl)
793 line[IDLEN+12] = 0; /* prevent stack overflow */
794 sscanf(line+12, "%s", id);
795 if (!str_find( &ctl->newsaved, num))
797 struct idlist *new = save_str(&ctl->newsaved,id,UID_SEEN);
798 new->val.status.num = num;
802 #endif /* __UNUSED__ */
804 else if (!MULTIDROP(ctl))
807 else if (!strncasecmp("To:", line, 3)
808 || !strncasecmp("Cc:", line, 3)
809 || !strncasecmp("Bcc:", line, 4)
810 || !strncasecmp("Apparently-To:", line, 14))
812 *to_chainptr = xmalloc(sizeof(struct addrblk));
813 (*to_chainptr)->offset = (line - msgblk.headers);
814 to_chainptr = &(*to_chainptr)->next;
818 else if (!strncasecmp("Resent-To:", line, 10)
819 || !strncasecmp("Resent-Cc:", line, 10)
820 || !strncasecmp("Resent-Bcc:", line, 11))
822 *resent_to_chainptr = xmalloc(sizeof(struct addrblk));
823 (*resent_to_chainptr)->offset = (line - msgblk.headers);
824 resent_to_chainptr = &(*resent_to_chainptr)->next;
825 *resent_to_chainptr = NULL;
828 else if (ctl->server.envelope != STRING_DISABLED)
830 if (ctl->server.envelope
831 && strcasecmp(ctl->server.envelope, "Received"))
833 if (env_offs == -1 && !strncasecmp(ctl->server.envelope,
835 strlen(ctl->server.envelope)))
837 if (skipcount++ != ctl->server.envskip)
839 env_offs = (line - msgblk.headers);
842 else if (!received_for && !strncasecmp("Received:", line, 9))
844 if (skipcount++ != ctl->server.envskip)
846 received_for = parse_received(ctl, line);
853 * We want to detect this early in case there are so few headers that the
854 * dispatch logic barfs.
858 if (outlevel > O_SILENT)
860 _("message delimiter found while scanning headers\n"));
864 * Hack time. If the first line of the message was blank, with no headers
865 * (this happens occasionally due to bad gatewaying software) cons up
866 * a set of fake headers.
868 * If you modify the fake header template below, be sure you don't
869 * make either From or To address @-less, otherwise the reply_hack
870 * logic will do bad things.
872 if (msgblk.headers == (char *)NULL)
875 snprintf(buf, sizeof(buf),
878 #endif /* HAVE_SNPRINTF */
879 "From: FETCHMAIL-DAEMON\r\nTo: %s@%s\r\nSubject: Headerless mail from %s's mailbox on %s\r\n",
880 user, fetchmailhost, ctl->remotename, ctl->server.truename);
881 msgblk.headers = xstrdup(buf);
885 * We can now process message headers before reading the text.
886 * In fact we have to, as this will tell us where to forward to.
889 /* Check for MIME headers indicating possible 8-bit data */
890 ctl->mimemsg = MimeBodyType(msgblk.headers, ctl->mimedecode);
893 if (ctl->server.sdps && sdps_envfrom)
895 /* We have the real envelope return-path, stored out of band by
896 * SDPS - that's more accurate than any header is going to be.
898 strcpy(msgblk.return_path, sdps_envfrom);
901 #endif /* SDPS_ENABLE */
903 * If there is a Return-Path address on the message, this was
904 * almost certainly the MAIL FROM address given the originating
905 * sendmail. This is the best thing to use for logging the
906 * message origin (it sets up the right behavior for bounces and
907 * mailing lists). Otherwise, fall down to the next available
908 * envelope address (which is the most probable real sender).
909 * *** The order is important! ***
910 * This is especially useful when receiving mailing list
911 * messages in multidrop mode. if a local address doesn't
912 * exist, the bounce message won't be returned blindly to the
913 * author or to the list itself but rather to the list manager
914 * (ex: specified by "Sender:") which is much less annoying. This
915 * is true for most mailing list packages.
917 if( !msgblk.return_path[0] ){
919 if (resent_sender_offs >= 0 && (ap = nxtaddr(msgblk.headers + resent_sender_offs)));
920 else if (sender_offs >= 0 && (ap = nxtaddr(msgblk.headers + sender_offs)));
921 else if (resent_from_offs >= 0 && (ap = nxtaddr(msgblk.headers + resent_from_offs)));
922 else if (from_offs >= 0 && (ap = nxtaddr(msgblk.headers + from_offs)));
923 else if (reply_to_offs >= 0 && (ap = nxtaddr(msgblk.headers + reply_to_offs)));
924 else if (app_from_offs >= 0 && (ap = nxtaddr(msgblk.headers + app_from_offs)));
925 if (ap) strcpy( msgblk.return_path, ap );
928 /* cons up a list of local recipients */
929 msgblk.recipients = (struct idlist *)NULL;
930 accept_count = reject_count = 0;
931 /* is this a multidrop box? */
935 if (ctl->server.sdps && sdps_envto)
937 /* We have the real envelope recipient, stored out of band by
938 * SDPS - that's more accurate than any header is going to be.
940 find_server_names(sdps_envto, ctl, &msgblk.recipients);
943 #endif /* SDPS_ENABLE */
944 if (env_offs > -1) /* We have the actual envelope addressee */
945 find_server_names(msgblk.headers + env_offs, ctl, &msgblk.recipients);
946 else if (delivered_to && ctl->server.envelope != STRING_DISABLED &&
947 ctl->server.envelope && !strcasecmp(ctl->server.envelope, "Delivered-To"))
949 find_server_names(delivered_to, ctl, &msgblk.recipients);
952 else if (received_for)
954 * We have the Received for addressee.
955 * It has to be a mailserver address, or we
956 * wouldn't have got here.
957 * We use find_server_names() to let local
958 * hostnames go through.
960 find_server_names(received_for, ctl, &msgblk.recipients);
964 * We haven't extracted the envelope address.
965 * So check all the "Resent-To" header addresses if
966 * they exist. If and only if they don't, consider
967 * the "To" addresses.
969 register struct addrblk *nextptr;
970 if (resent_to_addrchain) {
971 /* delete the "To" chain and substitute it
972 * with the "Resent-To" list
974 while (to_addrchain) {
975 nextptr = to_addrchain->next;
977 to_addrchain = nextptr;
979 to_addrchain = resent_to_addrchain;
980 resent_to_addrchain = NULL;
982 /* now look for remaining adresses */
983 while (to_addrchain) {
984 find_server_names(msgblk.headers+to_addrchain->offset, ctl, &msgblk.recipients);
985 nextptr = to_addrchain->next;
987 to_addrchain = nextptr;
992 no_local_matches = TRUE;
993 save_str(&msgblk.recipients, run.postmaster, XMIT_ACCEPT);
994 if (outlevel >= O_DEBUG)
996 _("no local matches, forwarding to %s\n"),
1000 else /* it's a single-drop box, use first localname */
1001 save_str(&msgblk.recipients, ctl->localnames->id, XMIT_ACCEPT);
1005 * Time to either address the message or decide we can't deliver it yet.
1007 if (ctl->errcount > olderrs) /* there were DNS errors above */
1009 if (outlevel >= O_DEBUG)
1011 _("forwarding and deletion suppressed due to DNS errors\n"));
1012 free(msgblk.headers);
1013 msgblk.headers = NULL;
1014 free_str_list(&msgblk.recipients);
1015 return(PS_TRANSIENT);
1019 /* set up stuffline() so we can deliver the message body through it */
1020 if ((n = open_sink(ctl, &msgblk,
1021 &good_addresses, &bad_addresses)) != PS_SUCCESS)
1023 free(msgblk.headers);
1024 msgblk.headers = NULL;
1025 free_str_list(&msgblk.recipients);
1032 * Some server/sendmail combinations cause problems when our
1033 * synthetic Received line is before the From header. Cope
1036 if ((rcv = strstr(msgblk.headers, "Received:")) == (char *)NULL)
1037 rcv = msgblk.headers;
1038 /* handle ">Received:" lines too */
1039 while (rcv > msgblk.headers && rcv[-1] != '\n')
1041 if (rcv > msgblk.headers)
1046 n = stuffline(ctl, msgblk.headers);
1049 if (!run.invisible && n != -1)
1051 /* utter any per-message Received information we need here */
1052 if (ctl->server.trueaddr) {
1053 sprintf(buf, "Received: from %s [%u.%u.%u.%u]\r\n",
1054 ctl->server.truename,
1055 (unsigned char)ctl->server.trueaddr[0],
1056 (unsigned char)ctl->server.trueaddr[1],
1057 (unsigned char)ctl->server.trueaddr[2],
1058 (unsigned char)ctl->server.trueaddr[3]);
1060 sprintf(buf, "Received: from %s\r\n", ctl->server.truename);
1062 n = stuffline(ctl, buf);
1066 * This header is technically invalid under RFC822.
1067 * POP3, IMAP, etc. are not legal mail-parameter values.
1069 * We used to include ctl->remotename in this log line,
1070 * but this can be secure information that would be bad
1073 sprintf(buf, "\tby %s with %s (fetchmail-%s)\r\n",
1077 n = stuffline(ctl, buf);
1081 if (good_addresses == 0)
1084 "for %s@%s (by default); ",
1085 user, ctl->destaddr);
1087 else if (good_addresses == 1)
1089 for (idp = msgblk.recipients; idp; idp = idp->next)
1090 if (idp->val.status.mark == XMIT_ACCEPT)
1091 break; /* only report first address */
1092 if (strchr(idp->id, '@'))
1093 sprintf(buf+1, "for %s", idp->id);
1096 * This could be a bit misleading, as destaddr is
1097 * the forwarding host rather than the actual
1098 * destination. Most of the time they coincide.
1100 sprintf(buf+1, "for %s@%s", idp->id, ctl->destaddr);
1101 sprintf(buf+strlen(buf), " (%s); ",
1102 MULTIDROP(ctl) ? "multi-drop" : "single-drop");
1107 strcat(buf, rfc822timestamp());
1108 strcat(buf, "\r\n");
1109 n = stuffline(ctl, buf);
1115 n = stuffline(ctl, rcv); /* ship out rest of msgblk.headers */
1119 report(stdout, _("writing RFC822 msgblk.headers\n"));
1121 free(msgblk.headers);
1122 msgblk.headers = NULL;
1123 free_str_list(&msgblk.recipients);
1126 else if ((run.poll_interval == 0 || nodetach) && outlevel >= O_VERBOSE && !isafile(2))
1129 /* write error notifications */
1130 if (no_local_matches || has_nuls || bad_addresses)
1133 char errhd[USERNAMELEN + POPBUFSIZE], *errmsg;
1136 (void) strcpy(errhd, "X-Fetchmail-Warning: ");
1137 if (no_local_matches)
1139 if (reject_count != 1)
1140 strcat(errhd, _("no recipient addresses matched declared local names"));
1143 for (idp = msgblk.recipients; idp; idp = idp->next)
1144 if (idp->val.status.mark == XMIT_REJECT)
1146 sprintf(errhd+strlen(errhd), _("recipient address %s didn't match any local name"), idp->id);
1152 if (errhd[sizeof("X-Fetchmail-Warning: ")])
1153 strcat(errhd, "; ");
1154 strcat(errhd, _("message has embedded NULs"));
1159 if (errhd[sizeof("X-Fetchmail-Warning: ")])
1160 strcat(errhd, "; ");
1161 strcat(errhd, _("SMTP listener rejected local recipient addresses: "));
1162 errlen = strlen(errhd);
1163 for (idp = msgblk.recipients; idp; idp = idp->next)
1164 if (idp->val.status.mark == XMIT_RCPTBAD)
1165 errlen += strlen(idp->id) + 2;
1167 xalloca(errmsg, char *, errlen+3);
1168 (void) strcpy(errmsg, errhd);
1169 for (idp = msgblk.recipients; idp; idp = idp->next)
1170 if (idp->val.status.mark == XMIT_RCPTBAD)
1172 strcat(errmsg, idp->id);
1174 strcat(errmsg, ", ");
1179 strcat(errmsg, "\r\n");
1181 /* ship out the error line */
1182 stuffline(ctl, errmsg);
1185 /* issue the delimiter line */
1190 stuffline(ctl, buf);
1192 /* free(msgblk.headers); */
1193 free_str_list(&msgblk.recipients);
1194 return(headers_ok ? PS_SUCCESS : PS_TRUNCATED);
1197 static int readbody(int sock, struct query *ctl, flag forward, int len)
1198 /* read and dispose of a message body presented on sock */
1199 /* ctl: query control record */
1200 /* sock: to which the server is connected */
1201 /* len: length of message */
1202 /* forward: TRUE to forward */
1205 unsigned char buf[MSGBUFSIZE+4];
1206 unsigned char *inbufp = buf;
1207 flag issoftline = FALSE;
1210 * Pass through the text lines in the body.
1212 * Yes, this wants to be ||, not &&. The problem is that in the most
1213 * important delimited protocol, POP3, the length is not reliable.
1214 * As usual, the problem is Microsoft brain damage; see FAQ item S2.
1215 * So, for delimited protocols we need to ignore the length here and
1216 * instead drop out of the loop with a break statement when we see
1217 * the message delimiter.
1219 while (protocol->delimited || len > 0)
1221 set_timeout(mytimeout);
1222 if ((linelen = SockRead(sock, inbufp, sizeof(buf)-4-(inbufp-buf)))==-1)
1230 /* write the message size dots */
1233 sizeticker += linelen;
1234 while (sizeticker >= SIZETICKER)
1236 if (outlevel > O_SILENT && (((run.poll_interval == 0 || nodetach) && !isafile(1)) || run.showdots))
1241 sizeticker -= SIZETICKER;
1246 /* check for end of message */
1247 if (protocol->delimited && *inbufp == '.')
1249 if (inbufp[1] == '\r' && inbufp[2] == '\n' && inbufp[3] == '\0')
1251 else if (inbufp[1] == '\n' && inbufp[2] == '\0')
1254 msglen--; /* subtract the size of the dot escape */
1259 if (ctl->mimedecode && (ctl->mimemsg & MSG_NEEDS_DECODE)) {
1260 issoftline = UnMimeBodyline(&inbufp, protocol->delimited, issoftline);
1261 if (issoftline && (sizeof(buf)-1-(inbufp-buf) < 200))
1264 * Soft linebreak, but less than 200 bytes left in
1265 * input buffer. Rather than doing a buffer overrun,
1266 * ignore the soft linebreak, NL-terminate data and
1267 * deliver what we have now.
1268 * (Who writes lines longer than 2K anyway?)
1270 *inbufp = '\n'; *(inbufp+1) = '\0';
1275 /* ship out the text line */
1276 if (forward && (!issoftline))
1281 /* guard against very long lines */
1282 buf[MSGBUFSIZE+1] = '\r';
1283 buf[MSGBUFSIZE+2] = '\n';
1284 buf[MSGBUFSIZE+3] = '\0';
1286 n = stuffline(ctl, buf);
1290 report(stdout, _("writing message text\n"));
1294 else if (outlevel >= O_VERBOSE && !isafile(1))
1307 kerberos_auth (socket, canonical, principal)
1308 /* authenticate to the server host using Kerberos V4 */
1309 int socket; /* socket to server host */
1310 char *canonical; /* server name */
1313 char * host_primary;
1317 Key_schedule schedule;
1319 char * prin_copy = (char *) NULL;
1320 char * prin = (char *) NULL;
1321 char * inst = (char *) NULL;
1322 char * realm = (char *) NULL;
1324 if (principal != (char *)NULL && *principal)
1327 prin = prin_copy = xstrdup(principal);
1328 for (cp = prin_copy; *cp && *cp != '.'; ++cp)
1334 while (*cp && *cp != '@')
1344 xalloca(ticket, KTEXT, sizeof (KTEXT_ST));
1345 rem = (krb_sendauth (0L, socket, ticket,
1346 prin ? prin : "pop",
1347 inst ? inst : canonical,
1348 realm ? realm : ((char *) (krb_realmofhost (canonical))),
1349 ((unsigned long) 0),
1353 ((struct sockaddr_in *) 0),
1354 ((struct sockaddr_in *) 0),
1360 if (rem != KSUCCESS)
1362 report(stderr, _("kerberos error %s\n"), (krb_get_err_text (rem)));
1363 return (PS_AUTHFAIL);
1367 #endif /* KERBEROS_V4 */
1370 static int kerberos5_auth(socket, canonical)
1371 /* authenticate to the server host using Kerberos V5 */
1372 int socket; /* socket to server host */
1373 const char *canonical; /* server name */
1375 krb5_error_code retval;
1376 krb5_context context;
1378 krb5_principal client = NULL, server = NULL;
1379 krb5_error *err_ret = NULL;
1381 krb5_auth_context auth_context = NULL;
1383 krb5_init_context(&context);
1384 krb5_init_ets(context);
1385 krb5_auth_con_init(context, &auth_context);
1387 if (retval = krb5_cc_default(context, &ccdef)) {
1388 report(stderr, "krb5_cc_default: %s\n", error_message(retval));
1392 if (retval = krb5_cc_get_principal(context, ccdef, &client)) {
1393 report(stderr, "krb5_cc_get_principal: %s\n", error_message(retval));
1397 if (retval = krb5_sname_to_principal(context, canonical, "pop",
1400 report(stderr, "krb5_sname_to_principal: %s\n", error_message(retval));
1404 retval = krb5_sendauth(context, &auth_context, (krb5_pointer) &socket,
1405 "KPOPV1.0", client, server,
1406 AP_OPTS_MUTUAL_REQUIRED,
1407 NULL, /* no data to checksum */
1408 0, /* no creds, use ccache instead */
1412 NULL); /* don't need reply */
1414 krb5_free_principal(context, server);
1415 krb5_free_principal(context, client);
1416 krb5_auth_con_free(context, auth_context);
1420 if (err_ret && err_ret->e_text) {
1421 report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
1422 error_message(retval),
1425 if (err_ret && err_ret->text.length) {
1426 report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
1427 error_message(retval),
1428 err_ret->text.length,
1429 err_ret->text.data);
1431 krb5_free_error(context, err_ret);
1433 report(stderr, "krb5_sendauth: %s\n", error_message(retval));
1439 #endif /* KERBEROS_V5 */
1441 static void clean_skipped_list(struct idlist **skipped_list)
1442 /* struct "idlist" contains no "prev" ptr; we must remove unused items first */
1444 struct idlist *current=NULL, *prev=NULL, *tmp=NULL, *head=NULL;
1445 prev = current = head = *skipped_list;
1451 /* if item has no reference, remove it */
1452 if (current && current->val.status.mark == 0)
1454 if (current == head) /* remove first item (head) */
1456 head = current->next;
1457 if (current->id) free(current->id);
1459 prev = current = head;
1461 else /* remove middle/last item */
1463 tmp = current->next;
1465 if (current->id) free(current->id);
1470 else /* skip this item */
1473 current = current->next;
1477 *skipped_list = head;
1480 static void send_size_warnings(struct query *ctl)
1481 /* send warning mail with skipped msg; reset msg count when user notified */
1484 int msg_to_send = FALSE;
1485 struct idlist *head=NULL, *current=NULL;
1486 int max_warning_poll_count;
1488 head = ctl->skipped;
1492 /* don't start a notification message unless we need to */
1493 for (current = head; current; current = current->next)
1494 if (current->val.status.num == 0 && current->val.status.mark)
1500 * There's no good way to recover if we can't send notification mail,
1501 * but it's not a disaster, either, since the skipped mail will not
1504 if (open_warning_by_mail(ctl, (struct msgblk *)NULL))
1507 _("Subject: Fetchmail oversized-messages warning.\r\n"
1509 "The following oversized messages remain on the mail server %s:"),
1510 ctl->server.pollname);
1512 if (run.poll_interval == 0)
1513 max_warning_poll_count = 0;
1515 max_warning_poll_count = ctl->warnings/run.poll_interval;
1517 /* parse list of skipped msg, adding items to the mail */
1518 for (current = head; current; current = current->next)
1520 if (current->val.status.num == 0 && current->val.status.mark)
1522 nbr = current->val.status.mark;
1523 size = atoi(current->id);
1525 _("\t%d msg %d octets long skipped by fetchmail.\r\n"),
1528 current->val.status.num++;
1529 current->val.status.mark = 0;
1531 if (current->val.status.num >= max_warning_poll_count)
1532 current->val.status.num = 0;
1535 close_warning_by_mail(ctl, (struct msgblk *)NULL);
1538 static int do_session(ctl, proto, maxfetch)
1539 /* retrieve messages from server using given protocol method table */
1540 struct query *ctl; /* parsed options with merged-in defaults */
1541 const struct method *proto; /* protocol method table */
1542 const int maxfetch; /* maximum number of messages to fetch */
1545 #ifdef HAVE_VOLATILE
1546 volatile int ok, mailserver_socket = -1; /* pacifies -Wall */
1548 int ok, mailserver_socket = -1;
1549 #endif /* HAVE_VOLATILE */
1551 void (*pipesave)(int);
1552 void (*alrmsave)(int);
1553 struct idlist *current=NULL, *tmp=NULL;
1556 ctl->server.base_protocol = protocol;
1560 tag[0] = '\0'; /* nuke any tag hanging out from previous query */
1563 /* set up the server-nonresponse timeout */
1564 alrmsave = signal(SIGALRM, timeout_handler);
1565 mytimeout = ctl->server.timeout;
1567 /* set up the broken-pipe timeout */
1568 pipesave = signal(SIGPIPE, sigpipe_handler);
1570 if ((js = setjmp(restart)))
1572 #ifdef HAVE_SIGPROCMASK
1574 * Don't rely on setjmp() to restore the blocked-signal mask.
1575 * It does this under BSD but is required not to under POSIX.
1577 * If your Unix doesn't have sigprocmask, better hope it has
1578 * BSD-like behavior. Otherwise you may see fetchmail get
1579 * permanently wedged after a second timeout on a bad read,
1580 * because alarm signals were blocked after the first.
1584 sigfillset(&allsigs);
1585 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
1586 #endif /* HAVE_SIGPROCMASK */
1588 if (js == THROW_SIGPIPE)
1590 signal(SIGPIPE, SIG_IGN);
1592 _("SIGPIPE thrown from an MDA or a stream socket error\n"));
1596 else if (js == THROW_TIMEOUT)
1598 if (phase == OPEN_WAIT)
1600 _("timeout after %d seconds waiting to connect to server %s.\n"),
1601 ctl->server.timeout, ctl->server.pollname);
1602 else if (phase == SERVER_WAIT)
1604 _("timeout after %d seconds waiting for server %s.\n"),
1605 ctl->server.timeout, ctl->server.pollname);
1606 else if (phase == FORWARDING_WAIT)
1608 _("timeout after %d seconds waiting for %s.\n"),
1609 ctl->server.timeout,
1610 ctl->mda ? "MDA" : "SMTP");
1611 else if (phase == LISTENER_WAIT)
1613 _("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
1616 _("timeout after %d seconds.\n"), ctl->server.timeout);
1619 * If we've exceeded our threshold for consecutive timeouts,
1620 * try to notify the user, then mark the connection wedged.
1621 * Don't do this if the connection can idle, though; idle
1622 * timeouts just mean the frequency of mail is low.
1624 if (timeoutcount > MAX_TIMEOUTS
1625 && !open_warning_by_mail(ctl, (struct msgblk *)NULL))
1628 _("Subject: fetchmail sees repeated timeouts\r\n"));
1630 _("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\r\n"),
1633 ctl->server.truename);
1635 _("This could mean that your mailserver is stuck, or that your SMTP\r\n" \
1636 "server is wedged, or that your mailbox file on the server has been\r\n" \
1637 "corrupted by a server error. You can run `fetchmail -v -v' to\r\n" \
1638 "diagnose the problem.\r\n\r\n" \
1639 "Fetchmail won't poll this mailbox again until you restart it.\r\n"));
1640 close_warning_by_mail(ctl, (struct msgblk *)NULL);
1647 /* try to clean up all streams */
1649 if (ctl->smtp_socket != -1)
1650 SockClose(ctl->smtp_socket);
1651 if (mailserver_socket != -1)
1652 SockClose(mailserver_socket);
1656 char buf[MSGBUFSIZE+1], *realhost;
1657 int len, num, count, new, bytes, deletions = 0, *msgsizes = NULL;
1659 int fetches, dispatches, oldphase;
1660 #else /* INET6_ENABLE */
1661 int port, fetches, dispatches, oldphase;
1662 #endif /* INET6_ENABLE */
1665 /* execute pre-initialization command, if any */
1666 if (ctl->preconnect && (ok = system(ctl->preconnect)))
1669 _("pre-connection command failed with status %d\n"), ok);
1674 /* open a socket to the mail server */
1677 set_timeout(mytimeout);
1680 port = ctl->server.port ? ctl->server.port : ( ctl->use_ssl ? protocol->sslport : protocol->port );
1682 port = ctl->server.port ? ctl->server.port : protocol->port;
1684 #endif /* !INET6_ENABLE */
1685 realhost = ctl->server.via ? ctl->server.via : ctl->server.pollname;
1687 /* allow time for the port to be set up if we have a plugin */
1688 if (ctl->server.plugin)
1691 if ((mailserver_socket = SockOpen(realhost,
1692 ctl->server.service ? ctl->server.service : ( ctl->use_ssl ? protocol->sslservice : protocol->service ),
1693 ctl->server.netsec, ctl->server.plugin)) == -1)
1694 #else /* INET6_ENABLE */
1695 if ((mailserver_socket = SockOpen(realhost, port, NULL, ctl->server.plugin)) == -1)
1696 #endif /* INET6_ENABLE */
1698 char errbuf[BUFSIZ];
1701 #ifdef HAVE_RES_SEARCH
1702 if (err_no != 0 && h_errno != 0)
1703 report(stderr, _("internal inconsistency\n"));
1706 * Avoid generating a bogus error every poll cycle when we're
1707 * in daemon mode but the connection to the outside world
1710 if (!((err_no == EHOSTUNREACH || err_no == ENETUNREACH)
1711 && run.poll_interval))
1713 report_build(stderr, _("%s connection to %s failed"),
1714 protocol->name, ctl->server.pollname);
1715 #ifdef HAVE_RES_SEARCH
1718 if (h_errno == HOST_NOT_FOUND)
1719 strcpy(errbuf, _("host is unknown."));
1721 else if (h_errno == NO_ADDRESS)
1722 strcpy(errbuf, _("name is valid but has no IP address."));
1724 else if (h_errno == NO_RECOVERY)
1725 strcpy(errbuf, _("unrecoverable name server error."));
1726 else if (h_errno == TRY_AGAIN)
1727 strcpy(errbuf, _("temporary name server error."));
1729 sprintf(errbuf, _("unknown DNS error %d."), h_errno);
1732 #endif /* HAVE_RES_SEARCH */
1733 strcpy(errbuf, strerror(err_no));
1734 report_complete(stderr, ": %s\n", errbuf);
1738 * Don't use this. It was an attempt to address Debian bug
1739 * #47143 (Notify user by mail when pop server nonexistent).
1740 * Trouble is, that doesn't work; you trip over the case
1741 * where your SLIP or PPP link is down...
1743 /* warn the system administrator */
1744 if (open_warning_by_mail(ctl, (struct msgblk *)NULL) == 0)
1747 _("Subject: Fetchmail unreachable-server warning.\r\n"
1749 "Fetchmail could not reach the mail server %s:")
1750 ctl->server.pollname);
1751 stuff_warning(ctl, errbuf, ctl->server.pollname);
1752 close_warning_by_mail(ctl, (struct msgblk *)NULL);
1756 #endif /* INET6_ENABLE */
1766 /* perform initial SSL handshake on open connection */
1767 /* Note: We pass the realhost name over for certificate
1768 verification. We may want to make this configurable */
1769 if (ctl->use_ssl && SSLOpen(mailserver_socket,ctl->sslkey,ctl->sslcert,ctl->sslproto,ctl->sslcertck,
1770 ctl->sslcertpath,ctl->sslfingerprint,realhost,ctl->server.pollname) == -1)
1772 report(stderr, _("SSL connection failed.\n"));
1778 if (ctl->server.authenticate == A_KERBEROS_V4)
1780 set_timeout(mytimeout);
1781 ok = kerberos_auth(mailserver_socket, ctl->server.truename,
1782 ctl->server.principal);
1787 #endif /* KERBEROS_V4 */
1790 if (ctl->server.authenticate == A_KERBEROS_V5)
1792 set_timeout(mytimeout);
1793 ok = kerberos5_auth(mailserver_socket, ctl->server.truename);
1798 #endif /* KERBEROS_V5 */
1800 /* accept greeting message from mail server */
1801 ok = (protocol->parse_response)(mailserver_socket, buf);
1805 /* try to get authorized to fetch mail */
1806 stage = STAGE_GETAUTH;
1807 if (protocol->getauth)
1809 ok = (protocol->getauth)(mailserver_socket, ctl, buf);
1813 if (ok == PS_LOCKBUSY)
1814 report(stderr, _("Lock-busy error on %s@%s\n"),
1816 ctl->server.truename);
1817 else if (ok == PS_SERVBUSY)
1818 report(stderr, _("Server busy error on %s@%s\n"),
1820 ctl->server.truename);
1821 else if (ok == PS_AUTHFAIL)
1823 report(stderr, _("Authorization failure on %s@%s%s\n"),
1825 ctl->server.truename,
1826 (ctl->wehaveauthed ? " (previously authorized)" : " ")
1830 * If we're running in background, try to mail the
1831 * calling user a heads-up about the authentication
1832 * failure once it looks like this isn't a fluke
1833 * due to the server being temporarily inaccessible.
1834 * When we get third succesive failure, we notify the user
1835 * but only if we haven't already managed to get
1836 * authorization. After that, once we get authorization
1837 * we let the user know service is restored.
1839 if (run.poll_interval
1840 && ctl->wehavesentauthnote
1841 && ((ctl->wehaveauthed && ++ctl->authfailcount == 10)
1842 || ++ctl->authfailcount == 3)
1843 && !open_warning_by_mail(ctl, (struct msgblk *)NULL))
1845 ctl->wehavesentauthnote = 1;
1847 _("Subject: fetchmail authentication failed on %s@%s\r\n"),
1848 ctl->remotename, ctl->server.truename);
1850 _("Fetchmail could not get mail from %s@%s.\r\n"),
1852 ctl->server.truename);
1853 if (ctl->wehaveauthed)
1854 stuff_warning(ctl, _("\
1855 The attempt to get authorization failed.\r\n\
1856 Since we have already succeeded in getting authorization for this\r\n\
1857 connection, this is probably another failure mode (such as busy server)\r\n\
1858 that fetchmail cannot distinguish because the server didn't send a useful\r\n\
1861 However, if you HAVE changed you account details since starting the\r\n\
1862 fetchmail daemon, you need to stop the daemon, change your configuration\r\n\
1863 of fetchmail, and then restart the daemon.\r\n\
1865 The fetchmail daemon will continue running and attempt to connect\r\n\
1866 at each cycle. No future notifications will be sent until service\r\n\
1869 stuff_warning(ctl, _("\
1870 The attempt to get authorization failed.\r\n\
1871 This probably means your password is invalid, but some servers have\r\n\
1872 other failure modes that fetchmail cannot distinguish from this\r\n\
1873 because they don't send useful error messages on login failure.\r\n\
1875 The fetchmail daemon will continue running and attempt to connect\r\n\
1876 at each cycle. No future notifications will be sent until service\r\n\
1878 close_warning_by_mail(ctl, (struct msgblk *)NULL);
1882 report(stderr, _("Unknown login or authentication error on %s@%s\n"),
1884 ctl->server.truename);
1891 * This connection has given us authorization at least once.
1893 * There are dodgy server (clubinternet.fr for example) that
1894 * give spurious authorization failures on patently good
1895 * account/password details, then 5 minutes later let you in!
1897 * This is meant to build in some tolerance of such nasty bits
1900 ctl->wehaveauthed = 1;
1901 /*if (ctl->authfailcount >= 3)*/
1902 if (ctl->wehavesentauthnote)
1904 ctl->wehavesentauthnote = 0;
1906 _("Authorization OK on %s@%s\n"),
1908 ctl->server.truename);
1909 if (!open_warning_by_mail(ctl, (struct msgblk *)NULL))
1912 _("Subject: fetchmail authentication OK on %s@%s\r\n"),
1913 ctl->remotename, ctl->server.truename);
1915 _("Fetchmail was able to log into %s@%s.\r\n"),
1917 ctl->server.truename);
1919 _("Service has been restored.\r\n"));
1920 close_warning_by_mail(ctl, (struct msgblk *)NULL);
1925 * Reporting only after the first three
1926 * consecutive failures, or ten consecutive
1927 * failures after we have managed to get
1930 ctl->authfailcount = 0;
1934 ctl->errcount = fetches = 0;
1936 /* now iterate over each folder selected */
1937 for (idp = ctl->mailboxes; idp; idp = idp->next)
1944 /* reset timeout, in case we did an IDLE */
1945 mytimeout = ctl->server.timeout;
1947 if (outlevel >= O_DEBUG)
1950 report(stdout, _("selecting or re-polling folder %s\n"), idp->id);
1952 report(stdout, _("selecting or re-polling default folder\n"));
1955 /* compute # of messages and number of new messages waiting */
1956 stage = STAGE_GETRANGE;
1957 ok = (protocol->getrange)(mailserver_socket, ctl, idp->id, &count, &new, &bytes);
1961 /* show user how many messages we downloaded */
1963 (void) sprintf(buf, _("%s at %s (folder %s)"),
1964 ctl->remotename, ctl->server.truename, idp->id);
1966 (void) sprintf(buf, _("%s at %s"),
1967 ctl->remotename, ctl->server.truename);
1968 if (outlevel > O_SILENT)
1970 if (count == -1) /* only used for ETRN */
1971 report(stdout, _("Polling %s\n"), ctl->server.truename);
1972 else if (count != 0)
1974 if (new != -1 && (count - new) > 0)
1975 report_build(stdout, _("%d %s (%d seen) for %s"),
1976 count, count > 1 ? _("messages") :
1980 report_build(stdout, _("%d %s for %s"),
1981 count, count > 1 ? _("messages") :
1984 report_complete(stdout, ".\n");
1986 report_complete(stdout, _(" (%d octets).\n"), bytes);
1990 /* these are pointless in normal daemon mode */
1991 if (pass == 1 && (run.poll_interval == 0 || outlevel >= O_VERBOSE))
1992 report(stdout, _("No mail for %s\n"), buf);
1996 /* very important, this is where we leave the do loop */
2002 if (new == -1 || ctl->fetchall)
2004 fetches = new; /* set error status ccorrectly */
2006 * There used to be a `got noerror' here, but this
2007 * prevneted checking of multiple folders. This
2008 * comment is a reminder in case I introduced some
2009 * subtle bug by removing it...
2014 flag force_retrieval;
2017 * What forces this code is that in POP2 and
2018 * IMAP2bis you can't fetch a message without
2019 * having it marked `seen'. In POP3 and IMAP4, on the
2020 * other hand, you can (peek_capable is set by
2021 * each driver module to convey this; it's not a
2022 * method constant because of the difference between
2023 * IMAP2bis and IMAP4, and because POP3 doesn't peek
2024 * if fetchall is on).
2026 * The result of being unable to peek is that if there's
2027 * any kind of transient error (DNS lookup failure, or
2028 * sendmail refusing delivery due to process-table limits)
2029 * the message will be marked "seen" on the server without
2030 * having been delivered. This is not a big problem if
2031 * fetchmail is running in foreground, because the user
2032 * will see a "skipped" message when it next runs and get
2035 * But in daemon mode this leads to the message
2036 * being silently ignored forever. This is not
2039 * We compensate for this by checking the error
2040 * count from the previous pass and forcing all
2041 * messages to be considered new if it's nonzero.
2043 force_retrieval = !peek_capable && (ctl->errcount > 0);
2046 * We need the size of each message before it's
2047 * loaded in order to pass it to the ESMTP SIZE
2048 * option. If the protocol has a getsizes method,
2049 * we presume this means it doesn't get reliable
2050 * sizes from message fetch responses.
2052 if (proto->getsizes)
2056 xalloca(msgsizes, int *, sizeof(int) * count);
2057 for (i = 0; i < count; i++)
2060 stage = STAGE_GETSIZES;
2061 ok = (proto->getsizes)(mailserver_socket, count, msgsizes);
2068 for (i = 0; i < count; i++)
2069 bytes += msgsizes[i];
2073 /* read, forward, and delete messages */
2074 stage = STAGE_FETCH;
2075 for (num = 1; num <= count; num++)
2077 flag toolarge = NUM_NONZERO(ctl->limit)
2078 && msgsizes && (msgsizes[num-1] > ctl->limit);
2079 flag oldmsg = (!new) || (protocol->is_old && (protocol->is_old)(mailserver_socket,ctl,num));
2080 flag fetch_it = !toolarge
2081 && (ctl->fetchall || force_retrieval || !oldmsg);
2082 flag suppress_delete = FALSE;
2083 flag suppress_forward = FALSE;
2084 flag suppress_readbody = FALSE;
2085 flag retained = FALSE;
2088 * This check copes with Post Office/NT's
2089 * annoying habit of randomly prepending bogus
2090 * LIST items of length -1. Patrick Audley
2091 * <paudley@pobox.com> tells us: LIST shows a
2092 * size of -1, RETR and TOP return "-ERR
2093 * System error - couldn't open message", and
2094 * DELE succeeds but doesn't actually delete
2097 if (msgsizes && msgsizes[num-1] == -1)
2099 if (outlevel >= O_VERBOSE)
2101 _("Skipping message %d, length -1\n"),
2107 * We may want to reject this message if it's old
2108 * or oversized, and we're not forcing retrieval.
2112 if (outlevel > O_SILENT)
2114 report_build(stdout,
2115 _("skipping message %d (%d octets)"),
2116 num, msgsizes[num-1]);
2117 if (toolarge && !check_only)
2122 /* convert sz to string */
2123 sprintf(size, "%d", msgsizes[num-1]);
2125 /* build a list of skipped messages
2126 * val.id = size of msg (string cnvt)
2127 * val.status.num = warning_poll_count
2128 * val.status.mask = nbr of msg this size
2131 current = ctl->skipped;
2133 /* initialise warning_poll_count to the
2134 * current value so that all new msg will
2135 * be included in the next mail
2137 cnt = current? current->val.status.num : 0;
2139 /* if entry exists, increment the count */
2141 str_in_list(¤t, size, FALSE))
2144 current = current->next)
2146 if (strcmp(current->id, size) == 0)
2148 current->val.status.mark++;
2153 /* otherwise, create a new entry */
2154 /* initialise with current poll count */
2157 tmp = save_str(&ctl->skipped, size, 1);
2158 tmp->val.status.num = cnt;
2161 report_build(stdout, _(" (oversized, %d octets)"),
2168 flag wholesize = !protocol->fetch_body;
2170 /* request a message */
2171 ok = (protocol->fetch_headers)(mailserver_socket,ctl,num, &len);
2175 /* -1 means we didn't see a size in the response */
2176 if (len == -1 && msgsizes)
2178 len = msgsizes[num - 1];
2182 if (outlevel > O_SILENT)
2184 report_build(stdout, _("reading message %d of %d"),
2188 report_build(stdout, _(" (%d %soctets)"),
2189 len, wholesize ? "" : _("header "));
2190 if (outlevel >= O_VERBOSE)
2191 report_complete(stdout, "\n");
2193 report_complete(stdout, " ");
2197 * Read the message headers and ship them to the
2200 ok = readheaders(mailserver_socket, len, msgsizes[num-1],
2202 if (ok == PS_RETAINED)
2203 suppress_forward = retained = TRUE;
2204 else if (ok == PS_TRANSIENT)
2205 suppress_delete = suppress_forward = TRUE;
2206 else if (ok == PS_REFUSED)
2207 suppress_forward = TRUE;
2208 else if (ok == PS_TRUNCATED)
2209 suppress_readbody = TRUE;
2214 * If we're using IMAP4 or something else that
2215 * can fetch headers separately from bodies,
2216 * it's time to request the body now. This
2217 * fetch may be skipped if we got an anti-spam
2218 * or other PS_REFUSED error response during
2221 if (protocol->fetch_body && !suppress_readbody)
2223 if (outlevel >= O_VERBOSE && !isafile(1))
2225 fputc('\n', stdout);
2229 if ((ok = (protocol->trail)(mailserver_socket, ctl, num)))
2232 if (!suppress_forward)
2234 if ((ok=(protocol->fetch_body)(mailserver_socket,ctl,num,&len)))
2237 * Work around a bug in Novell's
2238 * broken GroupWise IMAP server;
2239 * its body FETCH response is missing
2240 * the required length for the data
2241 * string. This violates RFC2060.
2244 len = msgsizes[num-1] - msglen;
2245 if (outlevel > O_SILENT && !wholesize)
2246 report_complete(stdout,
2247 _(" (%d body octets) "), len);
2251 /* process the body now */
2254 if (suppress_readbody)
2256 /* When readheaders returns PS_TRUNCATED,
2257 the body (which has no content
2258 has already been read by readheaders,
2259 so we say readbody returned PS_SUCCESS */
2264 ok = readbody(mailserver_socket,
2269 if (ok == PS_TRANSIENT)
2270 suppress_delete = suppress_forward = TRUE;
2274 /* tell server we got it OK and resynchronize */
2275 if (protocol->trail)
2277 if (outlevel >= O_VERBOSE && !isafile(1))
2279 fputc('\n', stdout);
2283 ok = (protocol->trail)(mailserver_socket, ctl, num);
2289 /* count # messages forwarded on this pass */
2290 if (!suppress_forward)
2294 * Check to see if the numbers matched?
2296 * Yes, some servers foo this up horribly.
2297 * All IMAP servers seem to get it right, and
2298 * so does Eudora QPOP at least in 2.xx
2301 * Microsoft Exchange gets it completely
2302 * wrong, reporting compressed rather than
2303 * actual sizes (so the actual length of
2304 * message is longer than the reported size).
2305 * Another fine example of Microsoft brain death!
2307 * Some older POP servers, like the old UCB
2308 * POP server and the pre-QPOP QUALCOMM
2309 * versions, report a longer size in the LIST
2310 * response than actually gets shipped up.
2311 * It's unclear what is going on here, as the
2312 * QUALCOMM server (at least) seems to be
2313 * reporting the on-disk size correctly.
2315 if (msgsizes && msglen != msgsizes[num-1])
2317 if (outlevel >= O_DEBUG)
2319 _("message %d was not the expected length (%d actual != %d expected)\n"),
2320 num, msglen, msgsizes[num-1]);
2323 /* end-of-message processing starts here */
2324 if (!close_sink(ctl, &msgblk, !suppress_forward))
2327 suppress_delete = TRUE;
2333 * At this point in flow of control, either
2334 * we've bombed on a protocol error or had
2335 * delivery refused by the SMTP server
2336 * (unlikely -- I've never seen it) or we've
2337 * seen `accepted for delivery' and the
2338 * message is shipped. It's safe to mark the
2339 * message seen and delete it on the server
2343 /* tell the UID code we've seen this */
2348 for (sdp = ctl->newsaved; sdp; sdp = sdp->next)
2349 if ((sdp->val.status.num == num)
2350 && (!toolarge || oldmsg))
2352 sdp->val.status.mark = UID_SEEN;
2353 save_str(&ctl->oldsaved, sdp->id,UID_SEEN);
2357 /* maybe we delete this message now? */
2360 if (outlevel > O_SILENT)
2361 report(stdout, _(" retained\n"));
2363 else if (protocol->delete
2365 && (fetch_it ? !ctl->keep : ctl->flush))
2368 if (outlevel > O_SILENT)
2369 report_complete(stdout, _(" flushed\n"));
2370 ok = (protocol->delete)(mailserver_socket, ctl, num);
2374 delete_str(&ctl->newsaved, num);
2375 #endif /* POP3_ENABLE */
2377 else if (outlevel > O_SILENT)
2378 report_complete(stdout, _(" not flushed\n"));
2380 /* perhaps this as many as we're ready to handle */
2381 if (maxfetch && maxfetch <= fetches && fetches < count)
2383 report(stdout, _("fetchlimit %d reached; %d messages left on server\n"),
2384 maxfetch, count - fetches);
2390 if (!check_only && ctl->skipped
2391 && run.poll_interval > 0 && !nodetach)
2393 clean_skipped_list(&ctl->skipped);
2394 send_size_warnings(ctl);
2399 * Only re-poll if we either had some actual forwards and
2400 * either allowed deletions and had no errors.
2401 * Otherwise it is far too easy to get into infinite loops.
2403 (dispatches && protocol->retry && !ctl->keep && !ctl->errcount);
2407 /* ordinary termination with no errors -- officially log out */
2408 ok = (protocol->logout_cmd)(mailserver_socket, ctl);
2410 * Hmmmm...arguably this would be incorrect if we had fetches but
2411 * no dispatches (due to oversized messages, etc.)
2414 ok = (fetches > 0) ? PS_SUCCESS : PS_NOMAIL;
2415 SockClose(mailserver_socket);
2419 /* we only get here on error */
2420 if (ok != 0 && ok != PS_SOCKET)
2422 stage = STAGE_LOGOUT;
2423 (protocol->logout_cmd)(mailserver_socket, ctl);
2425 SockClose(mailserver_socket);
2428 msg = (const char *)NULL; /* sacrifice to -Wall */
2435 msg = _("missing or bad RFC822 header");
2441 msg = _("client/server synchronization");
2444 msg = _("client/server protocol");
2447 msg = _("lock busy on server");
2450 msg = _("SMTP transaction");
2453 msg = _("DNS lookup");
2456 report(stderr, _("undefined error\n"));
2459 /* no report on PS_MAXFETCH or PS_UNDEFINED or PS_AUTHFAIL */
2460 if (ok==PS_SOCKET || ok==PS_SYNTAX
2461 || ok==PS_IOERR || ok==PS_ERROR || ok==PS_PROTOCOL
2462 || ok==PS_LOCKBUSY || ok==PS_SMTP || ok==PS_DNS)
2466 if (phase == FORWARDING_WAIT || phase == LISTENER_WAIT)
2467 stem = _("%s error while delivering to SMTP host %s\n");
2469 stem = _("%s error while fetching from %s\n");
2470 report(stderr, stem, msg, ctl->server.pollname);
2474 /* execute wrapup command, if any */
2475 if (ctl->postconnect && (ok = system(ctl->postconnect)))
2477 report(stderr, _("post-connection command failed with status %d\n"), ok);
2478 if (ok == PS_SUCCESS)
2482 signal(SIGALRM, alrmsave);
2483 signal(SIGPIPE, pipesave);
2487 int do_protocol(ctl, proto)
2488 /* retrieve messages from server using given protocol method table */
2489 struct query *ctl; /* parsed options with merged-in defaults */
2490 const struct method *proto; /* protocol method table */
2495 if (ctl->server.authenticate == A_KERBEROS_V4)
2497 report(stderr, _("Kerberos V4 support not linked.\n"));
2500 #endif /* KERBEROS_V4 */
2503 if (ctl->server.authenticate == A_KERBEROS_V5)
2505 report(stderr, _("Kerberos V5 support not linked.\n"));
2508 #endif /* KERBEROS_V5 */
2510 /* lacking methods, there are some options that may fail */
2513 /* check for unsupported options */
2516 _("Option --flush is not supported with %s\n"),
2520 else if (ctl->fetchall) {
2522 _("Option --all is not supported with %s\n"),
2527 if (!proto->getsizes && NUM_SPECIFIED(ctl->limit))
2530 _("Option --limit is not supported with %s\n"),
2536 * If no expunge limit or we do expunges within the driver,
2537 * then just do one session, passing in any fetchlimit.
2539 if (proto->retry || !NUM_SPECIFIED(ctl->expunge))
2540 return(do_session(ctl, proto, NUM_VALUE_OUT(ctl->fetchlimit)));
2542 * There's an expunge limit, and it isn't handled in the driver itself.
2543 * OK; do multiple sessions, each fetching a limited # of messages.
2544 * Stop if the total count of retrieved messages exceeds ctl->fetchlimit
2545 * (if it was nonzero).
2551 int expunge = NUM_VALUE_OUT(ctl->expunge);
2552 int fetchlimit = NUM_VALUE_OUT(ctl->fetchlimit);
2555 ok = do_session(ctl, proto, expunge);
2556 totalcount += expunge;
2557 if (NUM_SPECIFIED(ctl->fetchlimit) && totalcount >= fetchlimit)
2559 if (ok != PS_LOCKBUSY)
2561 else if (lockouts >= MAX_LOCKOUTS)
2563 else /* ok == PS_LOCKBUSY */
2566 * Allow time for the server lock to release. if we
2567 * don't do this, we'll often hit a locked-mailbox
2568 * condition and fail.
2574 (ok == PS_MAXFETCH || ok == PS_LOCKBUSY);
2580 #if defined(HAVE_STDARG_H)
2581 void gen_send(int sock, const char *fmt, ... )
2583 void gen_send(sock, fmt, va_alist)
2584 int sock; /* socket to which server is connected */
2585 const char *fmt; /* printf-style format */
2588 /* assemble command in printf(3) style and send to the server */
2590 char buf [MSGBUFSIZE+1];
2593 if (protocol->tagged && !suppress_tags)
2594 (void) sprintf(buf, "%s ", GENSYM);
2598 #if defined(HAVE_STDARG_H)
2603 #ifdef HAVE_VSNPRINTF
2604 vsnprintf(buf + strlen(buf), sizeof(buf), fmt, ap);
2606 vsprintf(buf + strlen(buf), fmt, ap);
2610 strcat(buf, "\r\n");
2611 SockWrite(sock, buf, strlen(buf));
2613 if (outlevel >= O_MONITOR)
2617 if (shroud[0] && (cp = strstr(buf, shroud)))
2621 sp = cp + strlen(shroud);
2627 buf[strlen(buf)-2] = '\0';
2628 report(stdout, "%s> %s\n", protocol->name, buf);
2632 int gen_recv(sock, buf, size)
2633 /* get one line of input from the server */
2634 int sock; /* socket to which server is connected */
2635 char *buf; /* buffer to receive input */
2636 int size; /* length of buffer */
2638 int oldphase = phase; /* we don't have to be re-entrant */
2640 phase = SERVER_WAIT;
2641 set_timeout(mytimeout);
2642 if (SockRead(sock, buf, size) == -1)
2651 if (buf[strlen(buf)-1] == '\n')
2652 buf[strlen(buf)-1] = '\0';
2653 if (buf[strlen(buf)-1] == '\r')
2654 buf[strlen(buf)-1] = '\0';
2655 if (outlevel >= O_MONITOR)
2656 report(stdout, "%s< %s\n", protocol->name, buf);
2662 #if defined(HAVE_STDARG_H)
2663 int gen_transact(int sock, const char *fmt, ... )
2665 int gen_transact(int sock, fmt, va_alist)
2666 int sock; /* socket to which server is connected */
2667 const char *fmt; /* printf-style format */
2670 /* assemble command in printf(3) style, send to server, accept a response */
2673 char buf [MSGBUFSIZE+1];
2675 int oldphase = phase; /* we don't have to be re-entrant */
2677 phase = SERVER_WAIT;
2679 if (protocol->tagged && !suppress_tags)
2680 (void) sprintf(buf, "%s ", GENSYM);
2684 #if defined(HAVE_STDARG_H)
2689 #ifdef HAVE_VSNPRINTF
2690 vsnprintf(buf + strlen(buf), sizeof(buf), fmt, ap);
2692 vsprintf(buf + strlen(buf), fmt, ap);
2696 strcat(buf, "\r\n");
2697 SockWrite(sock, buf, strlen(buf));
2699 if (outlevel >= O_MONITOR)
2703 if (shroud && shroud[0] && (cp = strstr(buf, shroud)))
2707 sp = cp + strlen(shroud);
2713 buf[strlen(buf)-1] = '\0';
2714 report(stdout, "%s> %s\n", protocol->name, buf);
2717 /* we presume this does its own response echoing */
2718 ok = (protocol->parse_response)(sock, buf);
2724 /* driver.c ends here */