X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=pop3.c;h=b557a0e966f11f1d4841cb4a0d4ccfcb84f0be85;hb=c5b468066e7dcf28f94a65bb56189afb87ed48a4;hp=f5623cfd20cac958a6a3dc48601efa498cc399a2;hpb=45ba00921a83a7744a5f8fedad7dbd0652eb9812;p=~andy%2Ffetchmail diff --git a/pop3.c b/pop3.c index f5623cfd..b557a0e9 100644 --- a/pop3.c +++ b/pop3.c @@ -1,870 +1,483 @@ -/* Copyright 1993-95 by Carl Harris, Jr. Copyright 1996 by Eric S. Raymond - * All rights reserved. +/* + * pop3.c -- POP3 protocol methods + * * For license terms, see the file COPYING in this directory. */ -/*********************************************************************** - module: pop3.c - project: popclient - programmer: Carl Harris, ceharris@mal.com - Hacks and bug fixes by esr. - description: POP3 client code. - - ***********************************************************************/ - -#include +#include "config.h" #include -#if defined(STDC_HEADERS) #include -#endif -#if defined(HAVE_UNISTD_H) -#include -#endif - -#include #include -#include - -#include "socket.h" -#include "popclient.h" - -#define POP3_PORT 110 - -#ifdef HAVE_PROTOTYPES -/* prototypes for internal functions */ -int POP3_OK (char *buf, int socket); -int POP3_auth (struct hostrec *options, int socket); -int POP3_sendQUIT (int socket); -int POP3_sendSTAT (int *msgcount, int socket); -int POP3_sendRETR (int msgnum, int socket); -int POP3_sendDELE (int msgnum, int socket); -int POP3_sendLAST (int *last, int socket); -int POP3_sendUIDL (int num, int socket, char **cp); -int POP3_readmsg (int socket, int mboxfd, char *host, int topipe, int rewrite); -int POP3_BuildDigest (char *buf, struct hostrec *options); +#if defined(HAVE_UNISTD_H) +#include #endif - - -/********************************************************************* - function: doPOP3 - description: retrieve messages from the specified mail server - using Post Office Protocol 3. - - arguments: - queryctl fully-specified options (i.e. parsed, defaults invoked, - etc). - - return value: exit code from the set of PS_.* constants defined in - popclient.h - calls: - globals: reads outlevel. - *********************************************************************/ - -int doPOP3 (queryctl) -struct hostrec *queryctl; -{ - int ok, use_uidl; - int mboxfd; - char buf [POPBUFSIZE]; - int socket; - int first,number,count; - - - /* open stdout or the mailbox, locking it if it is a folder */ - if (queryctl->output == TO_FOLDER || queryctl->output == TO_STDOUT) - if ((mboxfd = openuserfolder(queryctl)) < 0) - return(PS_IOERR); - - /* open the socket and get the greeting */ - if ((socket = Socket(queryctl->servername,POP3_PORT)) < 0) { - perror("doPOP3: socket"); - ok = PS_SOCKET; - goto closeUp; - } - - ok = POP3_OK(buf,socket); - if (ok != 0) { - if (ok != PS_SOCKET) - POP3_sendQUIT(socket); - close(socket); - goto closeUp; - } - - /* print the greeting */ - if (outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"pop3 greeting: %s\n",buf); - else - ; - -#if defined(HAVE_APOP_SUPPORT) - /* build MD5 digest from greeting timestamp + password */ - if (queryctl->whichpop == P_APOP) - if (POP3_BuildDigest(buf,queryctl) != 0) { - ok = PS_AUTHFAIL; - goto closeUp; - } else - ; - else - ; /* not using APOP protocol this time */ +#if defined(STDC_HEADERS) +#include #endif + +#include "fetchmail.h" +#include "socket.h" - /* try to get authorized */ - ok = POP3_auth(queryctl,socket); - if (ok == PS_ERROR) - ok = PS_AUTHFAIL; - if (ok != 0) - goto cleanUp; - - /* find out how many messages are waiting */ - ok = POP3_sendSTAT(&count,socket); - if (ok != 0) { - goto cleanUp; - } - - /* - * Ask for number of last message retrieved. - * Newer, RFC-1760-conformant POP servers may not have the LAST command. - * Therefore we don't croak if we get a nonzero return. Instead, send - * UIDL and try to find the last received ID stored for this host in - * the list we get back. - */ - first = 1; - use_uidl = 0; - if (!queryctl->fetchall) { - char buf [POPBUFSIZE]; - char id [IDLEN]; - int num; - - /* try LAST first */ - ok = POP3_sendLAST(&first, socket); - use_uidl = (ok != 0); - - /* otherwise, if we have a stored last ID for this host, - * send UIDL and search the returned list for it - */ - if (use_uidl && queryctl->lastid[0]) { - if ((ok = POP3_sendUIDL(-1, socket, 0)) == 0) { - while (SockGets(socket, buf, sizeof(buf)) >= 0) { - if (outlevel == O_VERBOSE) - fprintf(stderr,"%s\n",buf); - if (strcmp(buf, ".\n") == 0) { - break; - } - if (sscanf(buf, "%d %s\n", &num, id) == 2) - if (strcmp(id, queryctl->lastid) == 0) - first = num; - } - } - } - - if (ok == 0) - first++; - } - - /* show them how many messages we'll be downloading */ - if (outlevel > O_SILENT && outlevel < O_VERBOSE) - if (first > 1) - fprintf(stderr,"%d messages in folder, %d new messages.\n", - count, count - first + 1); - else - fprintf(stderr,"%d %smessages in folder.\n", count, ok ? "" : "new "); - else - ; - - if (count > 0) { - for (number = queryctl->flush ? 1 : first; number <= count; number++) { - - char *cp; - - /* open the mail pipe if we're using an MDA */ - if (queryctl->output == TO_MDA - && (queryctl->fetchall || number >= first)) { - ok = (mboxfd = openmailpipe(queryctl)) < 0 ? -1 : 0; - if (ok != 0) - goto cleanUp; - } - - if (queryctl->flush && number < first && !queryctl->fetchall) - ok = 0; /* no command to send here, will delete message below */ - else if (linelimit) - ok = POP3_sendTOP(number,linelimit,socket); - else - ok = POP3_sendRETR(number,socket); - if (ok != 0) - goto cleanUp; - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "reading text of %d\n", number); -#endif /* DEBUGLOG */ - - if (number >= first || queryctl->fetchall) - ok = POP3_readmsg(socket,mboxfd, - queryctl->servername, - queryctl->output == TO_MDA, - queryctl->rewrite); - else - ok = 0; - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "done reading text of %d; status %d\n", number, ok); -#endif /* DEBUGLOG */ - - if (ok != 0) - goto cleanUp; - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "about to update last-seen field with %d\n", number); -#endif /* DEBUGLOG */ - - /* update the last-seen field for this host */ - if (use_uidl && (ok = POP3_sendUIDL(number, socket, &cp)) == 0) - (void) strcpy(queryctl->lastid, cp); - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "about to check for deletion of %d\n", number); -#endif /* DEBUGLOG */ - - /* maybe we delete this message now? */ - if ((number < first && queryctl->flush) || !queryctl->keep) { - if (outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"flushing message %d\n", number); - else - ; - ok = POP3_sendDELE(number,socket); - if (ok != 0) - goto cleanUp; - } - else - ; /* message is kept */ - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "about to check for mail folder close after %d\n", number); -#endif /* DEBUGLOG */ - - /* close the mail pipe, we'll reopen before next message */ - if (queryctl->output == TO_MDA - && (queryctl->fetchall || number >= first)) { - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "about to close pipe\n"); -#endif /* DEBUGLOG */ - - ok = closemailpipe(mboxfd); - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "done closing pipe, status %d\n", ok); -#endif /* DEBUGLOG */ - - if (ok != 0) - goto cleanUp; - } - -#ifdef DEBUGLOG - if (outlevel == O_VERBOSE) - fprintf(stderr, "finished processing of %d\n", number); -#endif /* DEBUGLOG */ - } - - ok = POP3_sendQUIT(socket); - if (ok == 0) - ok = PS_SUCCESS; - close(socket); - goto closeUp; - } - else { - ok = POP3_sendQUIT(socket); - if (ok == 0) - ok = PS_NOMAIL; - close(socket); - goto closeUp; - } - -cleanUp: - if (ok != 0 && ok != PS_SOCKET) - POP3_sendQUIT(socket); - -closeUp: - if (queryctl->output == TO_FOLDER) - if (closeuserfolder(mboxfd) < 0 && ok == 0) - ok = PS_IOERR; - - if (ok == PS_IOERR || ok == PS_SOCKET) - perror("doPOP3: cleanUp"); +#if HAVE_LIBOPIE +#include +#endif /* HAVE_LIBOPIE */ - return(ok); -} +#define PROTOCOL_ERROR {error(0, 0, "protocol error"); return(PS_ERROR);} +#define LOCKBUSY_ERROR {error(0, 0, "lock busy! Is another session active?"); return(PS_LOCKBUSY);} +extern char *strstr(); /* needed on sysV68 R3V7.1. */ -/********************************************************************* - function: POP3_OK - description: get the server's response to a command, and return - the extra arguments sent with the response. - arguments: - argbuf buffer to receive the argument string. - socket socket to which the server is connected. +static int last; - return value: zero if okay, else return code. - calls: SockGets - globals: reads outlevel. - *********************************************************************/ +#if HAVE_LIBOPIE +static char lastok[POPBUFSIZE+1]; +#endif /* HAVE_LIBOPIE */ -int POP3_OK (argbuf,socket) -char *argbuf; -int socket; +int pop3_ok (int sock, char *argbuf) +/* parse command response */ { - int ok; - char buf [POPBUFSIZE]; - char *bufp; - - if (SockGets(socket, buf, sizeof(buf)) >= 0) { - if (outlevel == O_VERBOSE) - fprintf(stderr,"%s\n",buf); - - bufp = buf; - if (*bufp == '+' || *bufp == '-') - bufp++; - else - return(PS_PROTOCOL); - - while (isalpha(*bufp)) - bufp++; - *(bufp++) = '\0'; - - if (strcmp(buf,"+OK") == 0) - ok = 0; - else if (strcmp(buf,"-ERR") == 0) - ok = PS_ERROR; - else - ok = PS_PROTOCOL; - - if (argbuf != NULL) - strcpy(argbuf,bufp); - } - else - ok = PS_SOCKET; + int ok; + char buf [POPBUFSIZE+1]; + char *bufp; + + if ((ok = gen_recv(sock, buf, sizeof(buf))) == 0) + { + bufp = buf; + if (*bufp == '+' || *bufp == '-') + bufp++; + else + return(PS_PROTOCOL); + + while (isalpha(*bufp)) + bufp++; + *(bufp++) = '\0'; + + if (strcmp(buf,"+OK") == 0) + { +#if HAVE_LIBOPIE + strcpy(lastok, bufp); +#endif /* HAVE_LIBOPIE */ + ok = 0; + } + else if (strcmp(buf,"-ERR") == 0) + { + /* + * We're checking for "lock busy", "unable to lock", + * "already locked" etc. here. This indicates that we + * have to wait for the server to clean up before we + * can poll again. + * + * PS_LOCKBUSY check empirically verified with two recent + * versions the Berkeley popper; QPOP (version 2.2) and + * QUALCOMM Pop server derived from UCB (version 2.1.4-R3) + */ + if (strstr(bufp,"lock")||strstr(bufp,"Lock")||strstr(bufp,"LOCK")) + ok = PS_LOCKBUSY; + else + ok = PS_ERROR; + } + else + ok = PS_PROTOCOL; + + if (argbuf != NULL) + strcpy(argbuf,bufp); + } - return(ok); + return(ok); } - - -/********************************************************************* - function: POP3_auth - description: send the USER and PASS commands to the server, and - get the server's response. - arguments: - queryctl merged options record. - socket socket to which the server is connected. - - return value: zero if success, else status code. - calls: SockPrintf, POP3_OK. - globals: read outlevel. - *********************************************************************/ - -int POP3_auth (queryctl,socket) -struct hostrec *queryctl; -int socket; +int pop3_getauth(int sock, struct query *ctl, char *greeting) +/* apply for connection authorization */ { - char buf [POPBUFSIZE]; + int ok; +#if HAVE_LIBOPIE + char *challenge; +#endif /* HAVE_LIBOPIE */ + + /* build MD5 digest from greeting timestamp + password */ + if (ctl->server.protocol == P_APOP) + { + char *start,*end; + char *msg; + + /* find start of timestamp */ + for (start = greeting; *start != 0 && *start != '<'; start++) + continue; + if (*start == 0) { + error(0, -1, "Required APOP timestamp not found in greeting"); + return(PS_AUTHFAIL); + } + + /* find end of timestamp */ + for (end = start; *end != 0 && *end != '>'; end++) + continue; + if (*end == 0 || end == start + 1) { + error(0, -1, "Timestamp syntax error in greeting"); + return(PS_AUTHFAIL); + } + else + *++end = '\0'; + + /* copy timestamp and password into digestion buffer */ + msg = (char *)xmalloc((end-start+1) + strlen(ctl->password) + 1); + strcpy(msg,start); + strcat(msg,ctl->password); + + strcpy(ctl->digest, MD5Digest(msg)); + free(msg); + } - switch (queryctl->protocol) { + switch (ctl->server.protocol) { case P_POP3: - SockPrintf(socket,"USER %s\r\n",queryctl->remotename); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> USER %s\n",queryctl->remotename); - if (POP3_OK(buf,socket) != 0) - goto badAuth; - - SockPrintf(socket,"PASS %s\r\n",queryctl->password); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> PASS password\n"); - if (POP3_OK(buf,socket) != 0) - goto badAuth; - - break; + if ((gen_transact(sock, "USER %s", ctl->remotename)) != 0) + PROTOCOL_ERROR + +#if defined(HAVE_LIBOPIE) && defined(OPIE_ENABLE) + /* see RFC1938: A One-Time Password System */ + if (challenge = strstr(lastok, "otp-")) + { + char response[OPIE_RESPONSE_MAX+1]; + + /* + * Special case in case we're running Craig Metz's + * OPIE daemon. Code in opiegenerator() will detect this. + */ + if (ctl->password && !strcmp(ctl->password, "opie")) + { + if (ok = opiegenerator(challenge, "", response)) + if (ok != 2) + PROTOCOL_ERROR + } + else if (opiegenerator(challenge, ctl->password, response)) + PROTOCOL_ERROR + + ok = gen_transact(sock, "PASS %s", response); + } + else +#endif /* defined(HAVE_LIBOPIE) && defined(OPIE_ENABLE) */ + /* ordinary validation, no one-time password */ + ok = gen_transact(sock, "PASS %s", ctl->password); + + if (ok != 0) + { + if (ok == PS_LOCKBUSY) + LOCKBUSY_ERROR + PROTOCOL_ERROR + } + + /* + * Empirical experience shows some server/OS combinations + * may need a brief pause even after any lockfiles on the + * server are released, to give the server time to finish + * copying back very large mailfolders from the temp-file... + * this is only ever an issue with extremely large mailboxes. + */ + sleep(3); /* to be _really_ safe, probably need sleep(5)! */ + break; -#if defined(HAVE_APOP_SUPPORT) case P_APOP: - SockPrintf(socket,"APOP %s %s\r\n", - queryctl->remotename, queryctl->digest); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> APOP %s %s\n",queryctl->remotename, queryctl->digest); - if (POP3_OK(buf,socket) != 0) - goto badAuth; - break; -#endif /* HAVE_APOP_SUPPORT */ - -#if defined(HAVE_RPOP_SUPPORT) - case P_RPOP: - SockPrintf(socket, "RPOP %s\r\n", queryctl->remotename); - if (POP3_OK(buf,socket) != 0) - goto badAuth; - if (outlevel == O_VERBOSE) - fprintf(stderr,"> RPOP %s %s\n",queryctl->remotename); - break; -#endif /* HAVE_RPOP_SUPPORT */ - - default: - fprintf(stderr,"Undefined protocol request in POP3_auth\n"); - } - - /* we're approved */ - return(0); - - /*NOTREACHED*/ - -badAuth: - if (outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"%s\n",buf); - else - ; /* say nothing */ - - return(PS_ERROR); -} - - - + if ((gen_transact(sock, "APOP %s %s", + ctl->remotename, ctl->digest)) != 0) + PROTOCOL_ERROR + break; -/********************************************************************* - function: POP3_sendQUIT - description: send the QUIT command to the server and close - the socket. - - arguments: - socket socket to which the server is connected. - - return value: none. - calls: SockPuts, POP3_OK. - globals: reads outlevel. - *********************************************************************/ - -int POP3_sendQUIT (socket) -int socket; -{ - int ok; - char buf [POPBUFSIZE]; - - SockPuts(socket,"QUIT"); + case P_RPOP: + if ((gen_transact(sock,"USER %s", ctl->remotename)) != 0) + PROTOCOL_ERROR - if (outlevel == O_VERBOSE) - fprintf(stderr,"> QUIT\n"); - else - ; + if ((gen_transact(sock, "RPOP %s", ctl->password)) != 0) + PROTOCOL_ERROR + break; - ok = POP3_OK(buf,socket); - if (ok != 0 && outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"%s\n",buf); + default: + error(0, 0, "Undefined protocol request in POP3_auth"); + } - return(ok); + /* we're approved */ + return(0); } - - -/********************************************************************* - function: POP3_sendSTAT - description: send the STAT command to the POP3 server to find - out how many messages are waiting. - arguments: - count pointer to an integer to receive the message count. - socket socket to which the POP3 server is connected. - - return value: return code from POP3_OK. - calls: POP3_OK, SockPrintf - globals: reads outlevel. - *********************************************************************/ - -int POP3_sendSTAT (msgcount,socket) -int *msgcount; -int socket; +static int +pop3_gettopid( int sock, int num , char *id) { - int ok; - char buf [POPBUFSIZE]; - int totalsize; - - SockPrintf(socket,"STAT\r\n"); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> STAT\n"); - - ok = POP3_OK(buf,socket); - if (ok == 0) - sscanf(buf,"%d %d",msgcount,&totalsize); - else if (outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"%s\n",buf); - - return(ok); + int ok; + int got_it; + char buf [POPBUFSIZE+1]; + sprintf( buf, "TOP %d 1", num ); + if( (ok = gen_transact(sock, buf ) ) != 0 ) + return ok; + got_it = 0; + while((ok = gen_recv(sock, buf, sizeof(buf))) == 0) { + if( buf[0] == '.' ) + break; + if( ! got_it && ! strncasecmp("Message-Id:", buf, 11 )) { + got_it = 1; + sscanf( buf+12, "%s", id); + } + } + return 0; } - - - -/********************************************************************* - function: POP3_sendRETR - description: send the RETR command to the POP3 server. - arguments: - msgnum message ID number - socket socket to which the POP3 server is connected. - - return value: return code from POP3_OK. - calls: POP3_OK, SockPrintf - globals: reads outlevel. - *********************************************************************/ - -int POP3_sendRETR (msgnum,socket) -int msgnum; -int socket; +static int +pop3_slowuidl( int sock, struct query *ctl, int *countp, int *newp) { - int ok; - char buf [POPBUFSIZE]; - - SockPrintf(socket,"RETR %d\r\n",msgnum); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> RETR %d\n",msgnum); - - ok = POP3_OK(buf,socket); - if (ok != 0 && outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"%s\n",buf); - - return(ok); -} - - -/********************************************************************* - function: POP3_sendTOP - description: send the TOP command to the POP3 server. - arguments: - msgnum message ID number - limit maximum number of message body lines to retrieve. - socket socket to which the POP3 server is connected. + /* This approach tries to get the message headers from the + * remote hosts and compares the message-id to the already known + * ones: + * + if the first message containes a new id, all messages on + * the server will be new + * + if the first is known, try to estimate the last known message + * on the server and check. If this works you know the total number + * of messages to get. + * + Otherwise run a binary search to determine the last known message + */ + int ok, nolinear = 0; + int first_nr, list_len, try_id, try_nr, hop_id, add_id; + int num; + char id [IDLEN+1]; + + if( (ok = pop3_gettopid( sock, 1, id )) != 0 ) + return ok; + + if( ( first_nr = str_nr_in_list(&ctl->oldsaved, id) ) == -1 ) { + /* the first message is unknown -> all messages are new */ + *newp = *countp; + return 0; + } - return value: return code from POP3_OK. - calls: POP3_OK, SockPrintf - globals: reads outlevel. - *********************************************************************/ + /* check where we expect the latest known message */ + list_len = count_list( &ctl->oldsaved ); + try_id = list_len - first_nr; /* -1 + 1 */ + if( try_id > 1 ) { + if( try_id <= *countp ) { + if( (ok = pop3_gettopid( sock, try_id, id )) != 0 ) + return ok; + + try_nr = str_nr_in_list(&ctl->oldsaved, id); + } else { + try_id = *countp+1; + try_nr = -1; + } + if( try_nr != list_len -1 ) { + /* some messages inbetween have been deleted... */ + if( try_nr == -1 ) { + nolinear = 1; + + for( add_id = 1<<30; add_id > try_id-1; add_id >>= 1 ) + ; + for( ; add_id; add_id >>= 1 ) { + if( try_nr == -1 ) { + if( try_id - add_id <= 1 ) { + continue; + } + try_id -= add_id; + } else + try_id += add_id; + + if( (ok = pop3_gettopid( sock, try_id, id )) != 0 ) + return ok; + try_nr = str_nr_in_list(&ctl->oldsaved, id); + } + if( try_nr == -1 ) { + try_id--; + } + } else { + error(0,0,"Messages inserted into list on server. " + "Cannot handle this."); + return -1; + } + } + } + /* The first try_id messages are known -> copy them to + the newsaved list */ + for( num = first_nr; num < list_len; num++ ) + save_str(&ctl->newsaved, num-first_nr + 1, + str_from_nr_list( &ctl->oldsaved, num )); + + if( nolinear ) { + free_str_list(&ctl->oldsaved); + ctl->oldsaved = 0; + last = try_id; + } -int POP3_sendTOP (msgnum,limit,socket) -int msgnum; -int socket; -{ - int ok; - char buf [POPBUFSIZE]; - - SockPrintf(socket,"TOP %d %d\r\n",msgnum,limit); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> TOP %d %d\n",msgnum,limit); - - ok = POP3_OK(buf,socket); - if (ok != 0 && outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"option --limit failed; server says '%s'\n",buf); - - return(ok); + *newp = *countp - try_id; + return 0; } - - - -/********************************************************************* - function: POP3_sendDELE - description: send the DELE command to the POP3 server. - arguments: - msgnum message ID number - socket socket to which the POP3 server is connected. - - return value: return code from POP3_OK. - calls: POP3_OK, SockPrintF. - globals: reads outlevel. - *********************************************************************/ - -int POP3_sendDELE (msgnum,socket) -int msgnum; -int socket; +static int pop3_getrange(int sock, + struct query *ctl, + const char *folder, + int *countp, int *newp) +/* get range of messages to be fetched */ { - int ok; - char buf [POPBUFSIZE]; - - SockPrintf(socket,"DELE %d\r\n",msgnum); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> DELE %d\n",msgnum); - - ok = POP3_OK(buf,socket); - if (ok != 0 && outlevel > O_SILENT && outlevel < O_VERBOSE) - fprintf(stderr,"%s\n",buf); - - return(ok); -} - - - -/********************************************************************* - function: POP3_readmsg - description: Read the message content as described in RFC 1225. - arguments: - socket ... to which the server is connected. - mboxfd open file descriptor to which the retrieved message will - be written. - pophost name of the POP host - topipe true if we're writing to the system mailbox pipe. - - return value: zero if success else PS_* return code. - calls: SockGets. - globals: reads outlevel. - *********************************************************************/ - -int POP3_readmsg (socket,mboxfd,pophost,topipe,rewrite) -int socket; -int mboxfd; -char *pophost; -int topipe; -int rewrite; -{ - char buf [MSGBUFSIZE]; - char *bufp; - char savec; - char fromBuf[MSGBUFSIZE]; - int needFrom; - int inheaders; - int lines,sizeticker; - time_t now; - /* This keeps the retrieved message count for display purposes */ - static int msgnum = 0; - - /* set up for status message if outlevel allows it */ - if (outlevel > O_SILENT && outlevel < O_VERBOSE) { - fprintf(stderr,"reading message %d",++msgnum); - /* won't do the '...' if retrieved messages are being sent to stdout */ - if (mboxfd == 1) - fputs(".\n",stderr); + int ok; + char buf [POPBUFSIZE+1]; + + /* Ensure that the new list is properly empty */ + ctl->newsaved = (struct idlist *)NULL; + +#ifdef MBOX + /* Alain Knaff suggests this, but it's not RFC standard */ + if (folder) + if ((ok = gen_transact(sock, "MBOX %s", folder))) + return ok; +#endif /* MBOX */ + + /* get the total message count */ + gen_send(sock, "STAT"); + ok = pop3_ok(sock, buf); + if (ok == 0) + sscanf(buf,"%d %*d", countp); else - ; - } - else - ; - - /* read the message content from the server */ - inheaders = 1; - lines = 0; - sizeticker = MSGBUFSIZE; - while (1) { - if (SockGets(socket,buf,sizeof(buf)) < 0) - return(PS_SOCKET); - bufp = buf; - if (buf[0] == '\r' || buf[0] == '\n') - inheaders = 0; - if (*bufp == '.') { - bufp++; - if (*bufp == 0) - break; /* end of message */ - } - strcat(bufp,"\n"); - - /* Check for Unix 'From' header, and add a bogus one if it's not - present -- only if not using an MDA. - XXX -- should probably parse real From: header and use its - address field instead of bogus 'POPmail' string. - */ - if (!topipe && lines == 0) { - if (strlen(bufp) >= strlen("From ")) { - savec = *(bufp + 5); - *(bufp + 5) = 0; - needFrom = strcmp(bufp,"From ") != 0; - *(bufp + 5) = savec; - } - else - needFrom = 1; - if (needFrom) { - now = time(NULL); - sprintf(fromBuf,"From POPmail %s",ctime(&now)); - if (write(mboxfd,fromBuf,strlen(fromBuf)) < 0) { - perror("POP3_readmsg: write"); - return(PS_IOERR); - } - } - } + return(ok); /* - * Edit some headers so that replies will work properly. + * Newer, RFC-1725-conformant POP servers may not have the LAST command. + * We work as hard as possible to hide this ugliness, but it makes + * counting new messages intrinsically quadratic in the worst case. */ - if (inheaders && rewrite) - reply_hack(bufp, pophost); - - /* write this line to the file */ - if (write(mboxfd,bufp,strlen(bufp)) < 0) { - perror("POP3_readmsg: write"); - return(PS_IOERR); - } - - sizeticker -= strlen(bufp); - if (sizeticker <= 0) { - if (outlevel > O_SILENT && outlevel < O_VERBOSE && mboxfd != 1) - fputc('.',stderr); - sizeticker = MSGBUFSIZE; - } - lines++; - } - - if (!topipe) { - /* The server may not write the extra newline required by the Unix - mail folder format, so we write one here just in case */ - if (write(mboxfd,"\n",1) < 0) { - perror("POP3_readmsg: write"); - return(PS_IOERR); - } - } - else { - /* The mail delivery agent may require a terminator. Write it if - it has been defined */ -#ifdef BINMAIL_TERM - if (write(mboxfd,BINMAIL_TERM,strlen(BINMAIL_TERM)) < 0) { - perror("POP3_readmsg: write"); - return(PS_IOERR); - } -#endif + last = 0; + *newp = -1; + if (*countp > 0 && !ctl->fetchall) + { + char id [IDLEN+1]; + + if (!ctl->server.uidl) { + gen_send(sock, "LAST"); + ok = pop3_ok(sock, buf); + } else + ok = 1; + if (ok == 0) + { + if (sscanf(buf, "%d", &last) == 0) + PROTOCOL_ERROR + *newp = (*countp - last); + } + else + { + /* grab the mailbox's UID list */ + if ((ok = gen_transact(sock, "UIDL")) != 0) + { + /* don't worry, yet! do it the slow way */ + if((ok = pop3_slowuidl( sock, ctl, countp, newp))!=0) + PROTOCOL_ERROR + } + else + { + int num; + + *newp = 0; + while ((ok = gen_recv(sock, buf, sizeof(buf))) == 0) + { + if (buf[0] == '.') + break; + else if (sscanf(buf, "%d %s", &num, id) == 2) + { + save_str(&ctl->newsaved, num, id); + + /* note: ID comparison is caseblind */ + if (!str_in_list(&ctl->oldsaved, id)) + (*newp)++; + } + } + } + } } - /* finish up display output */ - if (outlevel == O_VERBOSE) - fprintf(stderr,"(%d lines of message content)\n",lines); - else if (outlevel > O_SILENT && mboxfd != 1) - fputs(".\n",stderr); - else - ; - return(0); + return(0); } +static int pop3_getsizes(int sock, int count, int *sizes) +/* capture the sizes of all messages */ +{ + int ok; + if ((ok = gen_transact(sock, "LIST")) != 0) + return(ok); + else + { + char buf [POPBUFSIZE+1]; + + while ((ok = gen_recv(sock, buf, sizeof(buf))) == 0) + { + int num, size; + + if (buf[0] == '.') + break; + else if (sscanf(buf, "%d %d", &num, &size) == 2) + sizes[num - 1] = size; + else + sizes[num - 1] = -1; + } + + return(ok); + } +} - -/****************************************************************** - function: POP3_sendLAST - description: send the LAST command to the server, which should - return the number of the last message number retrieved - from the server. - arguments: - last integer buffer to receive last message# - - ret. value: zero if success, else status code. - globals: SockPrintf, POP3_OK. - calls: reads outlevel. - *****************************************************************/ - -int POP3_sendLAST (last, socket) -int *last; -int socket; +static int pop3_is_old(int sock, struct query *ctl, int num) +/* is the given message old? */ { - int ok; - char buf [POPBUFSIZE]; + if (!ctl->oldsaved) + return (num <= last); + else + /* note: ID comparison is caseblind */ + return (str_in_list(&ctl->oldsaved, + str_find (&ctl->newsaved, num))); +} - SockPrintf(socket,"LAST\r\n"); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> LAST\n"); +static int pop3_fetch(int sock, struct query *ctl, int number, int *lenp) +/* request nth message */ +{ + int ok; + char buf [POPBUFSIZE+1], *cp; - ok = POP3_OK(buf,socket); - if (ok == 0 && sscanf(buf,"%d",last) == 0) - ok = PS_ERROR; + gen_send(sock, "RETR %d", number); + if ((ok = pop3_ok(sock, buf)) != 0) + return(ok); - if (ok != 0 && outlevel > O_SILENT) - fprintf(stderr,"Server says '%s' to LAST command.\n",buf); + *lenp = -1; /* we got sizes from the LIST response */ - return(ok); + return(0); } -/****************************************************************** - function: POP3_sendUIDL - description: send the UIDL command to the server, - - arguments: - num number of message to query (may be -1) - - ret. value: zero if success, else status code. - globals: SockPrintf, POP3_OK. - calls: reads outlevel. - *****************************************************************/ - -int POP3_sendUIDL (num, socket, cp) -int num; -int socket; -char **cp; +static int pop3_delete(int sock, struct query *ctl, int number) +/* delete a given message */ { - int ok; - char buf [POPBUFSIZE]; - static char id[IDLEN]; - - (void) strcpy(buf, "UIDL\r\n"); - if (num > -1) - (void) sprintf(buf, "UIDL %d\r\n", num); - - SockPrintf(socket, buf); - if (outlevel == O_VERBOSE) - fprintf(stderr,"> %s", buf); - - ok = POP3_OK(buf,socket); - if (ok != 0 && outlevel > O_SILENT) - fprintf(stderr,"Server says '%s' to UIDL command.\n",buf); - - if (cp) { - sscanf(buf, "%*d %s\n", id); - *cp = id; - } - return(ok); + /* actually, mark for deletion -- doesn't happen until QUIT time */ + return(gen_transact(sock, "DELE %d", number)); } - -/****************************************************************** - function: POP3_BuildDigest - description: Construct the MD5 digest for the current session, - using the user-specified password, and the time - stamp in the POP3 greeting. - arguments: - buf greeting string - queryctl merged options record. - - ret. value: zero on success, nonzero if no timestamp found in - greeting. - globals: none. - calls: MD5Digest. - *****************************************************************/ - -#if defined(HAVE_APOP_SUPPORT) -POP3_BuildDigest (buf,queryctl) -char *buf; -struct hostrec *queryctl; +const static struct method pop3 = { - char *start,*end; - char *msg; - - /* find start of timestamp */ - for (start = buf; *start != 0 && *start != '<'; start++) - ; - if (*start == 0) { - fprintf(stderr,"Required APOP timestamp not found in greeting\n"); - return(-1); - } - - /* find end of timestamp */ - for (end = start; *end != 0 && *end != '>'; end++) - ; - if (*end == 0 || (end - start - 1) == 1) { - fprintf(stderr,"Timestamp syntax error in greeting\n"); - return(-1); - } - - /* copy timestamp and password into digestion buffer */ - msg = (char *) malloc((end-start-1) + strlen(queryctl->password) + 1); - *(++end) = 0; - strcpy(msg,start); - strcat(msg,queryctl->password); - - strcpy(queryctl->digest, MD5Digest(msg)); - free(msg); - return(0); + "POP3", /* Post Office Protocol v3 */ + 110, /* standard POP3 port */ + FALSE, /* this is not a tagged protocol */ + TRUE, /* this uses a message delimiter */ + pop3_ok, /* parse command response */ + pop3_getauth, /* get authorization */ + pop3_getrange, /* query range of messages */ + pop3_getsizes, /* we can get a list of sizes */ + pop3_is_old, /* how do we tell a message is old? */ + pop3_fetch, /* request given message */ + NULL, /* no way to fetch body alone */ + NULL, /* no message trailer */ + pop3_delete, /* how to delete a message */ + "QUIT", /* the POP3 exit command */ +}; + +int doPOP3 (struct query *ctl) +/* retrieve messages using POP3 */ +{ +#ifndef MBOX + if (ctl->mailboxes->id) { + fprintf(stderr,"Option --remote is not supported with POP3\n"); + return(PS_SYNTAX); + } +#endif /* MBOX */ + peek_capable = FALSE; + return(do_protocol(ctl, &pop3)); } -#endif /* HAVE_APOP_SUPPORT */ +/* pop3.c ends here */