-/*
- * transact.c -- transaction primitives for the fetchmail driver loop
+/**
+ * \file transact.c -- transaction primitives for the fetchmail driver loop
*
* Copyright 2001 by Eric S. Raymond
* For license terms, see the file COPYING in this directory.
#else
#include <varargs.h>
#endif
+#include <limits.h>
+#include <assert.h>
#ifdef HAVE_NET_SOCKET_H
#include <net/socket.h>
#include "socket.h"
#include "fetchmail.h"
+/** Macro to clamp the argument so it is >= INT_MIN. */
+#define _FIX_INT_MIN(x) ((x) < INT_MIN ? INT_MIN : (x))
+/** Macro to clamp the argument so it is <= INT_MAX. */
+#define _FIX_INT_MAX(x) ((x) > INT_MAX ? INT_MAX : (x))
+/** Macro to clamp the argument so it is representable as an int. */
+#define CAST_TO_INT(x) ((int)(_FIX_INT_MIN(_FIX_INT_MAX(x))))
+/** Macro to clamp the unsigned argument so it is representable as an int. */
+#define UCAST_TO_INT(x) ((int)(_FIX_INT_MAX(x)))
+
/* global variables: please reinitialize them explicitly for proper
* working in daemon mode */
/* session variables initialized in init_transact() */
-int suppress_tags = FALSE; /* emit tags? */
-char tag[TAGLEN];
-static int tagnum;
+int suppress_tags = FALSE; /**< emit tags in the protocol? */
+char tag[TAGLEN]; /**< buffer for the tag */
+static int tagnum; /**< local counter for the tag */
+/** Macro to generate the tag and store it in #tag. */
#define GENSYM (sprintf(tag, "A%04d", ++tagnum % TAGMOD), tag)
-static struct method *protocol;
-char shroud[PASSWORDLEN*2+3]; /* string to shroud in debug output */
+static const struct method *protocol; /**< description of the protocol used for the current poll */
+char shroud[PASSWORDLEN*2+3]; /**< string to shroud in debug output */
/* session variables initialized in do_session() */
-int mytimeout; /* value of nonreponse timeout */
+int mytimeout; /**< value of nonreponse timeout */
/* mail variables initialized in readheaders() */
-struct msgblk msgblk;
-static int accept_count, reject_count;
+struct msgblk msgblk; /**< stores attributes of the currently processed message */
+static int accept_count /** count of accepted recipients */, reject_count /** count of rejected recipients */;
/** add given address to xmit_names if it exactly matches a full address
* \returns nonzero if matched */
-static int map_address(const char *addr, struct query *ctl, struct idlist **xmit_names)
+static int map_address(const char *addr,/**< address to match */
+ struct query *ctl, /**< contains list of aliases */
+ struct idlist **xmit_names /**< list of recipient names */)
{
const char *lname;
/** add given name to xmit_names if it matches declared localnames */
static void map_name(const char *name, struct query *ctl, struct idlist **xmit_names)
-/* name: name to map */
-/* ctl: list of permissible aliases */
-/* xmit_names: list of recipient names parsed out */
+/** \param name name to map */
+/** \param ctl list of permissible aliases */
+/** \param xmit_names list of recipient names parsed out */
{
const char *lname;
static void find_server_names(const char *hdr,
struct query *ctl,
struct idlist **xmit_names)
-/* parse names out of a RFC822 header into an ID list */
-/* hdr: RFC822 header in question */
-/* ctl: list of permissible aliases */
-/* xmit_names: list of recipient names parsed out */
+/** parse names out of a RFC822 header into an ID list */
+/** \param hdr RFC822 header in question */
+/** \param ctl list of permissible aliases */
+/** \param xmit_names list of recipient names parsed out */
{
if (hdr == (char *)NULL)
return;
}
}
-/*
+/**
* Return zero on a syntactically invalid address, nz on a valid one.
*
* This used to be strchr(a, '.'), but it turns out that lines like this
*
- * Received: from punt-1.mail.demon.net by mailstore for markb@ordern.com
+ * Received: from punt-1.mail.demon.net by mailstore for markb@example.com
* id 938765929:10:27223:2; Fri, 01 Oct 99 08:18:49 GMT
*
* are not uncommon. So now we just check that the following token is
* not itself an email address.
*/
-#define VALID_ADDRESS(a) !strchr(a, '@')
+#define VALID_ADDRESS(a) (!strchr((a), '@'))
-static char *parse_received(struct query *ctl, char *bufp)
-/* try to extract real address from the Received line */
-/* If a valid Received: line is found, we return the full address in
- * a buffer which can be parsed from nxtaddr(). This is to ansure that
+/** write \a value into \a rbuf, indexed by \a tp, if there is
+ * sufficient room left. */
+#define RBUF_WRITE(value) do { if (tp < rbuf+sizeof(rbuf)-1) *tp++=(value); } while(0)
+
+/** Try to extract real address from the Received line.
+ * If a valid Received: line is found, we return the full address in
+ * a buffer which can be parsed from nxtaddr(). This is to ensure that
* the local domain part of the address can be passed along in
* find_server_names() if it contains one.
* Note: We should return a dummy header containing the address
* which makes nxtaddr() behave correctly.
*/
+static char *parse_received(struct query *ctl, char *bufp)
{
char *base, *ok = (char *)NULL;
static char rbuf[HOSTLEN + USERNAMELEN + 4];
struct addrinfo *ai0;
-#define RBUF_WRITE(value) if (tp < rbuf+sizeof(rbuf)-1) *tp++=value
-
/*
* Try to extract the real envelope addressee. We look here
* specifically for the mailserver's Received line.
}
/* shared by readheaders and readbody */
-static int sizeticker;
+static int sizeticker; /**< internal state variable for print_ticker() */
/** Print ticker based on a amount of data transferred of \a bytes.
* Increments \a *tickervar by \a bytes, and if it exceeds
}
}
+/** Check if \a s is equal to a LF or CR LF sequence, followed by a NUL
+ * byte. \todo FIXME merge this with end_of_header? */
#define EMPTYLINE(s) (((s)[0] == '\r' && (s)[1] == '\n' && (s)[2] == '\0') \
|| ((s)[0] == '\n' && (s)[1] == '\0'))
+/** Check if \a s is an empty line. Accept "\r*\n" as EOH in order to be bulletproof against broken survers */
static int end_of_header (const char *s)
-/* accept "\r*\n" as EOH in order to be bulletproof against broken survers */
{
while (s[0] == '\r')
s++;
return (s[0] == '\n' && s[1] == '\0');
}
+/** read message headers and ship to SMTP or MDA */
int readheaders(int sock,
long fetchlen,
long reallen,
struct query *ctl,
int num,
flag *suppress_readbody)
-/* read message headers and ship to SMTP or MDA */
-/* sock: to which the server is connected */
-/* fetchlen: length of message according to fetch response */
-/* reallen: length of message according to getsizes */
-/* ctl: query control record */
-/* num: index of message */
-/* suppress_readbody: whether call to readbody() should be supressed */
+/** \param sock to which the server is connected */
+/** \param fetchlen length of message according to fetch response */
+/** \param reallen length of message according to getsizes */
+/** \param ctl query control record */
+/** \param num index of message */
+/** \param suppress_readbody output: whether call to readbody() should be supressed */
{
struct addrblk
{
has_nuls = TRUE;
if (outlevel > O_SILENT)
report(stdout,
- GT_("incorrect header line found while scanning headers\n"));
+ GT_("incorrect header line found - see manpage for bad-header option\n"));
if (outlevel >= O_VERBOSE)
report (stdout, GT_("line: %s"), line);
refuse_mail = 1;
* our terminating combination \n\0, we move backwards to
* make sure that we don't catch some \n\0 stored in the
* decoded part of the message */
- for (tcp = line + linelen - 1; tcp > line && (*tcp != 0 || tcp[-1] != '\n'); tcp--);
+ for (tcp = line + linelen - 1; tcp > line && (*tcp != 0 || tcp[-1] != '\n'); tcp--) { }
if (tcp > line) linelen = tcp - line;
}
* turns on the dropstatus flag.
*/
{
- char *cp;
+ char *tcp;
if (!strncasecmp(line, "Status:", 7))
- cp = line + 7;
+ tcp = line + 7;
else if (!strncasecmp(line, "X-Mozilla-Status:", 17))
- cp = line + 17;
+ tcp = line + 17;
else
- cp = NULL;
- if (cp) {
- while (*cp && isspace((unsigned char)*cp)) cp++;
- if (!*cp || ctl->dropstatus)
+ tcp = NULL;
+ if (tcp) {
+ while (*tcp && isspace((unsigned char)*tcp)) tcp++;
+ if (!*tcp || ctl->dropstatus)
{
free(line);
continue;
free(sdps_envto);
} else
#endif /* SDPS_ENABLE */
- if (env_offs > -1) /* We have the actual envelope addressee */
- find_server_names(msgblk.headers + env_offs, ctl, &msgblk.recipients);
+ if (env_offs > -1) { /* We have the actual envelope addressee */
+ if (outlevel >= O_DEBUG) {
+ const char *tmps = msgblk.headers + env_offs;
+ size_t l = strcspn(tmps, "\r\n");
+ report(stdout, GT_("Parsing envelope \"%s\" names \"%-.*s\"\n"), ctl->server.envelope, UCAST_TO_INT(l), tmps);
+ }
+ find_server_names(msgblk.headers + env_offs, ctl, &msgblk.recipients);
+ }
else if (delivered_to && ctl->server.envelope != STRING_DISABLED &&
- ctl->server.envelope && !strcasecmp(ctl->server.envelope, "Delivered-To"))
- {
+ ctl->server.envelope && !strcasecmp(ctl->server.envelope, "Delivered-To"))
+ {
+ if (outlevel >= O_DEBUG) {
+ const char *tmps = delivered_to + 2 + strlen(ctl->server.envelope);
+ size_t l = strcspn(tmps, "\r\n");
+ report(stdout, GT_("Parsing envelope \"%s\" names \"%-.*s\"\n"), ctl->server.envelope, UCAST_TO_INT(l), tmps);
+ }
find_server_names(delivered_to, ctl, &msgblk.recipients);
xfree(delivered_to);
- }
- else if (received_for)
+ } else if (received_for) {
/*
* We have the Received for addressee.
* It has to be a mailserver address, or we
* We use find_server_names() to let local
* hostnames go through.
*/
+ if (outlevel >= O_DEBUG) {
+ const char *tmps = received_for + 2;
+ size_t l = strcspn(tmps, "\r\n");
+ report(stdout, GT_("Parsing Received names \"%-.*s\"\n"), UCAST_TO_INT(l), tmps);
+ }
find_server_names(received_for, ctl, &msgblk.recipients);
- else
- {
+ } else {
/*
* We haven't extracted the envelope address.
* So check all the "Resent-To" header addresses if
* the "To" addresses.
*/
register struct addrblk *nextptr;
+ if (outlevel >= O_DEBUG)
+ report(stdout, GT_("No envelope recipient found, resorting to header guessing.\n"));
if (resent_to_addrchain) {
/* delete the "To" chain and substitute it
* with the "Resent-To" list
}
/* now look for remaining adresses */
while (to_addrchain) {
+ if (outlevel >= O_DEBUG) {
+ const char *tmps = msgblk.headers+to_addrchain->offset;
+ size_t l = strcspn(tmps, "\r\n");
+ report(stdout, GT_("Guessing from header \"%-.*s\".\n"), UCAST_TO_INT(l), tmps);
+ }
+
find_server_names(msgblk.headers+to_addrchain->offset, ctl, &msgblk.recipients);
nextptr = to_addrchain->next;
free(to_addrchain);
for (idp = msgblk.recipients; idp; idp = idp->next)
if (idp->val.status.mark == XMIT_ACCEPT)
break; /* only report first address */
- snprintf(buf+1, sizeof(buf)-1,
- "for <%s>", rcpt_address (ctl, idp->id, 1));
+ if (idp)
+ snprintf(buf+1, sizeof(buf)-1,
+ "for <%s>", rcpt_address (ctl, idp->id, 1));
snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf)-1,
" (%s); ",
MULTIDROP(ctl) ? "multi-drop" : "single-drop");
}
int readbody(int sock, struct query *ctl, flag forward, int len)
-/* read and dispose of a message body presented on sock */
-/* ctl: query control record */
-/* sock: to which the server is connected */
-/* len: length of message */
-/* forward: TRUE to forward */
+/** read and dispose of a message body presented on \a sock */
+/** \param ctl query control record */
+/** \param sock to which the server is connected */
+/** \param forward TRUE to forward */
+/** \param len length of message */
{
int linelen;
char buf[MSGBUFSIZE+4];
* so we might end truncating messages prematurely.
*/
if (!protocol->delimited && linelen > len) {
+ /* FIXME: HACK ALERT! This \r\n is only here to make sure the
+ * \n\0 hunt works later on. The \n generated here was not
+ * part of the original message!
+ * The real fix will be to use buffer + length strings,
+ * rather than 0-terminated C strings. */
+ inbufp[len++] = '\r';
+ inbufp[len++] = '\n';
inbufp[len] = '\0';
+ linelen = len;
}
len -= linelen;
}
void init_transact(const struct method *proto)
-/* initialize state for the send and receive functions */
+/** initialize state for the send and receive functions */
{
suppress_tags = FALSE;
tagnum = 0;
tag[0] = '\0'; /* nuke any tag hanging out from previous query */
- protocol = (struct method *)proto;
+ protocol = proto;
shroud[0] = '\0';
}
+/** shroud a password in the given buffer */
static void enshroud(char *buf)
-/* shroud a password in the given buffer */
{
char *cp;
}
#if defined(HAVE_STDARG_H)
+/** assemble command in printf(3) style and send to the server */
void gen_send(int sock, const char *fmt, ... )
#else
void gen_send(sock, fmt, va_alist)
-int sock; /* socket to which server is connected */
-const char *fmt; /* printf-style format */
+int sock; /** socket to which server is connected */
+const char *fmt; /** printf-style format */
va_dcl
#endif
-/* assemble command in printf(3) style and send to the server */
{
char buf [MSGBUFSIZE+1];
va_list ap;
/** get one line of input from the server */
int gen_recv(int sock /** socket to which server is connected */,
- char *buf /* buffer to receive input */,
- int size /* length of buffer */)
+ char *buf /** buffer to receive input */,
+ int size /** length of buffer */)
{
+ size_t n;
int oldphase = phase; /* we don't have to be re-entrant */
phase = SERVER_WAIT;
else
{
set_timeout(0);
- if (buf[strlen(buf)-1] == '\n')
- buf[strlen(buf)-1] = '\0';
- if (buf[strlen(buf)-1] == '\r')
- buf[strlen(buf)-1] = '\0';
+ n = strlen(buf);
+ if (n > 0 && buf[n-1] == '\n')
+ buf[--n] = '\0';
+ if (n > 0 && buf[n-1] == '\r')
+ buf[--n] = '\0';
if (outlevel >= O_MONITOR)
report(stdout, "%s< %s\n", protocol->name, buf);
phase = oldphase;
}
}
+/** \addtogroup gen_recv_split
+ * @{
+ * gen_recv_split() splits the response from a server which is too
+ * long to fit into the buffer into multiple lines. If the prefix is
+ * set as "MY FEATURES" and the response from the server is too long
+ * to fit in the buffer, as in:
+ *
+ * "MY FEATURES ABC DEF GHI JKLMNOPQRS TU VWX YZ"
+ *
+ * Repeated calls to gen_recv_split() may return:
+ *
+ * "MY FEATURES ABC DEF GHI"
+ * "MY FEATURES JKLMNOPQRS"
+ * "MY FEATURES TU VWX YZ"
+ *
+ * A response not beginning with the prefix "MY FEATURES" will not be
+ * split.
+ *
+ * To use:
+ * - Declare a variable of type struct RecvSplit
+ * - Call gen_recv_split_init() once
+ * - Call gen_recv_split() in a loop, preferably with the same buffer
+ * size as the "buf" array in struct RecvSplit
+ */
+
+static void overrun(const char *f, size_t l) __attribute__((noreturn));
+
+/** Internal error report function. If this happens, the calling site
+ * needs to be adjusted to set a shorter prefix, or the prefix capacity
+ * needs to be raised in struct RecvSplit. */
+static void overrun(const char *f, size_t l)
+{
+ report(stderr, GT_("Buffer too small. This is a bug in the caller of %s:%lu.\n"), f, (unsigned long)l);
+ abort();
+}
+
+/** Initialize \a rs for later use by gen_recv_split. */
+void gen_recv_split_init (const char *prefix /** prefix to match/repeat */,
+ struct RecvSplit *rs /** structure to be initialized */)
+{
+ if (strlcpy(rs->prefix, prefix, sizeof(rs->prefix)) > sizeof(rs->prefix))
+ overrun(__FILE__, __LINE__);
+ rs->cached = 0;
+ rs->buf[0] = '\0';
+}
+
+/** Function to split replies at blanks, and duplicate prefix.
+ * gen_recv_split_init() must be called before this can be used. */
+int gen_recv_split(int sock /** socket to which server is connected */,
+ char *buf /** buffer to receive input */,
+ int size /** length of buffer, must be the same for all calls */,
+ struct RecvSplit *rs /** cached information across calls */)
+{
+ size_t n = 0;
+ int foundnewline = 0;
+ char *p;
+ int oldphase = phase; /* we don't have to be re-entrant */
+
+ assert(size > 0);
+
+ /* if this is not our first call, prepare the buffer */
+ if (rs->cached)
+ {
+ /*
+ * if this condition is not met, we lose data
+ * because the cached data does not fit into the buffer.
+ * this cannot happen if size is the same throughout all calls.
+ */
+ assert(strlen(rs->prefix) + strlen(rs->buf) + 1 <= (size_t)size);
+
+ if ((strlcpy(buf, rs->prefix, size) >= (size_t)size)
+ || (strlcat(buf, rs->buf, size) >= (size_t)size)) {
+ overrun(__FILE__, __LINE__);
+ }
+
+ n = strlen(buf);
+ /* clear the cache for the next call */
+ rs->cached = 0;
+ rs->buf[0] = '\0';
+ }
+
+ if ((size_t)size > n) {
+ int rr;
+
+ phase = SERVER_WAIT;
+ set_timeout(mytimeout);
+ rr = SockRead(sock, buf + n, size - n);
+ set_timeout(0);
+ phase = oldphase;
+ if (rr == -1)
+ return PS_SOCKET;
+ }
+
+ n = strlen(buf);
+ if (n > 0 && buf[n-1] == '\n')
+ {
+ buf[--n] = '\0';
+ foundnewline = 1;
+ }
+ if (n > 0 && buf[n-1] == '\r')
+ buf[--n] = '\0';
+
+ if (foundnewline /* we have found a complete line */
+ || strncasecmp(buf, rs->prefix, strlen(rs->prefix)) /* mismatch in prefix */
+ || !(p = strrchr(buf, ' ')) /* no space found in response */
+ || p < buf + strlen(rs->prefix)) /* space is at the wrong location */
+ {
+ if (outlevel >= O_MONITOR)
+ report(stdout, "%s< %s\n", protocol->name, buf);
+ return(PS_SUCCESS);
+ }
+
+ /* we are ready to cache some information now. */
+ rs->cached = 1;
+ if (strlcpy(rs->buf, p, sizeof(rs->buf)) >= sizeof(rs->buf)) {
+ overrun(__FILE__, __LINE__);
+ }
+ *p = '\0'; /* chop off what we've cached */
+ if (outlevel >= O_MONITOR)
+ report(stdout, "%s< %s\n", protocol->name, buf);
+ if (outlevel >= O_DEBUG)
+ report(stdout, "%s< %s%s...\n", protocol->name, rs->prefix, rs->buf);
+ return(PS_SUCCESS);
+}
+/** @} */
+
#if defined(HAVE_STDARG_H)
int gen_transact(int sock, const char *fmt, ... )
#else
int gen_transact(int sock, fmt, va_alist)
-int sock; /* socket to which server is connected */
-const char *fmt; /* printf-style format */
+int sock; /** socket to which server is connected */
+const char *fmt; /** printf-style format */
va_dcl
#endif
-/* assemble command in printf(3) style, send to server, accept a response */
+/** assemble command in printf(3) style, send to server, fetch a response */
{
int ok;
char buf [MSGBUFSIZE+1];
projects / ~andy / fetchmail / blobdiff