#include <setjmp.h>
#include <errno.h>
#include <string.h>
-#ifdef HAVE_MEMORY_H
-#include <memory.h>
-#endif /* HAVE_MEMORY_H */
-#if defined(STDC_HEADERS)
#include <stdlib.h>
-#endif
-#if defined(HAVE_UNISTD_H)
+#include <limits.h>
#include <unistd.h>
-#endif
-#if defined(HAVE_SYS_ITIMER_H)
-#include <sys/itimer.h>
-#endif
-#include <sys/time.h>
#include <signal.h>
+#include <sys/wait.h>
+#include <sys/time.h>
-#ifdef HAVE_NET_SOCKET_H
-#include <net/socket.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#ifdef HAVE_PKG_hesiod
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <hesiod.h>
+#ifdef __cplusplus
+}
+#endif
#endif
-#ifdef HAVE_RES_SEARCH
-#include <netdb.h>
-#include "mx.h"
-#endif /* HAVE_RES_SEARCH */
+#include <langinfo.h>
#include "kerberos.h"
-#ifdef KERBEROS_V4
-#include <netinet/in.h>
-#endif /* KERBEROS_V4 */
-#include "i18n.h"
+#include "gettext.h"
+#include "socket.h"
#include "fetchmail.h"
+#include "getaddrinfo.h"
#include "tunable.h"
+#include "sdump.h"
+
/* throw types for runtime errors */
#define THROW_TIMEOUT 1 /* server timed out */
-#define THROW_SIGPIPE 2 /* SIGPIPE on stream socket */
-static int timeoutcount; /* count consecutive timeouts */
+/* magic values for the message length array */
+#define MSGLEN_UNKNOWN 0 /* length unknown (0 is impossible) */
+#define MSGLEN_INVALID -1 /* length passed back is invalid */
+#define MSGLEN_TOOLARGE -2 /* message is too large */
+#define MSGLEN_OLD -3 /* message is old */
+
+int pass; /* how many times have we re-polled? */
+int stage; /* where are we? */
+int phase; /* where are we, for error-logging purposes? */
+int batchcount; /* count of messages sent in current batch */
+flag peek_capable; /* can we peek for better error recovery? */
+int mailserver_socket_temp = -1; /* socket to free if connect timeout */
+
+struct addrinfo *ai0, *ai1; /* clean these up after signal */
-static jmp_buf restart;
+static volatile int timeoutcount = 0; /* count consecutive timeouts */
+static volatile int idletimeout = 0; /* timeout occured in idle stage? */
+
+static sigjmp_buf restart;
+
+int is_idletimeout(void)
+/* last timeout occured in idle stage? */
+{
+ return idletimeout;
+}
+
+void resetidletimeout(void)
+{
+ idletimeout = 0;
+}
void set_timeout(int timeleft)
/* reset the nonresponse-timeout */
{
-#if !defined(__EMX__) && !defined(__BEOS__)
struct itimerval ntimeout;
if (timeleft == 0)
ntimeout.it_value.tv_sec = timeleft;
ntimeout.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &ntimeout, (struct itimerval *)NULL);
-#endif
}
static void timeout_handler (int signal)
/* handle SIGALRM signal indicating a server timeout */
{
- timeoutcount++;
- longjmp(restart, THROW_TIMEOUT);
+ (void)signal;
+ if(stage != STAGE_IDLE) {
+ timeoutcount++;
+ /* XXX FIXME: this siglongjmp must die - it's not safe to be
+ * called from a function handler and breaks, for instance,
+ * getaddrinfo() */
+ siglongjmp(restart, THROW_TIMEOUT);
+ } else
+ idletimeout = 1;
}
-static void sigpipe_handler (int signal)
-/* handle SIGPIPE signal indicating a broken stream socket */
-{
- longjmp(restart, THROW_SIGPIPE);
-}
+#define CLEANUP_TIMEOUT 60 /* maximum timeout during cleanup */
-#ifdef KERBEROS_V4
-static int kerberos_auth(socket, canonical, principal)
-/* authenticate to the server host using Kerberos V4 */
-int socket; /* socket to server host */
-char *canonical; /* server name */
-char *principal;
+static int cleanupSockClose (int fd)
+/* close sockets in maximum CLEANUP_TIMEOUT seconds during cleanup */
{
- char * host_primary;
- KTEXT ticket;
- MSG_DAT msg_data;
- CREDENTIALS cred;
- Key_schedule schedule;
- int rem;
- char * prin_copy = (char *) NULL;
- char * prin = (char *) NULL;
- char * inst = (char *) NULL;
- char * realm = (char *) NULL;
-
- if (principal != (char *)NULL && *principal)
- {
- char *cp;
- prin = prin_copy = xstrdup(principal);
- for (cp = prin_copy; *cp && *cp != '.'; ++cp)
- ;
- if (*cp)
- {
- *cp++ = '\0';
- inst = cp;
- while (*cp && *cp != '@')
- ++cp;
- if (*cp)
- {
- *cp++ = '\0';
- realm = cp;
- }
- }
- }
-
- xalloca(ticket, KTEXT, sizeof (KTEXT_ST));
- rem = (krb_sendauth (0L, socket, ticket,
- prin ? prin : "pop",
- inst ? inst : canonical,
- realm ? realm : ((char *) (krb_realmofhost (canonical))),
- ((unsigned long) 0),
- (&msg_data),
- (&cred),
- (schedule),
- ((struct sockaddr_in *) 0),
- ((struct sockaddr_in *) 0),
- "KPOPV0.1"));
- if (prin_copy)
- {
- free(prin_copy);
- }
- if (rem != KSUCCESS)
- {
- report(stderr, _("kerberos error %s\n"), (krb_get_err_text (rem)));
- return (PS_AUTHFAIL);
- }
- return (0);
+ int scerror;
+ SIGHANDLERTYPE alrmsave;
+ alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
+ set_timeout(CLEANUP_TIMEOUT);
+ scerror = SockClose(fd);
+ set_timeout(0);
+ set_signal_handler(SIGALRM, alrmsave);
+ return (scerror);
}
-#endif /* KERBEROS_V4 */
#ifdef KERBEROS_V5
-static int kerberos5_auth(socket, canonical)
-/* authenticate to the server host using Kerberos V5 */
-int socket; /* socket to server host */
-const char *canonical; /* server name */
+/** authenticate to the server host using Kerberos V5 */
+static int kerberos5_auth(int socket /** socket to server host */, const char *canonical /** server name */)
{
krb5_error_code retval;
krb5_context context;
krb5_auth_context auth_context = NULL;
krb5_init_context(&context);
- krb5_init_ets(context);
krb5_auth_con_init(context, &auth_context);
- if (retval = krb5_cc_default(context, &ccdef)) {
+ if ((retval = krb5_cc_default(context, &ccdef))) {
report(stderr, "krb5_cc_default: %s\n", error_message(retval));
return(PS_ERROR);
}
- if (retval = krb5_cc_get_principal(context, ccdef, &client)) {
+ if ((retval = krb5_cc_get_principal(context, ccdef, &client))) {
report(stderr, "krb5_cc_get_principal: %s\n", error_message(retval));
return(PS_ERROR);
}
- if (retval = krb5_sname_to_principal(context, canonical, "pop",
+ if ((retval = krb5_sname_to_principal(context, canonical, "pop",
KRB5_NT_UNKNOWN,
- &server)) {
+ &server))) {
report(stderr, "krb5_sname_to_principal: %s\n", error_message(retval));
return(PS_ERROR);
}
if (retval) {
#ifdef HEIMDAL
if (err_ret && err_ret->e_text) {
- report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
- error_message(retval),
- err_ret->e_text);
+ char *t = err_ret->e_text;
+ char *tt = sdump(t, strlen(t));
+ report(stderr, GT_("krb5_sendauth: %s [server says '%s']\n"),
+ error_message(retval), tt);
+ free(tt);
#else
if (err_ret && err_ret->text.length) {
- report(stderr, _("krb5_sendauth: %s [server says '%*s'] \n"),
- error_message(retval),
- err_ret->text.length,
- err_ret->text.data);
+ char *tt = sdump(err_ret->text.data, err_ret->text.length);
+ report(stderr, GT_("krb5_sendauth: %s [server says '%s']\n"),
+ error_message(retval), tt);
+ free(tt);
#endif
krb5_free_error(context, err_ret);
} else
* but it's not a disaster, either, since the skipped mail will not
* be deleted.
*/
- if (open_warning_by_mail(ctl, (struct msgblk *)NULL))
+ if (open_warning_by_mail(ctl))
return;
- stuff_warning(ctl,
- _("Subject: Fetchmail oversized-messages warning.\r\n"
- "\r\n"
- "The following oversized messages remain on the mail server %s:"),
- ctl->server.pollname);
-
+ stuff_warning(iana_charset, ctl,
+ GT_("Subject: Fetchmail oversized-messages warning"));
+ stuff_warning(NULL, ctl, "%s", "");
+ if (ctl->limitflush)
+ stuff_warning(NULL, ctl,
+ GT_("The following oversized messages were deleted on server %s account %s:"),
+ ctl->server.pollname, ctl->remotename);
+ else
+ stuff_warning(NULL, ctl,
+ GT_("The following oversized messages remain on server %s account %s:"),
+ ctl->server.pollname, ctl->remotename);
+
+ stuff_warning(NULL, ctl, "%s", "");
+
if (run.poll_interval == 0)
max_warning_poll_count = 0;
else
{
nbr = current->val.status.mark;
size = atoi(current->id);
- stuff_warning(ctl,
- _("\t%d msg %d octets long skipped by fetchmail.\r\n"),
- nbr, size);
+ if (ctl->limitflush)
+ stuff_warning(NULL, ctl,
+ ngettext(" %d message %d octets long deleted by fetchmail.",
+ " %d messages %d octets long deleted by fetchmail.", nbr),
+ nbr, size);
+ else
+ stuff_warning(NULL, ctl,
+ ngettext(" %d message %d octets long skipped by fetchmail.",
+ " %d messages %d octets long skipped by fetchmail.", nbr),
+ nbr, size);
}
current->val.status.num++;
current->val.status.mark = 0;
current->val.status.num = 0;
}
+ stuff_warning(NULL, ctl, "%s", "");
+
close_warning_by_mail(ctl, (struct msgblk *)NULL);
}
-static int do_session(ctl, proto, maxfetch)
+static void mark_oversized(struct query *ctl, int size)
+/* mark a message oversized */
+{
+ struct idlist *current=NULL, *tmp=NULL;
+ char sizestr[32];
+ int cnt;
+
+ /* convert size to string */
+ snprintf(sizestr, sizeof(sizestr), "%d", size);
+
+ /* build a list of skipped messages
+ * val.id = size of msg (string cnvt)
+ * val.status.num = warning_poll_count
+ * val.status.mask = nbr of msg this size
+ */
+
+ current = ctl->skipped;
+
+ /* initialise warning_poll_count to the
+ * current value so that all new msg will
+ * be included in the next mail
+ */
+ cnt = current ? current->val.status.num : 0;
+
+ /* if entry exists, increment the count */
+ if (current && (tmp = str_in_list(¤t, sizestr, FALSE)))
+ {
+ tmp->val.status.mark++;
+ }
+ /* otherwise, create a new entry */
+ /* initialise with current poll count */
+ else
+ {
+ tmp = save_str(&ctl->skipped, sizestr, 1);
+ tmp->val.status.num = cnt;
+ }
+}
+
+static int eat_trailer(int sock, struct query *ctl)
+{
+ /* we only need this LF if we're printing ticker dots
+ * AND we are dumping protocol traces. */
+ if (outlevel >= O_VERBOSE && want_progress()) fputc('\n', stdout);
+ return (ctl->server.base_protocol->trail)(sock, ctl, tag);
+}
+
+static int fetch_messages(int mailserver_socket, struct query *ctl,
+ int count, int **msgsizes, int maxfetch,
+ int *fetches, int *dispatches, int *deletions,
+ int *transient_errors)
+/* fetch messages in lockstep mode */
+{
+ flag force_retrieval;
+ int num, firstnum = 1, lastnum = 0, err, len;
+ int fetchsizelimit = ctl->fetchsizelimit;
+ int msgsize;
+ int initialfetches = *fetches;
+
+ if (ctl->server.base_protocol->getpartialsizes && NUM_NONZERO(fetchsizelimit))
+ {
+ /* for POP3, we can get the size of one mail only! Unfortunately, this
+ * protocol specific test cannot be done elsewhere as the protocol
+ * could be "auto". */
+ switch (ctl->server.protocol)
+ {
+ case P_POP3:
+ fetchsizelimit = 1;
+ }
+
+ /* Time to allocate memory to store the sizes */
+ xfree(*msgsizes);
+ *msgsizes = (int *)xmalloc(sizeof(int) * fetchsizelimit);
+ }
+
+ /*
+ * What forces this code is that in
+ * IMAP2bis you can't fetch a message without
+ * having it marked `seen'. In POP3 and IMAP4, on the
+ * other hand, you can (peek_capable is set by
+ * each driver module to convey this; it's not a
+ * method constant because of the difference between
+ * IMAP2bis and IMAP4, and because POP3 doesn't peek
+ * if fetchall is on).
+ *
+ * The result of being unable to peek is that if there's
+ * any kind of transient error (DNS lookup failure, or
+ * sendmail refusing delivery due to process-table limits)
+ * the message will be marked "seen" on the server without
+ * having been delivered. This is not a big problem if
+ * fetchmail is running in foreground, because the user
+ * will see a "skipped" message when it next runs and get
+ * clued in.
+ *
+ * But in daemon mode this leads to the message
+ * being silently ignored forever. This is not
+ * acceptable.
+ *
+ * We compensate for this by checking the error
+ * count from the previous pass and forcing all
+ * messages to be considered new if it's nonzero.
+ */
+ force_retrieval = !peek_capable && (ctl->errcount > 0);
+
+ for (num = 1; num <= count; num++)
+ {
+ flag suppress_delete = FALSE;
+ flag suppress_forward = FALSE;
+ flag suppress_readbody = FALSE;
+ flag retained = FALSE;
+ int msgcode = MSGLEN_UNKNOWN;
+
+ /* check if the message is old
+ * Note: the size of the message may not be known here */
+ if (ctl->fetchall || force_retrieval) {
+ /* empty */
+ } else {
+ if (ctl->server.base_protocol->is_old && (ctl->server.base_protocol->is_old)(mailserver_socket,ctl,num)) {
+ msgcode = MSGLEN_OLD;
+ }
+ }
+ if (msgcode == MSGLEN_OLD)
+ {
+ /*
+ * To avoid flooding the logs when using --keep, report
+ * skipping for old messages only when --flush is on.
+ */
+ if (outlevel > O_SILENT && ctl->flush)
+ {
+ report_build(stdout,
+ GT_("skipping message %s@%s:%d"),
+ ctl->remotename, ctl->server.truename, num);
+ }
+
+ goto flagthemail;
+ }
+
+ if (ctl->server.base_protocol->getpartialsizes && NUM_NONZERO(fetchsizelimit) &&
+ lastnum < num)
+ {
+ /* Instead of getting the sizes of all mails at the start, we get
+ * the sizes in blocks of fetchsizelimit. This leads to better
+ * performance when there are too many mails (say, 10000) in
+ * the mailbox and either we are not getting all the mails at
+ * one go (--fetchlimit 100) or there is a frequent socket
+ * error while just getting the sizes of all mails! */
+
+ int i;
+ int oldstage = stage;
+ firstnum = num;
+ lastnum = num + fetchsizelimit - 1;
+ if (lastnum > count)
+ lastnum = count;
+ for (i = 0; i < fetchsizelimit; i++)
+ (*msgsizes)[i] = 0;
+
+ stage = STAGE_GETSIZES;
+ err = (ctl->server.base_protocol->getpartialsizes)(mailserver_socket, num, lastnum, *msgsizes);
+ if (err != 0) {
+ return err;
+ }
+ stage = oldstage;
+ }
+
+ msgsize = *msgsizes ? (*msgsizes)[num-firstnum] : 0;
+
+ /* check if the message is oversized */
+ if (NUM_NONZERO(ctl->limit) && (msgsize > ctl->limit))
+ msgcode = MSGLEN_TOOLARGE;
+/* else if (msgsize == 512)
+ msgcode = MSGLEN_OLD; (hmh) sample code to skip message */
+
+ if (msgcode < 0)
+ {
+ if (msgcode == MSGLEN_TOOLARGE)
+ {
+ mark_oversized(ctl, msgsize);
+ if (!ctl->limitflush)
+ suppress_delete = TRUE;
+ }
+ if (outlevel > O_SILENT)
+ {
+ /* old messages are already handled above */
+ report_build(stdout,
+ GT_("skipping message %s@%s:%d (%d octets)"),
+ ctl->remotename, ctl->server.truename, num,
+ msgsize);
+ switch (msgcode)
+ {
+ case MSGLEN_INVALID:
+ /*
+ * Invalid lengths are produced by Post Office/NT's
+ * annoying habit of randomly prepending bogus
+ * LIST items of length -1. Patrick Audley
+ * <paudley@pobox.com> tells us: LIST shows a
+ * size of -1, RETR and TOP return "-ERR
+ * System error - couldn't open message", and
+ * DELE succeeds but doesn't actually delete
+ * the message.
+ */
+ report_build(stdout, GT_(" (length -1)"));
+ break;
+ case MSGLEN_TOOLARGE:
+ report_build(stdout, GT_(" (oversized)"));
+ break;
+ }
+ }
+ }
+ else
+ {
+ /* XXX FIXME: make this one variable, wholesize and
+ separatefetchbody query the same variable just with
+ inverted logic */
+ flag wholesize = !ctl->server.base_protocol->fetch_body;
+ flag separatefetchbody = (ctl->server.base_protocol->fetch_body) ? TRUE : FALSE;
+
+ /* request a message */
+ err = (ctl->server.base_protocol->fetch_headers)(mailserver_socket,ctl,num, &len);
+ if (err == PS_TRANSIENT) /* server is probably Exchange */
+ {
+ report(stdout,
+ GT_("couldn't fetch headers, message %s@%s:%d (%d octets)\n"),
+ ctl->remotename, ctl->server.truename, num,
+ msgsize);
+ (*transient_errors)++;
+ continue;
+ }
+ else if (err != 0)
+ return(err);
+
+ /* -1 means we didn't see a size in the response */
+ if (len == -1)
+ {
+ len = msgsize;
+ wholesize = TRUE;
+ }
+
+ if (outlevel > O_SILENT)
+ {
+ report_build(stdout, GT_("reading message %s@%s:%d of %d"),
+ ctl->remotename, ctl->server.truename,
+ num, count);
+
+ if (len > 0)
+ report_build(stdout, wholesize ? GT_(" (%d octets)")
+ : GT_(" (%d header octets)"), len);
+ if (want_progress()) {
+ /* flush and add a blank to append ticker dots */
+ report_flush(stdout);
+ putchar(' ');
+ }
+ }
+
+ /*
+ * Read the message headers and ship them to the
+ * output sink.
+ */
+ err = readheaders(mailserver_socket, len, msgsize,
+ ctl, num,
+ /* pass the suppress_readbody flag only if the underlying
+ * protocol does not fetch the body separately */
+ separatefetchbody ? 0 : &suppress_readbody);
+
+ if (err == PS_RETAINED)
+ suppress_forward = suppress_delete = retained = TRUE;
+ else if (err == PS_TRANSIENT)
+ {
+ suppress_delete = suppress_forward = TRUE;
+ (*transient_errors)++;
+ }
+ else if (err == PS_REFUSED)
+ suppress_forward = TRUE;
+ else if (err)
+ return(err);
+
+ /* tell server we got it OK and resynchronize */
+ if (separatefetchbody && ctl->server.base_protocol->trail)
+ {
+ err = eat_trailer(mailserver_socket, ctl);
+ if (err) return(err);
+ }
+
+ /* do not read the body which is not being forwarded only if
+ * the underlying protocol allows the body to be fetched
+ * separately */
+ if (separatefetchbody && suppress_forward)
+ suppress_readbody = TRUE;
+
+ /*
+ * If we're using IMAP4 or something else that
+ * can fetch headers separately from bodies,
+ * it's time to request the body now. This
+ * fetch may be skipped if we got an anti-spam
+ * or other PS_REFUSED error response during
+ * readheaders.
+ */
+ if (!suppress_readbody)
+ {
+ if (separatefetchbody)
+ {
+ len = -1;
+ if ((err=(ctl->server.base_protocol->fetch_body)(mailserver_socket,ctl,num,&len))) {
+ if (err == PS_ERROR && ctl->server.retrieveerror) {
+ /*
+ * Mark a message with a protocol error as seen.
+ * This can be used to see which messages we've attempted
+ * to download, but failed.
+ */
+ if (ctl->server.retrieveerror == RE_MARKSEEN) {
+ if ((ctl->server.base_protocol->mark_seen)(mailserver_socket,ctl,num)) {
+ return(err);
+ }
+ }
+
+ if (ctl->server.retrieveerror != RE_ABORT) {
+ /*
+ * Do not abort download session. Continue with the next message.
+ *
+ * Prevents a malformed message from blocking all other messages
+ * behind it in the mailbox from being downloaded.
+ *
+ * Reconnect to SMTP to force this incomplete message to be dropped.
+ * Required because we've already begun the DATA portion of the
+ * interaction with the SMTP server (commands are ignored/
+ * considered part of the message data).
+ */
+ abort_message_sink(ctl);
+
+ // Ensure we don't delete the failed message from the server.
+ suppress_delete = TRUE;
+
+ // Bookkeeping required before next message can be downloaded.
+ goto flagthemail;
+ }
+ }
+
+ return(err);
+ }
+
+ /*
+ * Work around a bug in Novell's
+ * broken GroupWise IMAP server;
+ * its body FETCH response is missing
+ * the required length for the data
+ * string. This violates RFC2060.
+ */
+ if (len == -1)
+ len = msgsize - msgblk.msglen;
+ if (!wholesize) {
+ if (outlevel > O_SILENT)
+ report_build(stdout,
+ GT_(" (%d body octets)"), len);
+ if (want_progress()) {
+ report_flush(stdout);
+ putchar(' ');
+ }
+ }
+ }
+
+ /* process the body now */
+ err = readbody(mailserver_socket,
+ ctl,
+ !suppress_forward,
+ len);
+
+ if (err == PS_TRANSIENT)
+ {
+ suppress_delete = suppress_forward = TRUE;
+ (*transient_errors)++;
+ }
+ else if (err)
+ return(err);
+
+ /* tell server we got it OK and resynchronize */
+ if (ctl->server.base_protocol->trail) {
+ err = eat_trailer(mailserver_socket, ctl);
+ if (err) return(err);
+ }
+ }
+
+ /* count # messages forwarded on this pass */
+ if (!suppress_forward)
+ (*dispatches)++;
+
+ /*
+ * Check to see if the numbers matched?
+ *
+ * Yes, some servers foo this up horribly.
+ * All IMAP servers seem to get it right, and
+ * so does Eudora QPOP at least in 2.xx
+ * versions.
+ *
+ * Microsoft Exchange gets it completely
+ * wrong, reporting compressed rather than
+ * actual sizes (so the actual length of
+ * message is longer than the reported size).
+ * Another fine example of Microsoft brain death!
+ *
+ * Some older POP servers, like the old UCB
+ * POP server and the pre-QPOP QUALCOMM
+ * versions, report a longer size in the LIST
+ * response than actually gets shipped up.
+ * It's unclear what is going on here, as the
+ * QUALCOMM server (at least) seems to be
+ * reporting the on-disk size correctly.
+ *
+ * qmail-pop3d also goofs up message sizes and does not
+ * count the line end characters properly.
+ */
+ if (msgblk.msglen != msgsize)
+ {
+ if (outlevel >= O_DEBUG)
+ report(stdout,
+ GT_("message %s@%s:%d was not the expected length (%d actual != %d expected)\n"),
+ ctl->remotename, ctl->server.truename, num,
+ msgblk.msglen, msgsize);
+ }
+
+ /* end-of-message processing starts here */
+ if (!close_sink(ctl, &msgblk, !suppress_forward))
+ {
+ ctl->errcount++;
+ suppress_delete = TRUE;
+ }
+ if (!retained)
+ (*fetches)++;
+ }
+
+flagthemail:
+ /*
+ * At this point in flow of control,
+ * either we've bombed on a protocol error
+ * or had delivery refused by the SMTP server
+ * or we've seen `accepted for delivery' and the message is shipped.
+ * It's safe to mark the message seen and delete it on the server now.
+ */
+
+ /* in softbounce mode, suppress deletion and marking as seen */
+ if (suppress_forward)
+ suppress_delete = suppress_delete || run.softbounce;
+
+ /* maybe we delete this message now? */
+ if (retained)
+ {
+ if (outlevel > O_SILENT)
+ report_complete(stdout, GT_(" retained\n"));
+ }
+ else if (ctl->server.base_protocol->delete_msg
+ && !suppress_delete
+ && ((msgcode >= 0 && !ctl->keep)
+ || (msgcode == MSGLEN_OLD && ctl->flush)
+ || (msgcode == MSGLEN_TOOLARGE && ctl->limitflush)))
+ {
+ (*deletions)++;
+ if (outlevel > O_SILENT)
+ report_complete(stdout, GT_(" flushed\n"));
+ err = (ctl->server.base_protocol->delete_msg)(mailserver_socket, ctl, num);
+ if (err != 0)
+ return(err);
+ }
+ else
+ {
+ /*
+ * To avoid flooding the logs when using --keep, report
+ * skipping of new messages only.
+ */
+ if (outlevel > O_SILENT && msgcode != MSGLEN_OLD)
+ report_complete(stdout, GT_(" not flushed\n"));
+
+ /* maybe we mark this message as seen now? */
+ if (ctl->server.base_protocol->mark_seen
+ && !suppress_delete
+ && (msgcode >= 0 && ctl->keep))
+ {
+ err = (ctl->server.base_protocol->mark_seen)(mailserver_socket, ctl, num);
+ if (err != 0)
+ return(err);
+ }
+ }
+
+ /* perhaps this as many as we're ready to handle */
+ if (maxfetch && maxfetch <= *fetches && num < count)
+ {
+ int remcount = count - (*fetches - initialfetches);
+ report(stdout,
+ ngettext("fetchlimit %d reached; %d message left on server %s account %s\n",
+ "fetchlimit %d reached; %d messages left on server %s account %s\n", remcount),
+ maxfetch, remcount, ctl->server.truename, ctl->remotename);
+ return(PS_MAXFETCH);
+ }
+ } /* for (num = 1; num <= count; num++) */
+
+ return(PS_SUCCESS);
+}
+
/* retrieve messages from server using given protocol method table */
-struct query *ctl; /* parsed options with merged-in defaults */
-const struct method *proto; /* protocol method table */
-const int maxfetch; /* maximum number of messages to fetch */
+static int do_session(
+ /* parsed options with merged-in defaults */
+ struct query *ctl,
+ /* protocol method table */
+ const struct method *proto,
+ /* maximum number of messages to fetch */
+ const int maxfetch)
{
- int js;
-#ifdef HAVE_VOLATILE
- volatile int ok, mailserver_socket = -1; /* pacifies -Wall */
-#else
- int ok, mailserver_socket = -1;
-#endif /* HAVE_VOLATILE */
+ static int *msgsizes;
+ volatile int err, mailserver_socket = -1; /* pacifies -Wall */
+ int tmperr;
+ int deletions = 0, js;
const char *msg;
- void (*pipesave)(int);
- void (*alrmsave)(int);
- struct idlist *current=NULL, *tmp=NULL;
+ SIGHANDLERTYPE alrmsave;
ctl->server.base_protocol = proto;
+ msgsizes = NULL;
pass = 0;
- ok = 0;
+ err = 0;
init_transact(proto);
/* set up the server-nonresponse timeout */
- alrmsave = signal(SIGALRM, timeout_handler);
+ alrmsave = set_signal_handler(SIGALRM, timeout_handler);
mytimeout = ctl->server.timeout;
- /* set up the broken-pipe timeout */
- pipesave = signal(SIGPIPE, sigpipe_handler);
-
- if ((js = setjmp(restart)))
+ if ((js = sigsetjmp(restart,1)))
{
-#ifdef HAVE_SIGPROCMASK
- /*
- * Don't rely on setjmp() to restore the blocked-signal mask.
- * It does this under BSD but is required not to under POSIX.
- *
- * If your Unix doesn't have sigprocmask, better hope it has
- * BSD-like behavior. Otherwise you may see fetchmail get
- * permanently wedged after a second timeout on a bad read,
- * because alarm signals were blocked after the first.
- */
+ /* exception caught */
sigset_t allsigs;
sigfillset(&allsigs);
sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
-#endif /* HAVE_SIGPROCMASK */
- if (js == THROW_SIGPIPE)
- {
- signal(SIGPIPE, SIG_IGN);
- report(stdout,
- _("SIGPIPE thrown from an MDA or a stream socket error\n"));
- ok = PS_SOCKET;
- goto cleanUp;
+ if (ai0) {
+ fm_freeaddrinfo(ai0); ai0 = NULL;
}
- else if (js == THROW_TIMEOUT)
+
+ if (ai1) {
+ fm_freeaddrinfo(ai1); ai1 = NULL;
+ }
+
+ if (js == THROW_TIMEOUT)
{
if (phase == OPEN_WAIT)
report(stdout,
- _("timeout after %d seconds waiting to connect to server %s.\n"),
+ GT_("timeout after %d seconds waiting to connect to server %s.\n"),
ctl->server.timeout, ctl->server.pollname);
else if (phase == SERVER_WAIT)
report(stdout,
- _("timeout after %d seconds waiting for server %s.\n"),
+ GT_("timeout after %d seconds waiting for server %s.\n"),
ctl->server.timeout, ctl->server.pollname);
else if (phase == FORWARDING_WAIT)
report(stdout,
- _("timeout after %d seconds waiting for %s.\n"),
+ GT_("timeout after %d seconds waiting for %s.\n"),
ctl->server.timeout,
ctl->mda ? "MDA" : "SMTP");
else if (phase == LISTENER_WAIT)
report(stdout,
- _("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
+ GT_("timeout after %d seconds waiting for listener to respond.\n"), ctl->server.timeout);
else
report(stdout,
- _("timeout after %d seconds.\n"), ctl->server.timeout);
+ GT_("timeout after %d seconds.\n"), ctl->server.timeout);
/*
* If we've exceeded our threshold for consecutive timeouts,
* timeouts just mean the frequency of mail is low.
*/
if (timeoutcount > MAX_TIMEOUTS
- && !open_warning_by_mail(ctl, (struct msgblk *)NULL))
+ && !open_warning_by_mail(ctl))
{
- stuff_warning(ctl,
- _("Subject: fetchmail sees repeated timeouts\r\n"));
- stuff_warning(ctl,
- _("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\r\n"),
+ stuff_warning(iana_charset, ctl,
+ GT_("Subject: fetchmail sees repeated timeouts"));
+ stuff_warning(NULL, ctl, "%s", "");
+ stuff_warning(NULL, ctl,
+ GT_("Fetchmail saw more than %d timeouts while attempting to get mail from %s@%s.\n"),
MAX_TIMEOUTS,
- ctl->remotename,
- ctl->server.truename);
- stuff_warning(ctl,
- _("This could mean that your mailserver is stuck, or that your SMTP\r\n" \
- "server is wedged, or that your mailbox file on the server has been\r\n" \
- "corrupted by a server error. You can run `fetchmail -v -v' to\r\n" \
- "diagnose the problem.\r\n\r\n" \
- "Fetchmail won't poll this mailbox again until you restart it.\r\n"));
+ ctl->remotename, ctl->server.truename);
+ stuff_warning(NULL, ctl,
+ GT_("This could mean that your mailserver is stuck, or that your SMTP\n" \
+ "server is wedged, or that your mailbox file on the server has been\n" \
+ "corrupted by a server error. You can run `fetchmail -v -v' to\n" \
+ "diagnose the problem.\n\n" \
+ "Fetchmail won't poll this mailbox again until you restart it.\n"));
close_warning_by_mail(ctl, (struct msgblk *)NULL);
ctl->wedged = TRUE;
}
-
- ok = PS_ERROR;
}
- /* try to clean up all streams */
- release_sink(ctl);
- if (ctl->smtp_socket != -1)
- SockClose(ctl->smtp_socket);
- if (mailserver_socket != -1)
- SockClose(mailserver_socket);
+ err = PS_SOCKET;
+ goto cleanUp;
}
else
{
+ /* sigsetjmp returned zero -> normal operation */
char buf[MSGBUFSIZE+1], *realhost;
- int len, num, count, new, bytes, deletions = 0, *msgsizes = NULL;
-#if INET6_ENABLE
- int fetches, dispatches, oldphase;
-#else /* INET6_ENABLE */
- int port, fetches, dispatches, oldphase;
-#endif /* INET6_ENABLE */
+ int count, newm, bytes;
+ int fetches, dispatches, transient_errors, oldphase;
struct idlist *idp;
/* execute pre-initialization command, if any */
- if (ctl->preconnect && (ok = system(ctl->preconnect)))
+ if (ctl->preconnect && (err = system(ctl->preconnect)))
{
- report(stderr,
- _("pre-connection command failed with status %d\n"), ok);
- ok = PS_SYNTAX;
+ if (WIFSIGNALED(err))
+ report(stderr,
+ GT_("pre-connection command terminated with signal %d\n"), WTERMSIG(err));
+ else
+ report(stderr,
+ GT_("pre-connection command failed with status %d\n"), WEXITSTATUS(err));
+ err = PS_SYNTAX;
goto closeUp;
}
oldphase = phase;
phase = OPEN_WAIT;
set_timeout(mytimeout);
-#if !INET6_ENABLE
-#ifdef SSL_ENABLE
- port = ctl->server.port ? ctl->server.port : ( ctl->use_ssl ? ctl->server.base_protocol->sslport : ctl->server.base_protocol->port );
-#else
- port = ctl->server.port ? ctl->server.port : ctl->server.base_protocol->port;
+
+#ifdef HAVE_PKG_hesiod
+ /* If either the pollname or vianame are "hesiod" we want to
+ lookup the user's hesiod pobox host */
+ if (!strcasecmp(ctl->server.queryname, "hesiod")) {
+ struct hes_postoffice *hes_p;
+ hes_p = hes_getmailhost(ctl->remotename);
+ if (hes_p != NULL && strcmp(hes_p->po_type, "POP") == 0) {
+ free(ctl->server.queryname);
+ ctl->server.queryname = xstrdup(hes_p->po_host);
+ if (ctl->server.via)
+ free(ctl->server.via);
+ ctl->server.via = xstrdup(hes_p->po_host);
+ } else {
+ report(stderr,
+ GT_("couldn't find HESIOD pobox for %s\n"),
+ ctl->remotename);
+ }
+ }
+#endif /* HESIOD */
+
+ /*
+ * Canonicalize the server truename for later use. This also
+ * functions as a probe for whether the mailserver is accessible.
+ * We try it on each poll cycle until we get a result. This way,
+ * fetchmail won't fail if started up when the network is inaccessible.
+ */
+ if (ctl->server.dns && !ctl->server.trueaddr)
+ {
+ if (ctl->server.lead_server)
+ {
+ char *leadname = ctl->server.lead_server->truename;
+
+ /* prevent core dump from ill-formed or duplicate entry */
+ if (!leadname)
+ {
+ report(stderr, GT_("Lead server has no name.\n"));
+ err = PS_DNS;
+ set_timeout(0);
+ phase = oldphase;
+ goto closeUp;
+ }
+
+ xfree(ctl->server.truename);
+ ctl->server.truename = xstrdup(leadname);
+ }
+ else
+ {
+ struct addrinfo hints, *res;
+ int error;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_flags = AI_CANONNAME;
+#ifdef AI_ADDRCONFIG
+ hints.ai_flags |= AI_ADDRCONFIG;
#endif
-#endif /* !INET6_ENABLE */
+
+ error = fm_getaddrinfo(ctl->server.queryname, NULL, &hints, &res);
+ if (error)
+ {
+ report(stderr,
+ GT_("couldn't find canonical DNS name of %s (%s): %s\n"),
+ ctl->server.pollname, ctl->server.queryname,
+ gai_strerror(error));
+ err = PS_DNS;
+ set_timeout(0);
+ phase = oldphase;
+ goto closeUp;
+ }
+ else
+ {
+ xfree(ctl->server.truename);
+ /* Older FreeBSD versions return NULL in ai_canonname
+ * if they cannot canonicalize, rather than copying
+ * the queryname here, as IEEE Std 1003.1-2001
+ * requires. Work around NULL. */
+ if (res->ai_canonname != NULL) {
+ ctl->server.truename = xstrdup(res->ai_canonname);
+ } else {
+ ctl->server.truename = xstrdup(ctl->server.queryname);
+ }
+ ctl->server.trueaddr = (struct sockaddr *)xmalloc(res->ai_addrlen);
+ ctl->server.trueaddr_len = res->ai_addrlen;
+ memcpy(ctl->server.trueaddr, res->ai_addr, res->ai_addrlen);
+ fm_freeaddrinfo(res);
+ }
+ }
+ }
+
realhost = ctl->server.via ? ctl->server.via : ctl->server.pollname;
/* allow time for the port to be set up if we have a plugin */
if (ctl->server.plugin)
(void)sleep(1);
-#if INET6_ENABLE
if ((mailserver_socket = SockOpen(realhost,
ctl->server.service ? ctl->server.service : ( ctl->use_ssl ? ctl->server.base_protocol->sslservice : ctl->server.base_protocol->service ),
- ctl->server.netsec, ctl->server.plugin)) == -1)
-#else /* INET6_ENABLE */
- if ((mailserver_socket = SockOpen(realhost, port, NULL, ctl->server.plugin)) == -1)
-#endif /* INET6_ENABLE */
+ ctl->server.plugin, &ai0)) == -1)
{
char errbuf[BUFSIZ];
-#if !INET6_ENABLE
int err_no = errno;
-#ifdef HAVE_RES_SEARCH
- if (err_no != 0 && h_errno != 0)
- report(stderr, _("internal inconsistency\n"));
-#endif
/*
* Avoid generating a bogus error every poll cycle when we're
* in daemon mode but the connection to the outside world
if (!((err_no == EHOSTUNREACH || err_no == ENETUNREACH)
&& run.poll_interval))
{
- report_build(stderr, _("%s connection to %s failed"),
+ report_build(stderr, GT_("%s connection to %s failed"),
ctl->server.base_protocol->name, ctl->server.pollname);
-#ifdef HAVE_RES_SEARCH
- if (h_errno != 0)
- {
- if (h_errno == HOST_NOT_FOUND)
- strcpy(errbuf, _("host is unknown."));
-#ifndef __BEOS__
- else if (h_errno == NO_ADDRESS)
- strcpy(errbuf, _("name is valid but has no IP address."));
-#endif
- else if (h_errno == NO_RECOVERY)
- strcpy(errbuf, _("unrecoverable name server error."));
- else if (h_errno == TRY_AGAIN)
- strcpy(errbuf, _("temporary name server error."));
- else
- sprintf(errbuf, _("unknown DNS error %d."), h_errno);
- }
- else
-#endif /* HAVE_RES_SEARCH */
- strcpy(errbuf, strerror(err_no));
+ strlcpy(errbuf, strerror(err_no), sizeof(errbuf));
report_complete(stderr, ": %s\n", errbuf);
-
-#ifdef __UNUSED
- /*
- * Don't use this. It was an attempt to address Debian bug
- * #47143 (Notify user by mail when pop server nonexistent).
- * Trouble is, that doesn't work; you trip over the case
- * where your SLIP or PPP link is down...
- */
- /* warn the system administrator */
- if (open_warning_by_mail(ctl, (struct msgblk *)NULL) == 0)
- {
- stuff_warning(ctl,
- _("Subject: Fetchmail unreachable-server warning.\r\n"
- "\r\n"
- "Fetchmail could not reach the mail server %s:")
- ctl->server.pollname);
- stuff_warning(ctl, errbuf, ctl->server.pollname);
- close_warning_by_mail(ctl, (struct msgblk *)NULL);
- }
-#endif
}
-#endif /* INET6_ENABLE */
- ok = PS_SOCKET;
+ err = PS_SOCKET;
set_timeout(0);
phase = oldphase;
goto closeUp;
}
- set_timeout(0);
- phase = oldphase;
#ifdef SSL_ENABLE
- /* perform initial SSL handshake on open connection */
- /* Note: We pass the realhost name over for certificate
- verification. We may want to make this configurable */
- if (ctl->use_ssl && SSLOpen(mailserver_socket,ctl->sslkey,ctl->sslcert,ctl->sslproto,ctl->sslcertck,
- ctl->sslcertpath,ctl->sslfingerprint,realhost,ctl->server.pollname) == -1)
- {
- report(stderr, _("SSL connection failed.\n"));
- goto closeUp;
- }
-#endif
+ /* Save the socket opened. Useful if Fetchmail hangs on SSLOpen
+ * because the socket can be closed.
+ */
+ mailserver_socket_temp = mailserver_socket;
+ set_timeout(mytimeout);
-#ifdef KERBEROS_V4
- if (ctl->server.authenticate == A_KERBEROS_V4)
+ /* perform initial SSL handshake on open connection */
+ if (ctl->use_ssl &&
+ SSLOpen(mailserver_socket, ctl->sslcert, ctl->sslkey,
+ ctl->sslproto, ctl->sslcertck,
+ ctl->sslcertfile, ctl->sslcertpath,
+ ctl->sslfingerprint, ctl->sslcommonname ?
+ ctl->sslcommonname : realhost, ctl->server.pollname,
+ &ctl->remotename) == -1)
{
- set_timeout(mytimeout);
- ok = kerberos_auth(mailserver_socket, ctl->server.truename,
- ctl->server.principal);
set_timeout(0);
- if (ok != 0)
- goto cleanUp;
+ report(stderr, GT_("SSL connection failed.\n"));
+ err = PS_SOCKET;
+ goto cleanUp;
}
-#endif /* KERBEROS_V4 */
+
+ /* Fetchmail didn't hang on SSLOpen,
+ * then no need to set mailserver_socket_temp
+ */
+ mailserver_socket_temp = -1;
+#endif
+
+ /* A timeout is still defined before SSLOpen,
+ * then Fetchmail hanging on SSLOpen is handled.
+ */
+ set_timeout(0);
+ phase = oldphase;
#ifdef KERBEROS_V5
if (ctl->server.authenticate == A_KERBEROS_V5)
{
set_timeout(mytimeout);
- ok = kerberos5_auth(mailserver_socket, ctl->server.truename);
+ err = kerberos5_auth(mailserver_socket, ctl->server.truename);
set_timeout(0);
- if (ok != 0)
+ if (err != 0)
goto cleanUp;
}
#endif /* KERBEROS_V5 */
/* accept greeting message from mail server */
- ok = (ctl->server.base_protocol->parse_response)(mailserver_socket, buf);
- if (ok != 0)
+ err = (ctl->server.base_protocol->parse_response)(mailserver_socket, buf);
+ if (err != 0)
goto cleanUp;
/* try to get authorized to fetch mail */
stage = STAGE_GETAUTH;
if (ctl->server.base_protocol->getauth)
{
- ok = (ctl->server.base_protocol->getauth)(mailserver_socket, ctl, buf);
+ set_timeout(mytimeout);
+ err = (ctl->server.base_protocol->getauth)(mailserver_socket, ctl, buf);
+ set_timeout(0);
- if (ok != 0)
+ if (err != 0)
{
- if (ok == PS_LOCKBUSY)
- report(stderr, _("Lock-busy error on %s@%s\n"),
+ if (err == PS_LOCKBUSY)
+ report(stderr, GT_("Lock-busy error on %s@%s\n"),
ctl->remotename,
ctl->server.truename);
- else if (ok == PS_SERVBUSY)
- report(stderr, _("Server busy error on %s@%s\n"),
+ else if (err == PS_SERVBUSY)
+ report(stderr, GT_("Server busy error on %s@%s\n"),
ctl->remotename,
ctl->server.truename);
- else if (ok == PS_AUTHFAIL)
+ else if (err == PS_AUTHFAIL)
{
- report(stderr, _("Authorization failure on %s@%s%s\n"),
+ report(stderr, GT_("Authorization failure on %s@%s%s\n"),
ctl->remotename,
ctl->server.truename,
- (ctl->wehaveauthed ? _(" (previously authorized)") : "")
+ (ctl->wehaveauthed ? GT_(" (previously authorized)") : "")
);
+ if (ctl->server.authenticate == A_ANY && !ctl->wehaveauthed) {
+ report(stderr, GT_("For help, see http://www.fetchmail.info/fetchmail-FAQ.html#R15\n"));
+ }
/*
* If we're running in background, try to mail the
* we let the user know service is restored.
*/
if (run.poll_interval
- && ctl->wehavesentauthnote
- && ((ctl->wehaveauthed && ++ctl->authfailcount == 10)
- || ++ctl->authfailcount == 3)
- && !open_warning_by_mail(ctl, (struct msgblk *)NULL))
+ && !ctl->wehavesentauthnote
+ && ((ctl->wehaveauthed && ++ctl->authfailcount >= 10)
+ || (!ctl->wehaveauthed && ++ctl->authfailcount >= 3))
+ && !open_warning_by_mail(ctl))
{
ctl->wehavesentauthnote = 1;
- stuff_warning(ctl,
- _("Subject: fetchmail authentication failed on %s@%s\r\n"),
+ stuff_warning(iana_charset, ctl,
+ GT_("Subject: fetchmail authentication failed on %s@%s"),
ctl->remotename, ctl->server.truename);
- stuff_warning(ctl,
- _("Fetchmail could not get mail from %s@%s.\r\n"),
+ stuff_warning(NULL, ctl, "%s", "");
+ stuff_warning(NULL, ctl,
+ GT_("Fetchmail could not get mail from %s@%s.\n"),
ctl->remotename,
ctl->server.truename);
- if (ctl->wehaveauthed)
- stuff_warning(ctl, _("\
-The attempt to get authorization failed.\r\n\
-Since we have already succeeded in getting authorization for this\r\n\
-connection, this is probably another failure mode (such as busy server)\r\n\
-that fetchmail cannot distinguish because the server didn't send a useful\r\n\
-error message.\r\n\
-\r\n\
-However, if you HAVE changed you account details since starting the\r\n\
-fetchmail daemon, you need to stop the daemon, change your configuration\r\n\
-of fetchmail, and then restart the daemon.\r\n\
-\r\n\
-The fetchmail daemon will continue running and attempt to connect\r\n\
-at each cycle. No future notifications will be sent until service\r\n\
+ if (ctl->wehaveauthed) {
+ stuff_warning(NULL, ctl, GT_("\
+The attempt to get authorization failed.\n\
+Since we have already succeeded in getting authorization for this\n\
+connection, this is probably another failure mode (such as busy server)\n\
+that fetchmail cannot distinguish because the server didn't send a useful\n\
+error message."));
+ stuff_warning(NULL, ctl, GT_("\
+\n\
+However, if you HAVE changed your account details since starting the\n\
+fetchmail daemon, you need to stop the daemon, change your configuration\n\
+of fetchmail, and then restart the daemon.\n\
+\n\
+The fetchmail daemon will continue running and attempt to connect\n\
+at each cycle. No future notifications will be sent until service\n\
is restored."));
- else
- stuff_warning(ctl, _("\
-The attempt to get authorization failed.\r\n\
-This probably means your password is invalid, but some servers have\r\n\
-other failure modes that fetchmail cannot distinguish from this\r\n\
-because they don't send useful error messages on login failure.\r\n\
-\r\n\
-The fetchmail daemon will continue running and attempt to connect\r\n\
-at each cycle. No future notifications will be sent until service\r\n\
+ } else {
+ stuff_warning(NULL, ctl, GT_("\
+The attempt to get authorization failed.\n\
+This probably means your password is invalid, but some servers have\n\
+other failure modes that fetchmail cannot distinguish from this\n\
+because they don't send useful error messages on login failure.\n\
+\n\
+The fetchmail daemon will continue running and attempt to connect\n\
+at each cycle. No future notifications will be sent until service\n\
is restored."));
+ }
close_warning_by_mail(ctl, (struct msgblk *)NULL);
}
}
+ else if (err == PS_REPOLL)
+ {
+ if (outlevel >= O_VERBOSE)
+ report(stderr, GT_("Repoll immediately on %s@%s\n"),
+ ctl->remotename,
+ ctl->server.truename);
+ }
else
- report(stderr, _("Unknown login or authentication error on %s@%s\n"),
+ report(stderr, GT_("Unknown login or authentication error on %s@%s\n"),
ctl->remotename,
ctl->server.truename);
{
ctl->wehavesentauthnote = 0;
report(stderr,
- _("Authorization OK on %s@%s\n"),
+ GT_("Authorization OK on %s@%s\n"),
ctl->remotename,
ctl->server.truename);
- if (!open_warning_by_mail(ctl, (struct msgblk *)NULL))
+ if (!open_warning_by_mail(ctl))
{
- stuff_warning(ctl,
- _("Subject: fetchmail authentication OK on %s@%s\r\n"),
+ stuff_warning(iana_charset, ctl,
+ GT_("Subject: fetchmail authentication OK on %s@%s"),
ctl->remotename, ctl->server.truename);
- stuff_warning(ctl,
- _("Fetchmail was able to log into %s@%s.\r\n"),
+ stuff_warning(NULL, ctl, "%s", "");
+ stuff_warning(NULL, ctl,
+ GT_("Fetchmail was able to log into %s@%s.\n"),
ctl->remotename,
ctl->server.truename);
- stuff_warning(ctl,
- _("Service has been restored.\r\n"));
+ stuff_warning(NULL, ctl,
+ GT_("Service has been restored.\n"));
close_warning_by_mail(ctl, (struct msgblk *)NULL);
}
/* now iterate over each folder selected */
for (idp = ctl->mailboxes; idp; idp = idp->next)
{
+ ctl->folder = idp->id;
pass = 0;
do {
dispatches = 0;
+ transient_errors = 0;
++pass;
/* reset timeout, in case we did an IDLE */
if (outlevel >= O_DEBUG)
{
if (idp->id)
- report(stdout, _("selecting or re-polling folder %s\n"), idp->id);
+ report(stdout, GT_("selecting or re-polling folder %s\n"), idp->id);
else
- report(stdout, _("selecting or re-polling default folder\n"));
+ report(stdout, GT_("selecting or re-polling default folder\n"));
}
/* compute # of messages and number of new messages waiting */
stage = STAGE_GETRANGE;
- ok = (ctl->server.base_protocol->getrange)(mailserver_socket, ctl, idp->id, &count, &new, &bytes);
- if (ok != 0)
+ err = (ctl->server.base_protocol->getrange)(mailserver_socket, ctl, idp->id, &count, &newm, &bytes);
+ if (err != 0)
goto cleanUp;
/* show user how many messages we downloaded */
if (idp->id)
- (void) sprintf(buf, _("%s at %s (folder %s)"),
- ctl->remotename, ctl->server.truename, idp->id);
+ (void) snprintf(buf, sizeof(buf),
+ GT_("%s at %s (folder %s)"),
+ ctl->remotename, ctl->server.pollname, idp->id);
else
- (void) sprintf(buf, _("%s at %s"),
- ctl->remotename, ctl->server.truename);
+ (void) snprintf(buf, sizeof(buf), GT_("%s at %s"),
+ ctl->remotename, ctl->server.pollname);
if (outlevel > O_SILENT)
{
if (count == -1) /* only used for ETRN */
- report(stdout, _("Polling %s\n"), ctl->server.truename);
+ report(stdout, GT_("Polling %s\n"), ctl->server.truename);
else if (count != 0)
{
- if (new != -1 && (count - new) > 0)
- report_build(stdout, _("%d %s (%d seen) for %s"),
- count, count > 1 ? _("messages") :
- _("message"),
- count-new, buf);
+ if (newm != -1 && (count - newm) > 0)
+ report_build(stdout, ngettext("%d message (%d %s) for %s", "%d messages (%d %s) for %s", (unsigned long)count),
+ count,
+ count - newm,
+ ngettext("seen", "seen", (unsigned long)count-newm),
+ buf);
else
- report_build(stdout, _("%d %s for %s"),
- count, count > 1 ? _("messages") :
- _("message"), buf);
+ report_build(stdout, ngettext("%d message for %s",
+ "%d messages for %s",
+ count),
+ count, buf);
if (bytes == -1)
report_complete(stdout, ".\n");
else
- report_complete(stdout, _(" (%d octets).\n"), bytes);
+ report_complete(stdout, GT_(" (%d octets).\n"), bytes);
}
else
{
/* these are pointless in normal daemon mode */
if (pass == 1 && (run.poll_interval == 0 || outlevel >= O_VERBOSE))
- report(stdout, _("No mail for %s\n"), buf);
+ report(stdout, GT_("No mail for %s\n"), buf);
}
}
if (check_only)
{
- if (new == -1 || ctl->fetchall)
- new = count;
- fetches = new; /* set error status ccorrectly */
+ if (newm == -1 || ctl->fetchall)
+ newm = count;
+ fetches = newm; /* set error status correctly */
/*
- * There used to be a `got noerror' here, but this
- * prevneted checking of multiple folders. This
+ * There used to be a `goto noerror' here, but this
+ * prevented checking of multiple folders. This
* comment is a reminder in case I introduced some
* subtle bug by removing it...
*/
}
else if (count > 0)
{
- flag force_retrieval;
+ int i;
/*
- * What forces this code is that in POP2 and
- * IMAP2bis you can't fetch a message without
- * having it marked `seen'. In POP3 and IMAP4, on the
- * other hand, you can (peek_capable is set by
- * each driver module to convey this; it's not a
- * method constant because of the difference between
- * IMAP2bis and IMAP4, and because POP3 doesn't peek
- * if fetchall is on).
- *
- * The result of being unable to peek is that if there's
- * any kind of transient error (DNS lookup failure, or
- * sendmail refusing delivery due to process-table limits)
- * the message will be marked "seen" on the server without
- * having been delivered. This is not a big problem if
- * fetchmail is running in foreground, because the user
- * will see a "skipped" message when it next runs and get
- * clued in.
- *
- * But in daemon mode this leads to the message
- * being silently ignored forever. This is not
- * acceptable.
- *
- * We compensate for this by checking the error
- * count from the previous pass and forcing all
- * messages to be considered new if it's nonzero.
+ * Don't trust the message count passed by the server.
+ * Without this check, it might be possible to do a
+ * DNS-spoofing attack that would pass back a ridiculous
+ * count, and allocate a malloc area that would overlap
+ * a portion of the stack.
*/
- force_retrieval = !peek_capable && (ctl->errcount > 0);
+ if ((unsigned)count > INT_MAX/sizeof(int))
+ {
+ report(stderr, GT_("bogus message count!"));
+ err = PS_PROTOCOL;
+ goto cleanUp;
+ }
/*
* We need the size of each message before it's
* option. If the protocol has a getsizes method,
* we presume this means it doesn't get reliable
* sizes from message fetch responses.
+ *
+ * If the protocol supports getting sizes of subset of
+ * messages, we skip this step now.
*/
- if (proto->getsizes)
+ if (proto->getsizes &&
+ !(proto->getpartialsizes && NUM_NONZERO(ctl->fetchsizelimit)))
{
- int i;
-
- xalloca(msgsizes, int *, sizeof(int) * count);
+ xfree(msgsizes);
+ msgsizes = (int *)xmalloc(sizeof(int) * count);
for (i = 0; i < count; i++)
- msgsizes[i] = -1;
+ msgsizes[i] = 0;
stage = STAGE_GETSIZES;
- ok = (proto->getsizes)(mailserver_socket, count, msgsizes);
- if (ok != 0)
+ err = (proto->getsizes)(mailserver_socket, count, msgsizes);
+ if (err != 0)
goto cleanUp;
if (bytes == -1)
/* read, forward, and delete messages */
stage = STAGE_FETCH;
- for (num = 1; num <= count; num++)
- {
- flag toolarge = NUM_NONZERO(ctl->limit)
- && msgsizes && (msgsizes[num-1] > ctl->limit);
- flag oldmsg = (!new) || (ctl->server.base_protocol->is_old && (ctl->server.base_protocol->is_old)(mailserver_socket,ctl,num));
- flag fetch_it = !toolarge
- && (ctl->fetchall || force_retrieval || !oldmsg);
- flag suppress_delete = FALSE;
- flag suppress_forward = FALSE;
- flag suppress_readbody = FALSE;
- flag retained = FALSE;
-
- /*
- * This check copes with Post Office/NT's
- * annoying habit of randomly prepending bogus
- * LIST items of length -1. Patrick Audley
- * <paudley@pobox.com> tells us: LIST shows a
- * size of -1, RETR and TOP return "-ERR
- * System error - couldn't open message", and
- * DELE succeeds but doesn't actually delete
- * the message.
- */
- if (msgsizes && msgsizes[num-1] == -1)
- {
- if (outlevel >= O_VERBOSE)
- report(stdout,
- _("Skipping message %d, length -1\n"),
- num);
- continue;
- }
-
- /*
- * We may want to reject this message if it's old
- * or oversized, and we're not forcing retrieval.
- */
- if (!fetch_it)
- {
- if (outlevel > O_SILENT)
- {
- report_build(stdout,
- _("skipping message %d (%d octets)"),
- num, msgsizes[num-1]);
- if (toolarge && !check_only)
- {
- char size[32];
- int cnt;
-
- /* convert sz to string */
- sprintf(size, "%d", msgsizes[num-1]);
-
- /* build a list of skipped messages
- * val.id = size of msg (string cnvt)
- * val.status.num = warning_poll_count
- * val.status.mask = nbr of msg this size
- */
-
- current = ctl->skipped;
-
- /* initialise warning_poll_count to the
- * current value so that all new msg will
- * be included in the next mail
- */
- cnt = current? current->val.status.num : 0;
-
- /* if entry exists, increment the count */
- if (current &&
- str_in_list(¤t, size, FALSE))
- {
- for ( ; current;
- current = current->next)
- {
- if (strcmp(current->id, size) == 0)
- {
- current->val.status.mark++;
- break;
- }
- }
- }
- /* otherwise, create a new entry */
- /* initialise with current poll count */
- else
- {
- tmp = save_str(&ctl->skipped, size, 1);
- tmp->val.status.num = cnt;
- }
-
- report_build(stdout, _(" (oversized, %d octets)"),
- msgsizes[num-1]);
- }
- }
- }
- else
- {
- flag wholesize = !ctl->server.base_protocol->fetch_body;
-
- /* request a message */
- ok = (ctl->server.base_protocol->fetch_headers)(mailserver_socket,ctl,num, &len);
- if (ok != 0)
- goto cleanUp;
-
- /* -1 means we didn't see a size in the response */
- if (len == -1 && msgsizes)
- {
- len = msgsizes[num - 1];
- wholesize = TRUE;
- }
- if (outlevel > O_SILENT)
- {
- report_build(stdout, _("reading message %d of %d"),
- num,count);
-
- if (len > 0)
- report_build(stdout, _(" (%d %soctets)"),
- len, wholesize ? "" : _("header "));
- if (outlevel >= O_VERBOSE)
- report_complete(stdout, "\n");
- else
- report_complete(stdout, " ");
- }
+ /* fetch in lockstep mode */
+ err = fetch_messages(mailserver_socket, ctl,
+ count, &msgsizes,
+ maxfetch,
+ &fetches, &dispatches, &deletions,
+ &transient_errors);
+ if (err != PS_SUCCESS && err != PS_MAXFETCH)
+ goto cleanUp;
- /*
- * Read the message headers and ship them to the
- * output sink.
- */
- ok = readheaders(mailserver_socket, len, msgsizes[num-1],
- ctl, num);
- if (ok == PS_RETAINED)
- suppress_forward = retained = TRUE;
- else if (ok == PS_TRANSIENT)
- suppress_delete = suppress_forward = TRUE;
- else if (ok == PS_REFUSED)
- suppress_forward = TRUE;
- else if (ok == PS_TRUNCATED)
- suppress_readbody = TRUE;
- else if (ok)
- goto cleanUp;
-
- /*
- * If we're using IMAP4 or something else that
- * can fetch headers separately from bodies,
- * it's time to request the body now. This
- * fetch may be skipped if we got an anti-spam
- * or other PS_REFUSED error response during
- * readheaders.
- */
- if (ctl->server.base_protocol->fetch_body && !suppress_readbody)
- {
- if (outlevel >= O_VERBOSE && !isafile(1))
- {
- fputc('\n', stdout);
- fflush(stdout);
- }
-
- if ((ok = (ctl->server.base_protocol->trail)(mailserver_socket, ctl, num)))
- goto cleanUp;
- len = 0;
- if (!suppress_forward)
- {
- if ((ok=(ctl->server.base_protocol->fetch_body)(mailserver_socket,ctl,num,&len)))
- goto cleanUp;
- /*
- * Work around a bug in Novell's
- * broken GroupWise IMAP server;
- * its body FETCH response is missing
- * the required length for the data
- * string. This violates RFC2060.
- */
- if (len == -1)
- len = msgsizes[num-1] - msgblk.msglen;
- if (outlevel > O_SILENT && !wholesize)
- report_complete(stdout,
- _(" (%d body octets) "), len);
- }
- }
-
- /* process the body now */
- if (len > 0)
- {
- if (suppress_readbody)
- {
- /* When readheaders returns PS_TRUNCATED,
- the body (which has no content
- has already been read by readheaders,
- so we say readbody returned PS_SUCCESS */
- ok = PS_SUCCESS;
- }
- else
- {
- ok = readbody(mailserver_socket,
- ctl,
- !suppress_forward,
- len);
- }
- if (ok == PS_TRANSIENT)
- suppress_delete = suppress_forward = TRUE;
- else if (ok)
- goto cleanUp;
-
- /* tell server we got it OK and resynchronize */
- if (ctl->server.base_protocol->trail)
- {
- if (outlevel >= O_VERBOSE && !isafile(1))
- {
- fputc('\n', stdout);
- fflush(stdout);
- }
-
- ok = (ctl->server.base_protocol->trail)(mailserver_socket, ctl, num);
- if (ok != 0)
- goto cleanUp;
- }
- }
-
- /* count # messages forwarded on this pass */
- if (!suppress_forward)
- dispatches++;
-
- /*
- * Check to see if the numbers matched?
- *
- * Yes, some servers foo this up horribly.
- * All IMAP servers seem to get it right, and
- * so does Eudora QPOP at least in 2.xx
- * versions.
- *
- * Microsoft Exchange gets it completely
- * wrong, reporting compressed rather than
- * actual sizes (so the actual length of
- * message is longer than the reported size).
- * Another fine example of Microsoft brain death!
- *
- * Some older POP servers, like the old UCB
- * POP server and the pre-QPOP QUALCOMM
- * versions, report a longer size in the LIST
- * response than actually gets shipped up.
- * It's unclear what is going on here, as the
- * QUALCOMM server (at least) seems to be
- * reporting the on-disk size correctly.
- */
- if (msgsizes && msgblk.msglen != msgsizes[num-1])
- {
- if (outlevel >= O_DEBUG)
- report(stdout,
- _("message %d was not the expected length (%d actual != %d expected)\n"),
- num, msgblk.msglen, msgsizes[num-1]);
- }
-
- /* end-of-message processing starts here */
- if (!close_sink(ctl, &msgblk, !suppress_forward))
- {
- ctl->errcount++;
- suppress_delete = TRUE;
- }
- fetches++;
- }
-
- /*
- * At this point in flow of control, either
- * we've bombed on a protocol error or had
- * delivery refused by the SMTP server
- * (unlikely -- I've never seen it) or we've
- * seen `accepted for delivery' and the
- * message is shipped. It's safe to mark the
- * message seen and delete it on the server
- * now.
- */
-
- /* tell the UID code we've seen this */
- if (ctl->newsaved)
- {
- struct idlist *sdp;
-
- for (sdp = ctl->newsaved; sdp; sdp = sdp->next)
- if ((sdp->val.status.num == num)
- && (!toolarge || oldmsg))
- {
- sdp->val.status.mark = UID_SEEN;
- save_str(&ctl->oldsaved, sdp->id,UID_SEEN);
- }
- }
-
- /* maybe we delete this message now? */
- if (retained)
- {
- if (outlevel > O_SILENT)
- report(stdout, _(" retained\n"));
- }
- else if (ctl->server.base_protocol->delete
- && !suppress_delete
- && (fetch_it ? !ctl->keep : ctl->flush))
- {
- deletions++;
- if (outlevel > O_SILENT)
- report_complete(stdout, _(" flushed\n"));
- ok = (ctl->server.base_protocol->delete)(mailserver_socket, ctl, num);
- if (ok != 0)
- goto cleanUp;
-#ifdef POP3_ENABLE
- delete_str(&ctl->newsaved, num);
-#endif /* POP3_ENABLE */
- }
- else if (outlevel > O_SILENT)
- report_complete(stdout, _(" not flushed\n"));
-
- /* perhaps this as many as we're ready to handle */
- if (maxfetch && maxfetch <= fetches && fetches < count)
+ if (transient_errors > MAX_TRANSIENT_ERRORS)
+ {
+ if (outlevel > O_SILENT)
{
- report(stdout, _("fetchlimit %d reached; %d messages left on server\n"),
- maxfetch, count - fetches);
- ok = PS_MAXFETCH;
- goto cleanUp;
+ report(stderr, GT_("Too many mails skipped (%d > %d) due to transient errors for %s\n"),
+ transient_errors, MAX_TRANSIENT_ERRORS, buf);
}
}
send_size_warnings(ctl);
}
}
+
+ /* end-of-mailbox processing before we repoll or switch to another one */
+ if (ctl->server.base_protocol->end_mailbox_poll)
+ {
+ tmperr = (ctl->server.base_protocol->end_mailbox_poll)(mailserver_socket, ctl);
+ if (tmperr) {
+ err = tmperr;
+ goto cleanUp;
+ }
+ }
+ /* Return now if we have reached the fetchlimit */
+ if (maxfetch && maxfetch <= fetches)
+ goto no_error;
} while
/*
- * Only re-poll if we either had some actual forwards and
- * either allowed deletions and had no errors.
+ * Only repoll if we either had some actual forwards
+ * or are idling for new mails and had no errors.
* Otherwise it is far too easy to get into infinite loops.
*/
- (dispatches && ctl->server.base_protocol->retry && !ctl->keep && !ctl->errcount);
+ (ctl->server.base_protocol->retry && (dispatches || ctl->idle) && !ctl->errcount);
}
- /* no_error: */
- /* ordinary termination with no errors -- officially log out */
- ok = (ctl->server.base_protocol->logout_cmd)(mailserver_socket, ctl);
+ /* XXX: From this point onwards, preserve err unless a new error has occurred */
+
+ no_error:
+ /* PS_SUCCESS, PS_MAXFETCH: ordinary termination with no errors -- officially log out */
+ stage = STAGE_LOGOUT;
+ tmperr = (ctl->server.base_protocol->logout_cmd)(mailserver_socket, ctl);
+ if (tmperr != PS_SUCCESS)
+ err = tmperr;
/*
* Hmmmm...arguably this would be incorrect if we had fetches but
* no dispatches (due to oversized messages, etc.)
*/
- if (ok == 0)
- ok = (fetches > 0) ? PS_SUCCESS : PS_NOMAIL;
- SockClose(mailserver_socket);
+ else if (err == PS_SUCCESS && fetches == 0)
+ err = PS_NOMAIL;
+ /*
+ * Close all SMTP delivery sockets. For optimum performance
+ * we'd like to hold them open til end of run, but (1) this
+ * loses if our poll interval is longer than the MTA's
+ * inactivity timeout, and (2) some MTAs (like smail) don't
+ * deliver after each message, but rather queue up mail and
+ * wait to actually deliver it until the input socket is
+ * closed.
+ *
+ * don't send QUIT for ODMR case because we're acting as a
+ * proxy between the SMTP server and client.
+ */
+ smtp_close(ctl, ctl->server.protocol != P_ODMR);
+ cleanupSockClose(mailserver_socket);
goto closeUp;
cleanUp:
/* we only get here on error */
- if (ok != 0 && ok != PS_SOCKET)
+ if (err != 0 && err != PS_SOCKET && err != PS_REPOLL)
{
stage = STAGE_LOGOUT;
(ctl->server.base_protocol->logout_cmd)(mailserver_socket, ctl);
}
- SockClose(mailserver_socket);
+
+ /* try to clean up all streams */
+ release_sink(ctl);
+ /*
+ * Sending SMTP QUIT on signal is theoretically nice, but led
+ * to a subtle bug. If fetchmail was terminated by signal
+ * while it was shipping message text, it would hang forever
+ * waiting for a command acknowledge. In theory we could
+ * enable the QUIT only outside of the message send. In
+ * practice, we don't care. All mailservers hang up on a
+ * dropped TCP/IP connection anyway.
+ */
+ smtp_close(ctl, 0);
+ if (mailserver_socket != -1) {
+ cleanupSockClose(mailserver_socket);
+ }
+ /* If there was a connect timeout, the socket should be closed.
+ * mailserver_socket_temp contains the socket to close.
+ */
+ if (mailserver_socket_temp != -1) {
+ cleanupSockClose(mailserver_socket_temp);
+ mailserver_socket_temp = -1;
+ }
}
- msg = (const char *)NULL; /* sacrifice to -Wall */
- switch (ok)
+ /* no report on PS_AUTHFAIL */
+ msg = NULL;
+ switch (err)
{
case PS_SOCKET:
- msg = _("socket");
+ msg = GT_("socket");
break;
case PS_SYNTAX:
- msg = _("missing or bad RFC822 header");
+ msg = GT_("missing or bad RFC822 header or command line option");
break;
case PS_IOERR:
- msg = _("MDA");
+ msg = GT_("MDA");
break;
case PS_ERROR:
- msg = _("client/server synchronization");
+ msg = GT_("client/server synchronization");
break;
case PS_PROTOCOL:
- msg = _("client/server protocol");
+ msg = GT_("client/server protocol");
break;
case PS_LOCKBUSY:
- msg = _("lock busy on server");
+ msg = GT_("lock busy on server");
break;
case PS_SMTP:
- msg = _("SMTP transaction");
+ msg = GT_("SMTP transaction");
break;
case PS_DNS:
- msg = _("DNS lookup");
+ msg = GT_("DNS lookup");
break;
case PS_UNDEFINED:
- report(stderr, _("undefined error\n"));
+ msg = GT_("undefined");
break;
}
- /* no report on PS_MAXFETCH or PS_UNDEFINED or PS_AUTHFAIL */
- if (ok==PS_SOCKET || ok==PS_SYNTAX
- || ok==PS_IOERR || ok==PS_ERROR || ok==PS_PROTOCOL
- || ok==PS_LOCKBUSY || ok==PS_SMTP || ok==PS_DNS)
- {
- char *stem;
-
- if (phase == FORWARDING_WAIT || phase == LISTENER_WAIT)
- stem = _("%s error while delivering to SMTP host %s\n");
+ if (msg) {
+ if (phase == FORWARDING_WAIT || phase == LISTENER_WAIT
+ || err == PS_SMTP)
+ report(stderr, GT_("%s error while fetching from %s@%s and delivering to SMTP host %s\n"),
+ msg, ctl->remotename, ctl->server.pollname,
+ ctl->smtphost ? ctl->smtphost : GT_("unknown"));
else
- stem = _("%s error while fetching from %s\n");
- report(stderr, stem, msg, ctl->server.pollname);
+ report(stderr, GT_("%s error while fetching from %s@%s\n"),
+ msg, ctl->remotename, ctl->server.pollname);
}
closeUp:
+ xfree(msgsizes);
+ ctl->folder = NULL;
+
/* execute wrapup command, if any */
- if (ctl->postconnect && (ok = system(ctl->postconnect)))
+ if (ctl->postconnect && (tmperr = system(ctl->postconnect)))
{
- report(stderr, _("post-connection command failed with status %d\n"), ok);
- if (ok == PS_SUCCESS)
- ok = PS_SYNTAX;
+ if (WIFSIGNALED(tmperr))
+ report(stderr, GT_("post-connection command terminated with signal %d\n"), WTERMSIG(tmperr));
+ else
+ report(stderr, GT_("post-connection command failed with status %d\n"), WEXITSTATUS(tmperr));
+ if (err == PS_SUCCESS)
+ err = PS_SYNTAX;
}
- signal(SIGALRM, alrmsave);
- signal(SIGPIPE, pipesave);
- return(ok);
+ set_timeout(0); /* cancel any pending alarm */
+ set_signal_handler(SIGALRM, alrmsave);
+ return(err);
}
-int do_protocol(ctl, proto)
-/* retrieve messages from server using given protocol method table */
-struct query *ctl; /* parsed options with merged-in defaults */
-const struct method *proto; /* protocol method table */
+/** retrieve messages from server using given protocol method table */
+int do_protocol(struct query *ctl /** parsed options with merged-in defaults */,
+ const struct method *proto /** protocol method table */)
{
- int ok;
-
-#ifndef KERBEROS_V4
- if (ctl->server.authenticate == A_KERBEROS_V4)
- {
- report(stderr, _("Kerberos V4 support not linked.\n"));
- return(PS_ERROR);
- }
-#endif /* KERBEROS_V4 */
+ int err;
#ifndef KERBEROS_V5
if (ctl->server.authenticate == A_KERBEROS_V5)
{
- report(stderr, _("Kerberos V5 support not linked.\n"));
+ report(stderr, GT_("Kerberos V5 support not linked.\n"));
return(PS_ERROR);
}
#endif /* KERBEROS_V5 */
/* check for unsupported options */
if (ctl->flush) {
report(stderr,
- _("Option --flush is not supported with %s\n"),
+ GT_("Option --flush is not supported with %s\n"),
proto->name);
return(PS_SYNTAX);
}
else if (ctl->fetchall) {
report(stderr,
- _("Option --all is not supported with %s\n"),
+ GT_("Option --all is not supported with %s\n"),
proto->name);
return(PS_SYNTAX);
}
}
- if (!proto->getsizes && NUM_SPECIFIED(ctl->limit))
+ if (!(proto->getsizes || proto->getpartialsizes)
+ && NUM_SPECIFIED(ctl->limit))
{
report(stderr,
- _("Option --limit is not supported with %s\n"),
+ GT_("Option --limit is not supported with %s\n"),
proto->name);
return(PS_SYNTAX);
}
* If no expunge limit or we do expunges within the driver,
* then just do one session, passing in any fetchlimit.
*/
- if (proto->retry || !NUM_SPECIFIED(ctl->expunge))
+ if ((ctl->keep && !ctl->flush) ||
+ proto->retry || !NUM_SPECIFIED(ctl->expunge))
return(do_session(ctl, proto, NUM_VALUE_OUT(ctl->fetchlimit)));
/*
* There's an expunge limit, and it isn't handled in the driver itself.
do {
if (fetchlimit > 0 && (expunge == 0 || expunge > fetchlimit - totalcount))
expunge = fetchlimit - totalcount;
- ok = do_session(ctl, proto, expunge);
+ err = do_session(ctl, proto, expunge);
totalcount += expunge;
if (NUM_SPECIFIED(ctl->fetchlimit) && totalcount >= fetchlimit)
break;
- if (ok != PS_LOCKBUSY)
+ if (err != PS_LOCKBUSY)
lockouts = 0;
else if (lockouts >= MAX_LOCKOUTS)
break;
- else /* ok == PS_LOCKBUSY */
+ else /* err == PS_LOCKBUSY */
{
/*
* Allow time for the server lock to release. if we
sleep(3);
}
} while
- (ok == PS_MAXFETCH || ok == PS_LOCKBUSY);
+ (err == PS_MAXFETCH || err == PS_LOCKBUSY);
- return(ok);
+ return(err);
}
}