/* * driver.c -- generic driver for mail fetch method protocols * * Copyright 1996 by Eric S. Raymond * All rights reserved. * For license terms, see the file COPYING in this directory. */ #include #include #include #include #include #if defined(STDC_HEADERS) #include #endif #if defined(HAVE_UNISTD_H) #include #endif #if defined(HAVE_STDARG_H) #include #else #include #endif #include #include #ifdef HAVE_GETHOSTBYNAME #include #include "mx.h" #endif /* HAVE_GETHOSTBYNAME */ #ifdef KERBEROS_V4 #include #include #include /* must be included before "socket.h".*/ #include #endif /* KERBEROS_V4 */ #include "socket.h" #include "fetchmail.h" #include "smtp.h" #define SMTP_PORT 25 /* standard SMTP service port */ int batchlimit; /* how often to tear down the delivery connection */ int batchcount; /* count of messages sent in current batch */ static const struct method *protocol; static jmp_buf restart; char tag[TAGLEN]; static int tagnum; #define GENSYM (sprintf(tag, "a%04d", ++tagnum), tag) static char *shroud; /* string to shroud in debug output, if non-NULL */ static int mytimeout; /* value of nonreponse timeout */ static int strcrlf(dst, src, count) /* replace LFs with CR-LF; return length of string with replacements */ char *dst; /* new string with CR-LFs */ char *src; /* original string with LFs */ int count; /* length of src */ { int len = count; while (count--) { if (*src == '\n') { *dst++ = '\r'; len++; } *dst++ = *src++; } *dst = '\0'; return len; } static void vtalarm(int timeleft) /* reset the nonresponse-timeout */ { struct itimerval ntimeout; ntimeout.it_interval.tv_sec = ntimeout.it_interval.tv_usec = 0; ntimeout.it_value.tv_sec = timeleft; ntimeout.it_value.tv_usec = 0; setitimer(ITIMER_VIRTUAL, &ntimeout, (struct itimerval *)NULL); } static void vtalarm_handler (int signal) /* handle server-timeout SIGVTALARM signal */ { longjmp(restart, 1); } #ifdef HAVE_RES_SEARCH #define MX_RETRIES 3 static int is_host_alias(const char *name, struct query *ctl) /* determine whether name is a DNS alias of the hostname */ { struct hostent *he; struct mxentry *mxp, *mxrecords; /* * The first two checks are optimizations that will catch a good * many cases. First, check against the hostname the user specified. * Odds are good this will either be the mailserver's FQDN or a * suffix of it with the mailserver's domain's default host name * omitted. Next, check against the mailserver's FQDN, in case * it's not the same as the declared hostname. * * Either of these on a mail address is definitive. Only if the * name doesn't match either is it time to call the bind library. * If this happens odds are good we're looking at an MX name. */ if (strcmp(name, ctl->servername) == 0) return(TRUE); else if (strcmp(name, ctl->canonical_name) == 0) return(TRUE); /* * Is it in the `also known as' cache accumulated by previous DNS checks? * This cache may someday be primed by an aka option. */ else if (uid_in_list(&ctl->lead_server->aka, name)) return(TRUE); /* * We know DNS service was up at the beginning of this poll cycle. * If it's down, our nameserver has crashed. We don't want to try * delivering the current message or anything else from this * mailbox until it's back up. */ else if ((he = gethostbyname(name)) != (struct hostent *)NULL) { if (strcmp(ctl->canonical_name, he->h_name) == 0) goto match; else return(FALSE); } else switch (h_errno) { case HOST_NOT_FOUND: /* specified host is unknown */ case NO_ADDRESS: /* valid, but does not have an IP address */ break; case NO_RECOVERY: /* non-recoverable name server error */ case TRY_AGAIN: /* temporary error on authoritative server */ default: if (outlevel != O_SILENT) putchar('\n'); /* terminate the progress message */ fprintf(stderr, "fetchmail: nameserver failure while looking for `%s' during poll of %s.\n", name, ctl->servername); ctl->errcount++; longjmp(restart, 2); /* try again next poll cycle */ break; } /* * We're only here if DNS was OK but the gethostbyname() failed * with a HOST_NOT_FOUND or NO_ADDRESS error. * Search for a name match on MX records pointing to the server. */ h_errno = 0; if ((mxrecords = getmxrecords(name)) == (struct mxentry *)NULL) switch (h_errno) { case HOST_NOT_FOUND: /* specified host is unknown */ return(FALSE); case NO_ADDRESS: /* valid, but does not have an IP address */ for (mxp = mxrecords; mxp->name; mxp++) if (strcmp(name, mxp->name) == 0) goto match; break; case NO_RECOVERY: /* non-recoverable name server error */ case TRY_AGAIN: /* temporary error on authoritative server */ default: fprintf(stderr, "fetchmail: nameserver failure while looking for `%s' during poll of %s.\n", name, ctl->servername); ctl->errcount++; longjmp(restart, 2); /* try again next poll cycle */ break; } return(FALSE); match: /* add this name to relevant server's `also known as' list */ save_uid(&ctl->lead_server->aka, -1, name); return(TRUE); } void find_server_names(hdr, ctl, xmit_names) /* parse names out of a RFC822 header into an ID list */ const char *hdr; /* RFC822 header in question */ struct query *ctl; /* list of permissible aliases */ struct idlist **xmit_names; /* list of recipient names parsed out */ { if (hdr == (char *)NULL) return; else { char *cp, *lname; if ((cp = nxtaddr(hdr)) != (char *)NULL) do { char *atsign; if ((atsign = strchr(cp, '@'))) { /* * Address has an @. Check to see if the right-hand part * is an alias or MX equivalent of the mailserver. If it's * not, skip this name. If it is, we'll keep going and try * to find a mapping to a client name. */ if (!is_host_alias(atsign+1, ctl)) continue; atsign[0] = '\0'; } lname = idpair_find(&ctl->localnames, cp); if (lname != (char *)NULL) { if (outlevel == O_VERBOSE) fprintf(stderr, "fetchmail: mapped %s to local %s\n", cp, lname); save_uid(xmit_names, -1, lname); } } while ((cp = nxtaddr((char *)NULL)) != (char *)NULL); } } #endif /* HAVE_RES_SEARCH */ static FILE *smtp_open(struct query *ctl) /* try to open a socket to the appropriate SMTP server for this query */ { ctl = ctl->lead_smtp; /* go to the SMTP leader for this query */ /* maybe it's time to close the socket in order to force delivery */ if (batchlimit && ctl->smtp_sockfp && batchcount++ == batchlimit) { fclose(ctl->smtp_sockfp); ctl->smtp_sockfp = (FILE *)NULL; batchcount = 0; } /* if no socket to this host is already set up, try to open one */ if (ctl->smtp_sockfp == (FILE *)NULL) { if ((ctl->smtp_sockfp = Socket(ctl->smtphost, SMTP_PORT)) == (FILE *)NULL) return((FILE *)NULL); else if (SMTP_ok(ctl->smtp_sockfp) != SM_OK || SMTP_helo(ctl->smtp_sockfp, ctl->servername) != SM_OK) { fclose(ctl->smtp_sockfp); ctl->smtp_sockfp = (FILE *)NULL; } } return(ctl->smtp_sockfp); } static int gen_readmsg (sockfp, len, delimited, ctl) /* read message content and ship to SMTP or MDA */ FILE *sockfp; /* to which the server is connected */ long len; /* length of message */ int delimited; /* does the protocol use a message delimiter? */ struct query *ctl; /* query control record */ { char buf [MSGBUFSIZE+1]; char *bufp, *headers, *fromhdr,*tohdr,*cchdr,*bcchdr,*received_for,*envto; int n, oldlen, mboxfd; int inheaders,lines,sizeticker; FILE *sinkfp; #ifdef HAVE_GETHOSTBYNAME char rbuf[HOSTLEN + USERNAMELEN + 4]; #endif /* HAVE_GETHOSTBYNAME */ /* read the message content from the server */ inheaders = 1; headers = fromhdr = tohdr = cchdr = bcchdr = received_for = envto = NULL; lines = 0; sizeticker = 0; oldlen = 0; while (delimited || len > 0) { if ((n = SockGets(buf,sizeof(buf),sockfp)) < 0) return(PS_SOCKET); vtalarm(ctl->timeout); /* write the message size dots */ if (n > 0) { sizeticker += n; while (sizeticker >= SIZETICKER) { if (outlevel > O_SILENT) fputc('.',stderr); sizeticker -= SIZETICKER; } } len -= n; bufp = buf; if (buf[0] == '\0' || buf[0] == '\r' || buf[0] == '\n') inheaders = 0; if (delimited && *bufp == '.') { bufp++; if (*bufp == 0) break; /* end of message */ } strcat(bufp, "\n"); if (inheaders) { if (!ctl->norewrite) reply_hack(bufp, ctl->servername); if (!lines) { oldlen = strlen(bufp); headers = xmalloc(oldlen + 1); (void) strcpy(headers, bufp); bufp = headers; } else { int newlen; /* * We deal with RFC822 continuation lines here. * Replace previous '\n' with '\r' so nxtaddr * and reply_hack will be able to see past it. * (We know this is safe because SocketGets stripped * out all carriage returns in the read loop above * and we haven't reintroduced any since then.) * We'll undo this before writing the header. */ if (isspace(bufp[0])) headers[oldlen-1] = '\r'; newlen = oldlen + strlen(bufp); headers = realloc(headers, newlen + 1); if (headers == NULL) return(PS_IOERR); strcpy(headers + oldlen, bufp); bufp = headers + oldlen; oldlen = newlen; } if (!strncasecmp("From:", bufp, 5)) fromhdr = bufp; else if (!fromhdr && !strncasecmp("Resent-From:", bufp, 12)) fromhdr = bufp; else if (!fromhdr && !strncasecmp("Apparently-From:", bufp, 16)) fromhdr = bufp; else if (!strncasecmp("To:", bufp, 3)) tohdr = bufp; else if (!strncasecmp("Apparently-To:", bufp, 14)) envto = bufp; else if (!strncasecmp("X-Envelope-To:", bufp, 14)) envto = bufp; else if (!strncasecmp("Cc:", bufp, 3)) cchdr = bufp; else if (!strncasecmp("Bcc:", bufp, 4)) bcchdr = bufp; #ifdef HAVE_GETHOSTBYNAME else if (MULTIDROP(ctl) && !strncasecmp("Received:", bufp, 9)) { char *ok; /* * Try to extract the real envelope addressee. We look here * specifically for the mailserver's Received line. * Note: this will only work for sendmail, or an MTA that * shares sendmail's convention of embedding the envelope * address in the Received line. */ strcpy(rbuf, "by "); strcat(rbuf, ctl->canonical_name); if ((ok = strstr(bufp, rbuf))) ok = strstr(ok, "for <"); else ok = (char *)NULL; if (ok) { char *sp, *tp; tp = rbuf; for (sp = ok + 5; *sp && *sp != '>' && *sp != '@'; sp++) *tp++ = *sp; *tp = '\0'; if (*sp != ';' && *sp != '@') ok = (char *)NULL; } if (ok) { received_for = alloca(strlen(rbuf)+1); strcpy(received_for, rbuf); if (outlevel == O_VERBOSE) fprintf(stderr, "fetchmail: found Received address `%s'\n", received_for); } } #endif /* HAVE_GETHOSTBYNAME */ goto skipwrite; } else if (headers) /* OK, we're at end of headers now */ { char *cp; struct idlist *idp, *xmit_names; int good_addresses, bad_addresses; #ifdef HAVE_RES_SEARCH int no_local_matches = FALSE; #endif /* HAVE_RES_SEARCH */ /* cons up a list of local recipients */ xmit_names = (struct idlist *)NULL; bad_addresses = good_addresses = 0; #ifdef HAVE_RES_SEARCH /* is this a multidrop box? */ if (MULTIDROP(ctl)) { if (envto) /* We have the actual envelope addressee */ find_server_names(envto, ctl, &xmit_names); else if (received_for) /* * We have the Received for addressee. * It has to be a mailserver address, or we * wouldn't have got here. */ find_server_names(received_for, ctl, &xmit_names); else { /* * We haven't extracted the envelope address. * So check all the header addresses. */ find_server_names(tohdr, ctl, &xmit_names); find_server_names(cchdr, ctl, &xmit_names); find_server_names(bcchdr, ctl, &xmit_names); } if (!xmit_names) { no_local_matches = TRUE; save_uid(&xmit_names, -1, user); if (outlevel == O_VERBOSE) fprintf(stderr, "fetchmail: no local matches, forwarding to %s\n", user); } } else /* it's a single-drop box, use first localname */ #endif /* HAVE_RES_SEARCH */ save_uid(&xmit_names, -1, ctl->localnames->id); /* time to address the message */ if (ctl->mda[0]) /* we have a declared MDA */ { int i, nlocals = 0; char **sargv, **sp; /* * We go through this in order to be able to handle very * long lists of users and (re)implement %s. */ for (idp = xmit_names; idp; idp = idp->next) nlocals++; sp = sargv = (char **)alloca(sizeof(char **) * ctl->mda_argcount+nlocals+2); for (i = 0; i < ctl->mda_argcount; i++) if (strcmp("%s", ctl->mda_argv[i])) *sp++ = ctl->mda_argv[i]; else for (idp = xmit_names; idp; idp = idp->next) *sp++ = idp->id; *sp = (char *)NULL; #ifdef HAVE_SETEUID /* * Arrange to run with user's permissions if we're root. * This will initialize the ownership of any files the * MDA creates properly. (The seteuid call is available * under all BSDs and Linux) */ seteuid(ctl->uid); #endif /* HAVE_SETEUID */ mboxfd = openmailpipe(sargv); #ifdef HAVE_SETEUID /* this will fail quietly if we didn't start as root */ seteuid(0); #endif /* HAVE_SETEUID */ if (mboxfd < 0) { fprintf(stderr, "fetchmail: MDA open failed\n"); return(PS_IOERR); } } else { char *ap; /* build a connection to the SMTP listener */ if (ctl->mda[0] == '\0' && ((sinkfp = smtp_open(ctl)) == NULL)) { free_uid_list(&xmit_names); fprintf(stderr, "fetchmail: SMTP connect failed\n"); return(PS_SMTP); } /* * Try to get the SMTP listener to take the header * From address as MAIL FROM (this makes the logging * nicer). If it won't, fall back on the calling-user * ID. This won't affect replies, which use the header * From address anyway. */ if (!fromhdr || !(ap = nxtaddr(fromhdr)) || SMTP_from(sinkfp, ap) != SM_OK) if (SMTP_from(sinkfp, user) != SM_OK) return(PS_SMTP); /* should never happen */ /* now list the recipient addressees */ for (idp = xmit_names; idp; idp = idp->next) if (SMTP_rcpt(sinkfp, idp->id) == SM_OK) good_addresses++; else { bad_addresses++; idp->val.num = 0; fprintf(stderr, "fetchmail: SMTP listener doesn't like recipient address `%s'\n", idp->id); } if (!good_addresses && SMTP_rcpt(sinkfp, user) != SM_OK) { fprintf(stderr, "fetchmail: can't even send to calling user!\n"); return(PS_SMTP); } /* tell it we're ready to send data */ SMTP_data(sinkfp); if (outlevel == O_VERBOSE) fputs("SMTP> ", stderr); } /* change continuation markers back to regular newlines */ for (cp = headers; cp < headers + oldlen; cp++) if (*cp == '\r') *cp = '\n'; /* replace all LFs with CR-LF before sending to the SMTP server */ if (!ctl->mda[0]) { char *newheaders = xmalloc(1 + oldlen * 2); oldlen = strcrlf(newheaders, headers, oldlen); free(headers); headers = newheaders; } /* write all the headers */ if (ctl->mda[0]) n = write(mboxfd,headers,oldlen); else n = SockWrite(headers, oldlen, sinkfp); if (n < 0) { free(headers); headers = NULL; perror("fetchmail: writing RFC822 headers"); return(PS_IOERR); } else if (outlevel == O_VERBOSE) fputs("#", stderr); free(headers); headers = NULL; /* write error notifications */ #ifdef HAVE_RES_SEARCH if (no_local_matches || bad_addresses) #else if (bad_addresses) #endif /* HAVE_RES_SEARCH */ { int errlen = 0; char errhd[USERNAMELEN + POPBUFSIZE], *errmsg; errmsg = errhd; (void) strcpy(errhd, "X-Fetchmail-Warning: "); #ifdef HAVE_RES_SEARCH if (no_local_matches) { strcat(errhd, "no recipient addresses matched declared local names"); if (bad_addresses) strcat(errhd, "; "); } #endif /* HAVE_RES_SEARCH */ if (bad_addresses) { strcat(errhd, "SMTP listener rejected local recipient addresses: "); errlen = strlen(errhd); for (idp = xmit_names; idp; idp = idp->next) if (!idp->val.num) errlen += strlen(idp->id) + 2; errmsg = alloca(errlen+3); (void) strcpy(errmsg, errhd); for (idp = xmit_names; idp; idp = idp->next) if (!idp->val.num) { strcat(errmsg, idp->id); if (idp->next) strcat(errmsg, ", "); } } strcat(errmsg, "\n"); if (ctl->mda[0]) write(mboxfd, errmsg, strlen(errmsg)); else SockWrite(errmsg, strlen(errmsg), sinkfp); } free_uid_list(&xmit_names); } /* SMTP byte-stuffing */ if (*bufp == '.' && ctl->mda[0] == 0) SockWrite(".", 1, sinkfp); /* replace all LFs with CR-LF in the line */ if (!ctl->mda[0]) { char *newbufp = xmalloc(1 + strlen(bufp) * 2); strcrlf(newbufp, bufp, strlen(bufp)); bufp = newbufp; } /* ship out the text line */ if (ctl->mda[0]) n = write(mboxfd,bufp,strlen(bufp)); else n = SockWrite(bufp, strlen(bufp), sinkfp); if (!ctl->mda[0]) free(bufp); if (n < 0) { perror("fetchmail: writing message text"); return(PS_IOERR); } else if (outlevel == O_VERBOSE) fputc('*', stderr); skipwrite:; lines++; } if (ctl->mda[0]) { /* close the delivery pipe, we'll reopen before next message */ if (closemailpipe(mboxfd)) return(PS_IOERR); } else { /* write message terminator */ if (SMTP_eom(sinkfp) != SM_OK) { fputs("fetchmail: SMTP listener refused delivery\n", stderr); return(PS_SMTP); } } return(0); } #ifdef KERBEROS_V4 int kerberos_auth (socket, canonical) /* authenticate to the server host using Kerberos V4 */ int socket; /* socket to server host */ const char *canonical; /* server name */ { char * host_primary; KTEXT ticket; MSG_DAT msg_data; CREDENTIALS cred; Key_schedule schedule; int rem; ticket = ((KTEXT) (malloc (sizeof (KTEXT_ST)))); rem = (krb_sendauth (0L, socket, ticket, "pop", canonical, ((char *) (krb_realmofhost (canonical))), ((unsigned long) 0), (&msg_data), (&cred), (schedule), ((struct sockaddr_in *) 0), ((struct sockaddr_in *) 0), "KPOPV0.1")); free (ticket); if (rem != KSUCCESS) { fprintf (stderr, "fetchmail: kerberos error %s\n", (krb_get_err_text (rem))); return (PS_ERROR); } return (0); } #endif /* KERBEROS_V4 */ 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 */ { int ok, js; void (*sigsave)(); #ifndef KERBEROS_V4 if (ctl->authenticate == A_KERBEROS) { fputs("fetchmail: Kerberos support not linked.\n", stderr); return(PS_ERROR); } #endif /* KERBEROS_V4 */ /* lacking methods, there are some options that may fail */ if (!proto->is_old) { /* check for unsupported options */ if (ctl->flush) { fprintf(stderr, "Option --flush is not supported with %s\n", proto->name); return(PS_SYNTAX); } else if (ctl->fetchall) { fprintf(stderr, "Option --all is not supported with %s\n", proto->name); return(PS_SYNTAX); } } if (!proto->getsizes && ctl->limit) { fprintf(stderr, "Option --limit is not supported with %s\n", proto->name); return(PS_SYNTAX); } protocol = proto; tagnum = 0; tag[0] = '\0'; /* nuke any tag hanging out from previous query */ ok = 0; /* set up the server-nonresponse timeout */ sigsave = signal(SIGVTALRM, vtalarm_handler); vtalarm(mytimeout = ctl->timeout); if ((js = setjmp(restart)) == 1) { fprintf(stderr, "fetchmail: timeout after %d seconds waiting for %s.\n", ctl->timeout, ctl->servername); ok = PS_ERROR; } else if (js == 2) { /* error message printed at point of longjmp */ ok = PS_ERROR; } else { char buf [POPBUFSIZE+1]; int *msgsizes, len, num, count, new, deletions = 0; FILE *sockfp; /* open a socket to the mail server */ if ((sockfp = Socket(ctl->servername, ctl->port ? ctl->port : protocol->port)) == NULL) { perror("fetchmail, connecting to host"); ok = PS_SOCKET; goto closeUp; } #ifdef KERBEROS_V4 if (ctl->authenticate == A_KERBEROS) { ok = (kerberos_auth (fileno(sockfp), ctl->canonical_name)); vtalarm(ctl->timeout); if (ok != 0) goto cleanUp; } #endif /* KERBEROS_V4 */ /* accept greeting message from mail server */ ok = (protocol->parse_response)(sockfp, buf); vtalarm(ctl->timeout); if (ok != 0) goto cleanUp; /* try to get authorized to fetch mail */ shroud = ctl->password; ok = (protocol->getauth)(sockfp, ctl, buf); vtalarm(ctl->timeout); shroud = (char *)NULL; if (ok == PS_ERROR) ok = PS_AUTHFAIL; if (ok != 0) goto cleanUp; /* compute number of messages and number of new messages waiting */ if ((protocol->getrange)(sockfp, ctl, &count, &new) != 0) goto cleanUp; vtalarm(ctl->timeout); /* show user how many messages we downloaded */ if (outlevel > O_SILENT) if (count == 0) fprintf(stderr, "No mail from %s@%s\n", ctl->remotename, ctl->servername); else { fprintf(stderr, "%d message%s", count, count > 1 ? "s" : ""); if (new != -1 && (count - new) > 0) fprintf(stderr, " (%d seen)", count-new); fprintf(stderr, " from %s@%s.\n", ctl->remotename, ctl->servername); } /* we may need to get sizes in order to check message limits */ msgsizes = (int *)NULL; if (!ctl->fetchall && proto->getsizes && ctl->limit) { msgsizes = (int *)alloca(sizeof(int) * count); if ((ok = (proto->getsizes)(sockfp, count, msgsizes)) != 0) return(PS_ERROR); } if (check_only) { if (new == -1 || ctl->fetchall) new = count; ok = ((new > 0) ? PS_SUCCESS : PS_NOMAIL); goto closeUp; } else if (count > 0) { /* * What forces this code is that in POP3 you can't fetch a * message without having it marked `seen'. * * The result 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. */ int force_retrieval = (ctl->errcount > 0); ctl->errcount = 0; /* read, forward, and delete messages */ for (num = 1; num <= count; num++) { int toolarge = msgsizes && (msgsizes[num-1] > ctl->limit); int fetch_it = ctl->fetchall || (!toolarge && (force_retrieval || !(protocol->is_old && (protocol->is_old)(sockfp,ctl,num)))); /* we may want to reject this message if it's old */ if (!fetch_it) { if (outlevel > O_SILENT) { fprintf(stderr, "skipping message %d", num); if (toolarge) fprintf(stderr, " (oversized, %d bytes)", msgsizes[num-1]); } } else { /* request a message */ (protocol->fetch)(sockfp, num, &len); vtalarm(ctl->timeout); if (outlevel > O_SILENT) { fprintf(stderr, "reading message %d", num); if (len > 0) fprintf(stderr, " (%d bytes)", len); if (outlevel == O_VERBOSE) fputc('\n', stderr); else fputc(' ', stderr); } /* read the message and ship it to the output sink */ ok = gen_readmsg(sockfp, len, protocol->delimited, ctl); vtalarm(ctl->timeout); if (ok != 0) goto cleanUp; /* tell the server we got it OK and resynchronize */ if (protocol->trail) (protocol->trail)(sockfp, ctl, num); } /* * 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. */ /* maybe we delete this message now? */ if (protocol->delete && (fetch_it ? !ctl->keep : ctl->flush)) { deletions++; if (outlevel > O_SILENT) fprintf(stderr, " flushed\n"); ok = (protocol->delete)(sockfp, ctl, num); vtalarm(ctl->timeout); if (ok != 0) goto cleanUp; delete_uid(&ctl->newsaved, num); } else if (outlevel > O_SILENT) fprintf(stderr, " not flushed\n"); } /* remove all messages flagged for deletion */ if (protocol->expunge_cmd && deletions > 0) { ok = gen_transact(sockfp, protocol->expunge_cmd); if (ok != 0) goto cleanUp; } ok = gen_transact(sockfp, protocol->exit_cmd); if (ok == 0) ok = PS_SUCCESS; fclose(sockfp); goto closeUp; } else { ok = gen_transact(sockfp, protocol->exit_cmd); if (ok == 0) ok = PS_NOMAIL; fclose(sockfp); goto closeUp; } cleanUp: if (ok != 0 && ok != PS_SOCKET) { gen_transact(sockfp, protocol->exit_cmd); fclose(sockfp); } } switch (ok) { case PS_SOCKET: fputs("fetchmail: socket", stderr); break; case PS_AUTHFAIL: fputs("fetchmail: authorization", stderr); break; case PS_SYNTAX: fputs("fetchmail: missing or bad RFC822 header", stderr); break; case PS_IOERR: fputs("fetchmail: MDA", stderr); break; case PS_ERROR: fputs("fetchmail: client/server synchronization", stderr); break; case PS_PROTOCOL: fputs("fetchmail: client/server protocol", stderr); break; case PS_SMTP: fputs("fetchmail: SMTP transaction", stderr); break; case PS_UNDEFINED: fputs("fetchmail: undefined", stderr); break; } if (ok==PS_SOCKET || ok==PS_AUTHFAIL || ok==PS_SYNTAX || ok==PS_IOERR || ok==PS_ERROR || ok==PS_PROTOCOL || ok==PS_SMTP) fprintf(stderr, " error while talking to %s\n", ctl->servername); closeUp: signal(SIGVTALRM, sigsave); return(ok); } #if defined(HAVE_STDARG_H) void gen_send(FILE *sockfp, char *fmt, ... ) /* assemble command in printf(3) style and send to the server */ { #else void gen_send(sockfp, fmt, va_alist) /* assemble command in printf(3) style and send to the server */ FILE *sockfp; /* socket to which server is connected */ const char *fmt; /* printf-style format */ va_dcl { #endif char buf [POPBUFSIZE+1]; va_list ap; if (protocol->tagged) (void) sprintf(buf, "%s ", GENSYM); else buf[0] = '\0'; #if defined(HAVE_STDARG_H) va_start(ap, fmt) ; #else va_start(ap); #endif vsprintf(buf + strlen(buf), fmt, ap); va_end(ap); strcat(buf, "\r\n"); SockWrite(buf, strlen(buf), sockfp); if (outlevel == O_VERBOSE) { char *cp; if (shroud && (cp = strstr(buf, shroud))) memset(cp, '*', strlen(shroud)); fprintf(stderr,"> %s", buf); } } #if defined(HAVE_STDARG_H) int gen_transact(FILE *sockfp, char *fmt, ... ) /* assemble command in printf(3) style, send to server, accept a response */ { #else int gen_transact(sockfp, fmt, va_alist) /* assemble command in printf(3) style, send to server, accept a response */ FILE *sockfp; /* socket to which server is connected */ const char *fmt; /* printf-style format */ va_dcl { #endif int ok; char buf [POPBUFSIZE+1]; va_list ap; if (protocol->tagged) (void) sprintf(buf, "%s ", GENSYM); else buf[0] = '\0'; #if defined(HAVE_STDARG_H) va_start(ap, fmt) ; #else va_start(ap); #endif vsprintf(buf + strlen(buf), fmt, ap); va_end(ap); strcat(buf, "\r\n"); SockWrite(buf, strlen(buf), sockfp); if (outlevel == O_VERBOSE) { char *cp; if (shroud && (cp = strstr(buf, shroud))) memset(cp, '*', strlen(shroud)); fprintf(stderr,"> %s", buf); } /* we presume this does its own response echoing */ ok = (protocol->parse_response)(sockfp, buf); vtalarm(mytimeout); return(ok); } /* driver.c ends here */