/* pop.c: client routines for talking to a POP3-protocol post-office server
- Copyright (c) 1991, 1993, 1996, 1997, 1999 Free Software Foundation, Inc.
- Written by Jonathan Kamens, jik@security.ov.com.
+ Copyright (C) 1991, 1993, 1996, 1997, 1999, 2001, 2002, 2003, 2004,
+ 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+
+Author: Jonathan Kamens <jik@security.ov.com>
This file is part of GNU Emacs.
-GNU Emacs is free software; you can redistribute it and/or modify
+GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
+
#ifdef HAVE_CONFIG_H
-#define NO_SHORTNAMES /* Tell config not to load remap.h */
#include <config.h>
#else
#define MAIL_USE_POP
# ifdef HAVE_KRB5_H
# include <krb5.h>
# endif
-# ifdef HAVE_DES_H
-# include <des.h>
-# else
-# ifdef HAVE_KERBEROSIV_DES_H
-# include <kerberosIV/des.h>
-# else
-# ifdef HAVE_KERBEROS_DES_H
-# include <kerberos/des.h>
-# endif
-# endif
-# endif
# ifdef HAVE_KRB_H
# include <krb.h>
# else
#define KPOP_PORT 1109
#define POP_SERVICE "pop3" /* we don't want the POP2 port! */
#ifdef KERBEROS
-#define KPOP_SERVICE "kpop"
+#define KPOP_SERVICE "kpop" /* never used: look for 20060515 to see why */
#endif
char pop_error[ERROR_MAX];
return (0);
}
}
- if (password)
+ if (password) /* always true, detected 20060515 */
flags |= POP_NO_KERBEROS;
else
- password = username;
+ password = username; /* dead code, detected 20060515 */
+ /** "kpop" service is never used: look for 20060515 to see why **/
sock = socket_connection (host, flags);
if (sock == -1)
int *size;
{
char *fromserver;
+ char *end_ptr;
if (server->in_multi)
{
return (-1);
}
- *count = atoi (&fromserver[4]);
-
- fromserver = index (&fromserver[4], ' ');
- if (! fromserver)
+ errno = 0;
+ *count = strtol (&fromserver[4], &end_ptr, 10);
+ /* Check validity of string-to-integer conversion. */
+ if (fromserver + 4 == end_ptr || *end_ptr != ' ' || errno)
{
- strcpy (pop_error,
- "Badly formatted response from server in pop_stat");
+ strcpy (pop_error, "Unexpected response from POP server in pop_stat");
pop_trash (server);
return (-1);
}
- *size = atoi (fromserver + 1);
+ fromserver = end_ptr;
+
+ errno = 0;
+ *size = strtol (fromserver + 1, &end_ptr, 10);
+ if (fromserver + 1 == end_ptr || errno)
+ {
+ strcpy (pop_error, "Unexpected response from POP server in pop_stat");
+ pop_trash (server);
+ return (-1);
+ }
return (0);
}
}
else
{
- return (atoi (&fromserver[4]));
+ char *end_ptr;
+ int count;
+ errno = 0;
+ count = strtol (&fromserver[4], &end_ptr, 10);
+ if (fromserver + 4 == end_ptr || errno)
+ {
+ strcpy (pop_error, "Unexpected response from server in pop_last");
+ pop_trash (server);
+ return (-1);
+ }
+ return count;
}
}
close (server->file);
}
- if (server->buffer)
- free (server->buffer);
+ free (server->buffer);
free ((char *) server);
return (ret);
char *host;
int flags;
{
+#ifdef HAVE_GETADDRINFO
+ struct addrinfo *res, *it;
+ struct addrinfo hints;
+ int ret;
+#else /* !HAVE_GETADDRINFO */
struct hostent *hostent;
+#endif
struct servent *servent;
struct sockaddr_in addr;
char found_port = 0;
char *service;
int sock;
+ char *realhost;
#ifdef KERBEROS
#ifdef KERBEROS5
krb5_error_code rem;
CREDENTIALS cred;
Key_schedule schedule;
int rem;
- char *realhost;
#endif /* KERBEROS5 */
#endif /* KERBEROS */
int try_count = 0;
+ int connect_ok;
#ifdef WINDOWSNT
{
bzero ((char *) &addr, sizeof (addr));
addr.sin_family = AF_INET;
+ /** "kpop" service is never used: look for 20060515 to see why **/
#ifdef KERBEROS
service = (flags & POP_NO_KERBEROS) ? POP_SERVICE : KPOP_SERVICE;
#else
}
else
{
+ /** "kpop" service is never used: look for 20060515 to see why **/
#ifdef KERBEROS
addr.sin_port = htons ((flags & POP_NO_KERBEROS) ?
POP_PORT : KPOP_PORT);
}
+#ifdef HAVE_GETADDRINFO
+ memset (&hints, 0, sizeof(hints));
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_flags = AI_CANONNAME;
+ hints.ai_family = AF_INET;
+ do
+ {
+ ret = getaddrinfo (host, service, &hints, &res);
+ try_count++;
+ if (ret != 0 && (ret != EAI_AGAIN || try_count == 5))
+ {
+ strcpy (pop_error, "Could not determine POP server's address");
+ return (-1);
+ }
+ } while (ret != 0);
+
+ if (ret == 0)
+ {
+ it = res;
+ while (it)
+ {
+ if (it->ai_addrlen == sizeof (addr))
+ {
+ struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
+ bcopy (&in_a->sin_addr, (char *) &addr.sin_addr,
+ sizeof (addr.sin_addr));
+ if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
+ break;
+ }
+ it = it->ai_next;
+ }
+ connect_ok = it != NULL;
+ if (connect_ok)
+ {
+ realhost = alloca (strlen (it->ai_canonname) + 1);
+ strcpy (realhost, it->ai_canonname);
+ }
+ freeaddrinfo (res);
+ }
+#else /* !HAVE_GETADDRINFO */
do
{
hostent = gethostbyname (host);
break;
hostent->h_addr_list++;
}
+ connect_ok = *hostent->h_addr_list != NULL;
+ if (! connect_ok)
+ {
+ realhost = alloca (strlen (hostent->h_name) + 1);
+ strcpy (realhost, hostent->h_name);
+ }
+
+#endif /* !HAVE_GETADDRINFO */
#define CONNECT_ERROR "Could not connect to POP server: "
- if (! *hostent->h_addr_list)
+ if (! connect_ok)
{
CLOSESOCKET (sock);
strcpy (pop_error, CONNECT_ERROR);
}
#ifdef KERBEROS
+
#define KRB_ERROR "Kerberos error connecting to POP server: "
if (! (flags & POP_NO_KERBEROS))
{
if (rem = krb5_cc_get_principal (kcontext, ccdef, &client))
goto krb5error;
- for (cp = hostent->h_name; *cp; cp++)
+ for (cp = realhost; *cp; cp++)
{
if (isupper (*cp))
{
}
}
- if (rem = krb5_sname_to_principal (kcontext, hostent->h_name,
+ if (rem = krb5_sname_to_principal (kcontext, realhost,
POP_SERVICE, FALSE, &server))
goto krb5error;
krb5_free_principal (kcontext, server);
if (rem)
{
+ strcpy (pop_error, KRB_ERROR);
+ strncat (pop_error, error_message (rem),
+ ERROR_MAX - sizeof (KRB_ERROR));
+#if defined HAVE_KRB5_ERROR_TEXT
if (err_ret && err_ret->text.length)
{
- strcpy (pop_error, KRB_ERROR);
- strncat (pop_error, error_message (rem),
- ERROR_MAX - sizeof (KRB_ERROR));
strncat (pop_error, " [server says '",
ERROR_MAX - strlen (pop_error) - 1);
strncat (pop_error, err_ret->text.data,
strncat (pop_error, "']",
ERROR_MAX - strlen (pop_error) - 1);
}
- else
+#elif defined HAVE_KRB5_ERROR_E_TEXT
+ if (err_ret && err_ret->e_text && strlen(*err_ret->e_text))
{
- strcpy (pop_error, KRB_ERROR);
- strncat (pop_error, error_message (rem),
- ERROR_MAX - sizeof (KRB_ERROR));
+ strncat (pop_error, " [server says '",
+ ERROR_MAX - strlen (pop_error) - 1);
+ strncat (pop_error, *err_ret->e_text,
+ ERROR_MAX - strlen (pop_error) - 1);
+ strncat (pop_error, "']",
+ ERROR_MAX - strlen (pop_error) - 1);
}
+#endif
if (err_ret)
krb5_free_error (kcontext, err_ret);
krb5_auth_con_free (kcontext, auth_context);
}
#else /* ! KERBEROS5 */
ticket = (KTEXT) malloc (sizeof (KTEXT_ST));
- realhost = strdup (hostent->h_name);
rem = krb_sendauth (0L, sock, ticket, "pop", realhost,
(char *) krb_realmofhost (realhost),
(unsigned long) 0, &msg_data, &cred, schedule,
(struct sockaddr_in *) 0,
"KPOPV0.1");
free ((char *) ticket);
- free (realhost);
if (rem != KSUCCESS)
{
strcpy (pop_error, KRB_ERROR);
{
#define SENDLINE_ERROR "Error writing to POP server: "
int ret;
-
- ret = fullwrite (server->file, line, strlen (line));
- if (ret >= 0)
- { /* 0 indicates that a blank line was written */
- ret = fullwrite (server->file, "\r\n", 2);
- }
+ char *buf;
+
+ /* Combine the string and the CR-LF into one buffer. Otherwise, two
+ reasonable network stack optimizations, Nagle's algorithm and
+ delayed acks, combine to delay us a fraction of a second on every
+ message we send. (Movemail writes line without \r\n, client
+ kernel sends packet, server kernel delays the ack to see if it
+ can combine it with data, movemail writes \r\n, client kernel
+ waits because it has unacked data already in its outgoing queue,
+ client kernel eventually times out and sends.)
+
+ This can be something like 0.2s per command, which can add up
+ over a few dozen messages, and is a big chunk of the time we
+ spend fetching mail from a server close by. */
+ buf = alloca (strlen (line) + 3);
+ strcpy (buf, line);
+ strcat (buf, "\r\n");
+ ret = fullwrite (server->file, buf, strlen (buf));
if (ret < 0)
{
* Function: pop_trash
*
* Purpose: Like pop_close or pop_quit, but doesn't deallocate the
- * memory associated with the server. It is legal to call
+ * memory associated with the server. It is valid to call
* pop_close or pop_quit after this function has been called.
*/
static void
}
#endif /* MAIL_USE_POP */
+
+/* arch-tag: ceb37041-b7ad-49a8-a63d-286618b8367d
+ (do not change this comment) */