Fix typos.
[emacs.git] / lib-src / pop.c
blobae1000742cc1814d94f93f0e930d17924e7b8320
1 /* pop.c: client routines for talking to a POP3-protocol post-office server
3 Copyright (C) 1991, 1993, 1996-1997, 1999, 2001-2011
4 Free Software Foundation, Inc.
6 Author: Jonathan Kamens <jik@security.ov.com>
8 This file is part of GNU Emacs.
10 GNU Emacs is free software: you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
15 GNU Emacs is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #else
27 #define MAIL_USE_POP
28 #endif
30 #ifdef MAIL_USE_POP
32 #include <sys/types.h>
33 #ifdef WINDOWSNT
34 #include "ntlib.h"
35 #include <winsock.h>
36 #undef SOCKET_ERROR
37 #define RECV(s,buf,len,flags) recv (s,buf,len,flags)
38 #define SEND(s,buf,len,flags) send (s,buf,len,flags)
39 #define CLOSESOCKET(s) closesocket (s)
40 #else
41 #include <netinet/in.h>
42 #include <sys/socket.h>
43 #define RECV(s,buf,len,flags) read (s,buf,len)
44 #define SEND(s,buf,len,flags) write (s,buf,len)
45 #define CLOSESOCKET(s) close (s)
46 #endif
47 #include <pop.h>
49 #ifdef sun
50 #include <malloc.h>
51 #endif /* sun */
53 #ifdef HESIOD
54 #include <hesiod.h>
56 * It really shouldn't be necessary to put this declaration here, but
57 * the version of hesiod.h that Athena has installed in release 7.2
58 * doesn't declare this function; I don't know if the 7.3 version of
59 * hesiod.h does.
61 extern struct servent *hes_getservbyname (/* char *, char * */);
62 #endif
64 #include <pwd.h>
65 #include <netdb.h>
66 #include <errno.h>
67 #include <stdio.h>
68 #include <string.h>
69 #include <unistd.h>
71 #ifdef KERBEROS
72 # ifdef HAVE_KRB5_H
73 # include <krb5.h>
74 # endif
75 # ifdef HAVE_KRB_H
76 # include <krb.h>
77 # else
78 # ifdef HAVE_KERBEROSIV_KRB_H
79 # include <kerberosIV/krb.h>
80 # else
81 # ifdef HAVE_KERBEROS_KRB_H
82 # include <kerberos/krb.h>
83 # endif
84 # endif
85 # endif
86 # ifdef HAVE_COM_ERR_H
87 # include <com_err.h>
88 # endif
89 #endif /* KERBEROS */
91 #include <min-max.h>
93 #ifdef KERBEROS
94 #ifndef KERBEROS5
95 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
96 u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
97 struct sockaddr_in *, struct sockaddr_in *,
98 char * */);
99 extern char *krb_realmofhost (/* char * */);
100 #endif /* ! KERBEROS5 */
101 #endif /* KERBEROS */
103 #ifndef WINDOWSNT
104 #if !defined (HAVE_H_ERRNO) || !defined (HAVE_CONFIG_H)
105 extern int h_errno;
106 #endif
107 #endif
109 static int socket_connection (char *, int);
110 static int pop_getline (popserver, char **);
111 static int sendline (popserver, const char *);
112 static int fullwrite (int, char *, int);
113 static int getok (popserver);
114 #if 0
115 static int gettermination (popserver);
116 #endif
117 static void pop_trash (popserver);
118 static char *find_crlf (char *, int);
120 #define ERROR_MAX 160 /* a pretty arbitrary size, but needs
121 to be bigger than the original
122 value of 80 */
123 #define POP_PORT 110
124 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
125 #ifdef KERBEROS
126 #define KPOP_PORT 1109
127 #define KPOP_SERVICE "kpop" /* never used: look for 20060515 to see why */
128 #endif
130 char pop_error[ERROR_MAX];
131 int pop_debug = 0;
134 * Function: pop_open (char *host, char *username, char *password,
135 * int flags)
137 * Purpose: Establishes a connection with a post-office server, and
138 * completes the authorization portion of the session.
140 * Arguments:
141 * host The server host with which the connection should be
142 * established. Optional. If omitted, internal
143 * heuristics will be used to determine the server host,
144 * if possible.
145 * username
146 * The username of the mail-drop to access. Optional.
147 * If omitted, internal heuristics will be used to
148 * determine the username, if possible.
149 * password
150 * The password to use for authorization. If omitted,
151 * internal heuristics will be used to determine the
152 * password, if possible.
153 * flags A bit mask containing flags controlling certain
154 * functions of the routine. Valid flags are defined in
155 * the file pop.h
157 * Return value: Upon successful establishment of a connection, a
158 * non-null popserver will be returned. Otherwise, null will be
159 * returned, and the string variable pop_error will contain an
160 * explanation of the error.
162 popserver
163 pop_open (char *host, char *username, char *password, int flags)
165 int sock;
166 popserver server;
168 /* Determine the user name */
169 if (! username)
171 username = getenv ("USER");
172 if (! (username && *username))
174 username = getlogin ();
175 if (! (username && *username))
177 struct passwd *passwd;
178 passwd = getpwuid (getuid ());
179 if (passwd && passwd->pw_name && *passwd->pw_name)
181 username = passwd->pw_name;
183 else
185 strcpy (pop_error, "Could not determine username");
186 return (0);
193 * Determine the mail host.
196 if (! host)
198 host = getenv ("MAILHOST");
201 #ifdef HESIOD
202 if ((! host) && (! (flags & POP_NO_HESIOD)))
204 struct hes_postoffice *office;
205 office = hes_getmailhost (username);
206 if (office && office->po_type && (! strcmp (office->po_type, "POP"))
207 && office->po_name && *office->po_name && office->po_host
208 && *office->po_host)
210 host = office->po_host;
211 username = office->po_name;
214 #endif
216 #ifdef MAILHOST
217 if (! host)
219 host = MAILHOST;
221 #endif
223 if (! host)
225 strcpy (pop_error, "Could not determine POP server");
226 return (0);
229 /* Determine the password */
230 #ifdef KERBEROS
231 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
232 #else
233 #define DONT_NEED_PASSWORD 0
234 #endif
236 if ((! password) && (! DONT_NEED_PASSWORD))
238 if (! (flags & POP_NO_GETPASS))
240 password = getpass ("Enter POP password:");
242 if (! password)
244 strcpy (pop_error, "Could not determine POP password");
245 return (0);
248 if (password) /* always true, detected 20060515 */
249 flags |= POP_NO_KERBEROS;
250 else
251 password = username; /* dead code, detected 20060515 */
252 /** "kpop" service is never used: look for 20060515 to see why **/
254 sock = socket_connection (host, flags);
255 if (sock == -1)
256 return (0);
258 server = (popserver) malloc (sizeof (struct _popserver));
259 if (! server)
261 strcpy (pop_error, "Out of memory in pop_open");
262 return (0);
264 server->buffer = (char *) malloc (GETLINE_MIN);
265 if (! server->buffer)
267 strcpy (pop_error, "Out of memory in pop_open");
268 free ((char *) server);
269 return (0);
272 server->file = sock;
273 server->data = 0;
274 server->buffer_index = 0;
275 server->buffer_size = GETLINE_MIN;
276 server->in_multi = 0;
277 server->trash_started = 0;
279 if (getok (server))
280 return (0);
283 * I really shouldn't use the pop_error variable like this, but....
285 if (strlen (username) > ERROR_MAX - 6)
287 pop_close (server);
288 strcpy (pop_error,
289 "Username too long; recompile pop.c with larger ERROR_MAX");
290 return (0);
292 sprintf (pop_error, "USER %s", username);
294 if (sendline (server, pop_error) || getok (server))
296 return (0);
299 if (strlen (password) > ERROR_MAX - 6)
301 pop_close (server);
302 strcpy (pop_error,
303 "Password too long; recompile pop.c with larger ERROR_MAX");
304 return (0);
306 sprintf (pop_error, "PASS %s", password);
308 if (sendline (server, pop_error) || getok (server))
310 return (0);
313 return (server);
317 * Function: pop_stat
319 * Purpose: Issue the STAT command to the server and return (in the
320 * value parameters) the number of messages in the maildrop and
321 * the total size of the maildrop.
323 * Return value: 0 on success, or non-zero with an error in pop_error
324 * in failure.
326 * Side effects: On failure, may make further operations on the
327 * connection impossible.
330 pop_stat (popserver server, int *count, int *size)
332 char *fromserver;
333 char *end_ptr;
335 if (server->in_multi)
337 strcpy (pop_error, "In multi-line query in pop_stat");
338 return (-1);
341 if (sendline (server, "STAT") || (pop_getline (server, &fromserver) < 0))
342 return (-1);
344 if (strncmp (fromserver, "+OK ", 4))
346 if (0 == strncmp (fromserver, "-ERR", 4))
348 strncpy (pop_error, fromserver, ERROR_MAX);
350 else
352 strcpy (pop_error,
353 "Unexpected response from POP server in pop_stat");
354 pop_trash (server);
356 return (-1);
359 errno = 0;
360 *count = strtol (&fromserver[4], &end_ptr, 10);
361 /* Check validity of string-to-integer conversion. */
362 if (fromserver + 4 == end_ptr || *end_ptr != ' ' || errno)
364 strcpy (pop_error, "Unexpected response from POP server in pop_stat");
365 pop_trash (server);
366 return (-1);
369 fromserver = end_ptr;
371 errno = 0;
372 *size = strtol (fromserver + 1, &end_ptr, 10);
373 if (fromserver + 1 == end_ptr || errno)
375 strcpy (pop_error, "Unexpected response from POP server in pop_stat");
376 pop_trash (server);
377 return (-1);
380 return (0);
384 * Function: pop_list
386 * Purpose: Performs the POP "list" command and returns (in value
387 * parameters) two malloc'd zero-terminated arrays -- one of
388 * message IDs, and a parallel one of sizes.
390 * Arguments:
391 * server The pop connection to talk to.
392 * message The number of the one message about which to get
393 * information, or 0 to get information about all
394 * messages.
396 * Return value: 0 on success, non-zero with error in pop_error on
397 * failure.
399 * Side effects: On failure, may make further operations on the
400 * connection impossible.
403 pop_list (popserver server, int message, int **IDs, int **sizes)
405 int how_many, i;
406 char *fromserver;
408 if (server->in_multi)
410 strcpy (pop_error, "In multi-line query in pop_list");
411 return (-1);
414 if (message)
415 how_many = 1;
416 else
418 int count, size;
419 if (pop_stat (server, &count, &size))
420 return (-1);
421 how_many = count;
424 *IDs = (int *) malloc ((how_many + 1) * sizeof (int));
425 *sizes = (int *) malloc ((how_many + 1) * sizeof (int));
426 if (! (*IDs && *sizes))
428 strcpy (pop_error, "Out of memory in pop_list");
429 return (-1);
432 if (message)
434 sprintf (pop_error, "LIST %d", message);
435 if (sendline (server, pop_error))
437 free ((char *) *IDs);
438 free ((char *) *sizes);
439 return (-1);
441 if (pop_getline (server, &fromserver) < 0)
443 free ((char *) *IDs);
444 free ((char *) *sizes);
445 return (-1);
447 if (strncmp (fromserver, "+OK ", 4))
449 if (! strncmp (fromserver, "-ERR", 4))
450 strncpy (pop_error, fromserver, ERROR_MAX);
451 else
453 strcpy (pop_error,
454 "Unexpected response from server in pop_list");
455 pop_trash (server);
457 free ((char *) *IDs);
458 free ((char *) *sizes);
459 return (-1);
461 (*IDs)[0] = atoi (&fromserver[4]);
462 fromserver = strchr (&fromserver[4], ' ');
463 if (! fromserver)
465 strcpy (pop_error,
466 "Badly formatted response from server in pop_list");
467 pop_trash (server);
468 free ((char *) *IDs);
469 free ((char *) *sizes);
470 return (-1);
472 (*sizes)[0] = atoi (fromserver);
473 (*IDs)[1] = (*sizes)[1] = 0;
474 return (0);
476 else
478 if (pop_multi_first (server, "LIST", &fromserver))
480 free ((char *) *IDs);
481 free ((char *) *sizes);
482 return (-1);
484 for (i = 0; i < how_many; i++)
486 if (pop_multi_next (server, &fromserver) <= 0)
488 free ((char *) *IDs);
489 free ((char *) *sizes);
490 return (-1);
492 (*IDs)[i] = atoi (fromserver);
493 fromserver = strchr (fromserver, ' ');
494 if (! fromserver)
496 strcpy (pop_error,
497 "Badly formatted response from server in pop_list");
498 free ((char *) *IDs);
499 free ((char *) *sizes);
500 pop_trash (server);
501 return (-1);
503 (*sizes)[i] = atoi (fromserver);
505 if (pop_multi_next (server, &fromserver) < 0)
507 free ((char *) *IDs);
508 free ((char *) *sizes);
509 return (-1);
511 else if (fromserver)
513 strcpy (pop_error,
514 "Too many response lines from server in pop_list");
515 free ((char *) *IDs);
516 free ((char *) *sizes);
517 return (-1);
519 (*IDs)[i] = (*sizes)[i] = 0;
520 return (0);
525 * Function: pop_retrieve
527 * Purpose: Retrieve a specified message from the maildrop.
529 * Arguments:
530 * server The server to retrieve from.
531 * message The message number to retrieve.
532 * markfrom
533 * If true, then mark the string "From " at the beginning
534 * of lines with '>'.
535 * msg_buf Output parameter to which a buffer containing the
536 * message is assigned.
538 * Return value: The number of bytes in msg_buf, which may contain
539 * embedded nulls, not including its final null, or -1 on error
540 * with pop_error set.
542 * Side effects: May kill connection on error.
545 pop_retrieve (popserver server, int message, int markfrom, char **msg_buf)
547 int *IDs, *sizes, bufsize, fromcount = 0, cp = 0;
548 char *ptr, *fromserver;
549 int ret;
551 if (server->in_multi)
553 strcpy (pop_error, "In multi-line query in pop_retrieve");
554 return (-1);
557 if (pop_list (server, message, &IDs, &sizes))
558 return (-1);
560 if (pop_retrieve_first (server, message, &fromserver))
562 return (-1);
566 * The "5" below is an arbitrary constant -- I assume that if
567 * there are "From" lines in the text to be marked, there
568 * probably won't be more than 5 of them. If there are, I
569 * allocate more space for them below.
571 bufsize = sizes[0] + (markfrom ? 5 : 0);
572 ptr = (char *)malloc (bufsize);
573 free ((char *) IDs);
574 free ((char *) sizes);
576 if (! ptr)
578 strcpy (pop_error, "Out of memory in pop_retrieve");
579 pop_retrieve_flush (server);
580 return (-1);
583 while ((ret = pop_retrieve_next (server, &fromserver)) >= 0)
585 if (! fromserver)
587 ptr[cp] = '\0';
588 *msg_buf = ptr;
589 return (cp);
591 if (markfrom && fromserver[0] == 'F' && fromserver[1] == 'r' &&
592 fromserver[2] == 'o' && fromserver[3] == 'm' &&
593 fromserver[4] == ' ')
595 if (++fromcount == 5)
597 bufsize += 5;
598 ptr = (char *)realloc (ptr, bufsize);
599 if (! ptr)
601 strcpy (pop_error, "Out of memory in pop_retrieve");
602 pop_retrieve_flush (server);
603 return (-1);
605 fromcount = 0;
607 ptr[cp++] = '>';
609 memcpy (&ptr[cp], fromserver, ret);
610 cp += ret;
611 ptr[cp++] = '\n';
614 free (ptr);
615 return (-1);
619 pop_retrieve_first (popserver server, int message, char **response)
621 sprintf (pop_error, "RETR %d", message);
622 return (pop_multi_first (server, pop_error, response));
626 Returns a negative number on error, 0 to indicate that the data has
627 all been read (i.e., the server has returned a "." termination
628 line), or a positive number indicating the number of bytes in the
629 returned buffer (which is null-terminated and may contain embedded
630 nulls, but the returned bytecount doesn't include the final null).
634 pop_retrieve_next (popserver server, char **line)
636 return (pop_multi_next (server, line));
640 pop_retrieve_flush (popserver server)
642 return (pop_multi_flush (server));
646 pop_top_first (popserver server, int message, int lines, char **response)
648 sprintf (pop_error, "TOP %d %d", message, lines);
649 return (pop_multi_first (server, pop_error, response));
653 Returns a negative number on error, 0 to indicate that the data has
654 all been read (i.e., the server has returned a "." termination
655 line), or a positive number indicating the number of bytes in the
656 returned buffer (which is null-terminated and may contain embedded
657 nulls, but the returned bytecount doesn't include the final null).
661 pop_top_next (popserver server, char **line)
663 return (pop_multi_next (server, line));
667 pop_top_flush (popserver server)
669 return (pop_multi_flush (server));
673 pop_multi_first (popserver server, const char *command, char **response)
675 if (server->in_multi)
677 strcpy (pop_error,
678 "Already in multi-line query in pop_multi_first");
679 return (-1);
682 if (sendline (server, command) || (pop_getline (server, response) < 0))
684 return (-1);
687 if (0 == strncmp (*response, "-ERR", 4))
689 strncpy (pop_error, *response, ERROR_MAX);
690 return (-1);
692 else if (0 == strncmp (*response, "+OK", 3))
694 for (*response += 3; **response == ' '; (*response)++) /* empty */;
695 server->in_multi = 1;
696 return (0);
698 else
700 strcpy (pop_error,
701 "Unexpected response from server in pop_multi_first");
702 return (-1);
707 Read the next line of data from SERVER and place a pointer to it
708 into LINE. Return -1 on error, 0 if there are no more lines to read
709 (i.e., the server has returned a line containing only "."), or a
710 positive number indicating the number of bytes in the LINE buffer
711 (not including the final null). The data in that buffer may contain
712 embedded nulls, but does not contain the final CRLF. When returning
713 0, LINE is set to null. */
716 pop_multi_next (popserver server, char **line)
718 char *fromserver;
719 int ret;
721 if (! server->in_multi)
723 strcpy (pop_error, "Not in multi-line query in pop_multi_next");
724 return (-1);
727 if ((ret = pop_getline (server, &fromserver)) < 0)
729 return (-1);
732 if (fromserver[0] == '.')
734 if (! fromserver[1])
736 *line = 0;
737 server->in_multi = 0;
738 return (0);
740 else
742 *line = fromserver + 1;
743 return (ret - 1);
746 else
748 *line = fromserver;
749 return (ret);
754 pop_multi_flush (popserver server)
756 char *line;
757 int ret;
759 if (! server->in_multi)
761 return (0);
764 while ((ret = pop_multi_next (server, &line)))
766 if (ret < 0)
767 return (-1);
770 return (0);
773 /* Function: pop_delete
775 * Purpose: Delete a specified message.
777 * Arguments:
778 * server Server from which to delete the message.
779 * message Message to delete.
781 * Return value: 0 on success, non-zero with error in pop_error
782 * otherwise.
785 pop_delete (popserver server, int message)
787 if (server->in_multi)
789 strcpy (pop_error, "In multi-line query in pop_delete");
790 return (-1);
793 sprintf (pop_error, "DELE %d", message);
795 if (sendline (server, pop_error) || getok (server))
796 return (-1);
798 return (0);
802 * Function: pop_noop
804 * Purpose: Send a noop command to the server.
806 * Argument:
807 * server The server to send to.
809 * Return value: 0 on success, non-zero with error in pop_error
810 * otherwise.
812 * Side effects: Closes connection on error.
815 pop_noop (popserver server)
817 if (server->in_multi)
819 strcpy (pop_error, "In multi-line query in pop_noop");
820 return (-1);
823 if (sendline (server, "NOOP") || getok (server))
824 return (-1);
826 return (0);
830 * Function: pop_last
832 * Purpose: Find out the highest seen message from the server.
834 * Arguments:
835 * server The server.
837 * Return value: If successful, the highest seen message, which is
838 * greater than or equal to 0. Otherwise, a negative number with
839 * the error explained in pop_error.
841 * Side effects: Closes the connection on error.
844 pop_last (popserver server)
846 char *fromserver;
848 if (server->in_multi)
850 strcpy (pop_error, "In multi-line query in pop_last");
851 return (-1);
854 if (sendline (server, "LAST"))
855 return (-1);
857 if (pop_getline (server, &fromserver) < 0)
858 return (-1);
860 if (! strncmp (fromserver, "-ERR", 4))
862 strncpy (pop_error, fromserver, ERROR_MAX);
863 return (-1);
865 else if (strncmp (fromserver, "+OK ", 4))
867 strcpy (pop_error, "Unexpected response from server in pop_last");
868 pop_trash (server);
869 return (-1);
871 else
873 char *end_ptr;
874 int count;
875 errno = 0;
876 count = strtol (&fromserver[4], &end_ptr, 10);
877 if (fromserver + 4 == end_ptr || errno)
879 strcpy (pop_error, "Unexpected response from server in pop_last");
880 pop_trash (server);
881 return (-1);
883 return count;
888 * Function: pop_reset
890 * Purpose: Reset the server to its initial connect state
892 * Arguments:
893 * server The server.
895 * Return value: 0 for success, non-0 with error in pop_error
896 * otherwise.
898 * Side effects: Closes the connection on error.
901 pop_reset (popserver server)
903 if (pop_retrieve_flush (server))
905 return (-1);
908 if (sendline (server, "RSET") || getok (server))
909 return (-1);
911 return (0);
915 * Function: pop_quit
917 * Purpose: Quit the connection to the server,
919 * Arguments:
920 * server The server to quit.
922 * Return value: 0 for success, non-zero otherwise with error in
923 * pop_error.
925 * Side Effects: The popserver passed in is unusable after this
926 * function is called, even if an error occurs.
929 pop_quit (popserver server)
931 int ret = 0;
933 if (server->file >= 0)
935 if (pop_retrieve_flush (server))
937 ret = -1;
940 if (sendline (server, "QUIT") || getok (server))
942 ret = -1;
945 close (server->file);
948 free (server->buffer);
949 free ((char *) server);
951 return (ret);
954 #ifdef WINDOWSNT
955 static int have_winsock = 0;
956 #endif
959 * Function: socket_connection
961 * Purpose: Opens the network connection with the mail host, without
962 * doing any sort of I/O with it or anything.
964 * Arguments:
965 * host The host to which to connect.
966 * flags Option flags.
968 * Return value: A file descriptor indicating the connection, or -1
969 * indicating failure, in which case an error has been copied
970 * into pop_error.
972 static int
973 socket_connection (char *host, int flags)
975 #ifdef HAVE_GETADDRINFO
976 struct addrinfo *res, *it;
977 struct addrinfo hints;
978 int ret;
979 #else /* !HAVE_GETADDRINFO */
980 struct hostent *hostent;
981 #endif
982 struct servent *servent;
983 struct sockaddr_in addr;
984 char found_port = 0;
985 const char *service;
986 int sock;
987 char *realhost;
988 #ifdef KERBEROS
989 #ifdef KERBEROS5
990 krb5_error_code rem;
991 krb5_context kcontext = 0;
992 krb5_auth_context auth_context = 0;
993 krb5_ccache ccdef;
994 krb5_principal client, server;
995 krb5_error *err_ret;
996 register char *cp;
997 #else
998 KTEXT ticket;
999 MSG_DAT msg_data;
1000 CREDENTIALS cred;
1001 Key_schedule schedule;
1002 int rem;
1003 #endif /* KERBEROS5 */
1004 #endif /* KERBEROS */
1006 int try_count = 0;
1007 int connect_ok;
1009 #ifdef WINDOWSNT
1011 WSADATA winsockData;
1012 if (WSAStartup (0x101, &winsockData) == 0)
1013 have_winsock = 1;
1015 #endif
1017 memset (&addr, 0, sizeof (addr));
1018 addr.sin_family = AF_INET;
1020 /** "kpop" service is never used: look for 20060515 to see why **/
1021 #ifdef KERBEROS
1022 service = (flags & POP_NO_KERBEROS) ? POP_SERVICE : KPOP_SERVICE;
1023 #else
1024 service = POP_SERVICE;
1025 #endif
1027 #ifdef HESIOD
1028 if (! (flags & POP_NO_HESIOD))
1030 servent = hes_getservbyname (service, "tcp");
1031 if (servent)
1033 addr.sin_port = servent->s_port;
1034 found_port = 1;
1037 #endif
1038 if (! found_port)
1040 servent = getservbyname (service, "tcp");
1041 if (servent)
1043 addr.sin_port = servent->s_port;
1045 else
1047 /** "kpop" service is never used: look for 20060515 to see why **/
1048 #ifdef KERBEROS
1049 addr.sin_port = htons ((flags & POP_NO_KERBEROS) ?
1050 POP_PORT : KPOP_PORT);
1051 #else
1052 addr.sin_port = htons (POP_PORT);
1053 #endif
1057 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1059 sock = socket (PF_INET, SOCK_STREAM, 0);
1060 if (sock < 0)
1062 strcpy (pop_error, POP_SOCKET_ERROR);
1063 strncat (pop_error, strerror (errno),
1064 ERROR_MAX - sizeof (POP_SOCKET_ERROR));
1065 return (-1);
1069 #ifdef HAVE_GETADDRINFO
1070 memset (&hints, 0, sizeof (hints));
1071 hints.ai_socktype = SOCK_STREAM;
1072 hints.ai_flags = AI_CANONNAME;
1073 hints.ai_family = AF_INET;
1076 ret = getaddrinfo (host, service, &hints, &res);
1077 try_count++;
1078 if (ret != 0 && (ret != EAI_AGAIN || try_count == 5))
1080 strcpy (pop_error, "Could not determine POP server's address");
1081 return (-1);
1083 } while (ret != 0);
1085 if (ret == 0)
1087 it = res;
1088 while (it)
1090 if (it->ai_addrlen == sizeof (addr))
1092 struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
1093 memcpy (&addr.sin_addr, &in_a->sin_addr, sizeof (addr.sin_addr));
1094 if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
1095 break;
1097 it = it->ai_next;
1099 connect_ok = it != NULL;
1100 if (connect_ok)
1102 realhost = alloca (strlen (it->ai_canonname) + 1);
1103 strcpy (realhost, it->ai_canonname);
1105 freeaddrinfo (res);
1107 #else /* !HAVE_GETADDRINFO */
1110 hostent = gethostbyname (host);
1111 try_count++;
1112 if ((! hostent) && ((h_errno != TRY_AGAIN) || (try_count == 5)))
1114 strcpy (pop_error, "Could not determine POP server's address");
1115 return (-1);
1117 } while (! hostent);
1119 while (*hostent->h_addr_list)
1121 memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
1122 if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
1123 break;
1124 hostent->h_addr_list++;
1126 connect_ok = *hostent->h_addr_list != NULL;
1127 if (! connect_ok)
1129 realhost = alloca (strlen (hostent->h_name) + 1);
1130 strcpy (realhost, hostent->h_name);
1133 #endif /* !HAVE_GETADDRINFO */
1135 #define CONNECT_ERROR "Could not connect to POP server: "
1137 if (! connect_ok)
1139 CLOSESOCKET (sock);
1140 strcpy (pop_error, CONNECT_ERROR);
1141 strncat (pop_error, strerror (errno),
1142 ERROR_MAX - sizeof (CONNECT_ERROR));
1143 return (-1);
1147 #ifdef KERBEROS
1149 #define KRB_ERROR "Kerberos error connecting to POP server: "
1150 if (! (flags & POP_NO_KERBEROS))
1152 #ifdef KERBEROS5
1153 if ((rem = krb5_init_context (&kcontext)))
1155 krb5error:
1156 if (auth_context)
1157 krb5_auth_con_free (kcontext, auth_context);
1158 if (kcontext)
1159 krb5_free_context (kcontext);
1160 strcpy (pop_error, KRB_ERROR);
1161 strncat (pop_error, error_message (rem),
1162 ERROR_MAX - sizeof (KRB_ERROR));
1163 CLOSESOCKET (sock);
1164 return (-1);
1167 if ((rem = krb5_auth_con_init (kcontext, &auth_context)))
1168 goto krb5error;
1170 if (rem = krb5_cc_default (kcontext, &ccdef))
1171 goto krb5error;
1173 if (rem = krb5_cc_get_principal (kcontext, ccdef, &client))
1174 goto krb5error;
1176 for (cp = realhost; *cp; cp++)
1178 if (isupper (*cp))
1180 *cp = tolower (*cp);
1184 if (rem = krb5_sname_to_principal (kcontext, realhost,
1185 POP_SERVICE, FALSE, &server))
1186 goto krb5error;
1188 rem = krb5_sendauth (kcontext, &auth_context,
1189 (krb5_pointer) &sock, "KPOPV1.0", client, server,
1190 AP_OPTS_MUTUAL_REQUIRED,
1191 0, /* no checksum */
1192 0, /* no creds, use ccache instead */
1193 ccdef,
1194 &err_ret,
1195 0, /* don't need subsession key */
1196 0); /* don't need reply */
1197 krb5_free_principal (kcontext, server);
1198 if (rem)
1200 strcpy (pop_error, KRB_ERROR);
1201 strncat (pop_error, error_message (rem),
1202 ERROR_MAX - sizeof (KRB_ERROR));
1203 #if defined HAVE_KRB5_ERROR_TEXT
1204 if (err_ret && err_ret->text.length)
1206 strncat (pop_error, " [server says '",
1207 ERROR_MAX - strlen (pop_error) - 1);
1208 strncat (pop_error, err_ret->text.data,
1209 min (ERROR_MAX - strlen (pop_error) - 1,
1210 err_ret->text.length));
1211 strncat (pop_error, "']",
1212 ERROR_MAX - strlen (pop_error) - 1);
1214 #elif defined HAVE_KRB5_ERROR_E_TEXT
1215 if (err_ret && err_ret->e_text && strlen (*err_ret->e_text))
1217 strncat (pop_error, " [server says '",
1218 ERROR_MAX - strlen (pop_error) - 1);
1219 strncat (pop_error, *err_ret->e_text,
1220 ERROR_MAX - strlen (pop_error) - 1);
1221 strncat (pop_error, "']",
1222 ERROR_MAX - strlen (pop_error) - 1);
1224 #endif
1225 if (err_ret)
1226 krb5_free_error (kcontext, err_ret);
1227 krb5_auth_con_free (kcontext, auth_context);
1228 krb5_free_context (kcontext);
1230 CLOSESOCKET (sock);
1231 return (-1);
1233 #else /* ! KERBEROS5 */
1234 ticket = (KTEXT) malloc (sizeof (KTEXT_ST));
1235 rem = krb_sendauth (0L, sock, ticket, "pop", realhost,
1236 (char *) krb_realmofhost (realhost),
1237 (unsigned long) 0, &msg_data, &cred, schedule,
1238 (struct sockaddr_in *) 0,
1239 (struct sockaddr_in *) 0,
1240 "KPOPV0.1");
1241 free ((char *) ticket);
1242 if (rem != KSUCCESS)
1244 strcpy (pop_error, KRB_ERROR);
1245 strncat (pop_error, krb_err_txt[rem],
1246 ERROR_MAX - sizeof (KRB_ERROR));
1247 CLOSESOCKET (sock);
1248 return (-1);
1250 #endif /* KERBEROS5 */
1252 #endif /* KERBEROS */
1254 return (sock);
1255 } /* socket_connection */
1258 * Function: pop_getline
1260 * Purpose: Get a line of text from the connection and return a
1261 * pointer to it. The carriage return and linefeed at the end of
1262 * the line are stripped, but periods at the beginnings of lines
1263 * are NOT dealt with in any special way.
1265 * Arguments:
1266 * server The server from which to get the line of text.
1268 * Returns: The number of characters in the line, which is returned in
1269 * LINE, not including the final null. A return value of 0
1270 * indicates a blank line. A negative return value indicates an
1271 * error (in which case the contents of LINE are undefined. In
1272 * case of error, an error message is copied into pop_error.
1274 * Notes: The line returned is overwritten with each call to pop_getline.
1276 * Side effects: Closes the connection on error.
1278 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1280 static int
1281 pop_getline (popserver server, char **line)
1283 #define GETLINE_ERROR "Error reading from server: "
1285 int ret;
1286 int search_offset = 0;
1288 if (server->data)
1290 char *cp = find_crlf (server->buffer + server->buffer_index,
1291 server->data);
1292 if (cp)
1294 int found;
1295 int data_used;
1297 found = server->buffer_index;
1298 data_used = (cp + 2) - server->buffer - found;
1300 *cp = '\0'; /* terminate the string to be returned */
1301 server->data -= data_used;
1302 server->buffer_index += data_used;
1304 if (pop_debug)
1305 /* Embedded nulls will truncate this output prematurely,
1306 but that's OK because it's just for debugging anyway. */
1307 fprintf (stderr, "<<< %s\n", server->buffer + found);
1308 *line = server->buffer + found;
1309 return (data_used - 2);
1311 else
1313 memmove (server->buffer, server->buffer + server->buffer_index,
1314 server->data);
1315 /* Record the fact that we've searched the data already in
1316 the buffer for a CRLF, so that when we search below, we
1317 don't have to search the same data twice. There's a "-
1318 1" here to account for the fact that the last character
1319 of the data we have may be the CR of a CRLF pair, of
1320 which we haven't read the second half yet, so we may have
1321 to search it again when we read more data. */
1322 search_offset = server->data - 1;
1323 server->buffer_index = 0;
1326 else
1328 server->buffer_index = 0;
1331 while (1)
1333 /* There's a "- 1" here to leave room for the null that we put
1334 at the end of the read data below. We put the null there so
1335 that find_crlf knows where to stop when we call it. */
1336 if (server->data == server->buffer_size - 1)
1338 server->buffer_size += GETLINE_INCR;
1339 server->buffer = (char *)realloc (server->buffer, server->buffer_size);
1340 if (! server->buffer)
1342 strcpy (pop_error, "Out of memory in pop_getline");
1343 pop_trash (server);
1344 return (-1);
1347 ret = RECV (server->file, server->buffer + server->data,
1348 server->buffer_size - server->data - 1, 0);
1349 if (ret < 0)
1351 strcpy (pop_error, GETLINE_ERROR);
1352 strncat (pop_error, strerror (errno),
1353 ERROR_MAX - sizeof (GETLINE_ERROR));
1354 pop_trash (server);
1355 return (-1);
1357 else if (ret == 0)
1359 strcpy (pop_error, "Unexpected EOF from server in pop_getline");
1360 pop_trash (server);
1361 return (-1);
1363 else
1365 char *cp;
1366 server->data += ret;
1367 server->buffer[server->data] = '\0';
1369 cp = find_crlf (server->buffer + search_offset,
1370 server->data - search_offset);
1371 if (cp)
1373 int data_used = (cp + 2) - server->buffer;
1374 *cp = '\0';
1375 server->data -= data_used;
1376 server->buffer_index = data_used;
1378 if (pop_debug)
1379 fprintf (stderr, "<<< %s\n", server->buffer);
1380 *line = server->buffer;
1381 return (data_used - 2);
1383 /* As above, the "- 1" here is to account for the fact that
1384 we may have read a CR without its accompanying LF. */
1385 search_offset += ret - 1;
1389 /* NOTREACHED */
1393 * Function: sendline
1395 * Purpose: Sends a line of text to the POP server. The line of text
1396 * passed into this function should NOT have the carriage return
1397 * and linefeed on the end of it. Periods at beginnings of lines
1398 * will NOT be treated specially by this function.
1400 * Arguments:
1401 * server The server to which to send the text.
1402 * line The line of text to send.
1404 * Return value: Upon successful completion, a value of 0 will be
1405 * returned. Otherwise, a non-zero value will be returned, and
1406 * an error will be copied into pop_error.
1408 * Side effects: Closes the connection on error.
1410 static int
1411 sendline (popserver server, const char *line)
1413 #define SENDLINE_ERROR "Error writing to POP server: "
1414 int ret;
1415 char *buf;
1417 /* Combine the string and the CR-LF into one buffer. Otherwise, two
1418 reasonable network stack optimizations, Nagle's algorithm and
1419 delayed acks, combine to delay us a fraction of a second on every
1420 message we send. (Movemail writes line without \r\n, client
1421 kernel sends packet, server kernel delays the ack to see if it
1422 can combine it with data, movemail writes \r\n, client kernel
1423 waits because it has unacked data already in its outgoing queue,
1424 client kernel eventually times out and sends.)
1426 This can be something like 0.2s per command, which can add up
1427 over a few dozen messages, and is a big chunk of the time we
1428 spend fetching mail from a server close by. */
1429 buf = alloca (strlen (line) + 3);
1430 strcpy (buf, line);
1431 strcat (buf, "\r\n");
1432 ret = fullwrite (server->file, buf, strlen (buf));
1434 if (ret < 0)
1436 pop_trash (server);
1437 strcpy (pop_error, SENDLINE_ERROR);
1438 strncat (pop_error, strerror (errno),
1439 ERROR_MAX - sizeof (SENDLINE_ERROR));
1440 return (ret);
1443 if (pop_debug)
1444 fprintf (stderr, ">>> %s\n", line);
1446 return (0);
1450 * Procedure: fullwrite
1452 * Purpose: Just like write, but keeps trying until the entire string
1453 * has been written.
1455 * Return value: Same as write. Pop_error is not set.
1457 static int
1458 fullwrite (int fd, char *buf, int nbytes)
1460 char *cp;
1461 int ret = 0;
1463 cp = buf;
1464 while (nbytes && ((ret = SEND (fd, cp, nbytes, 0)) > 0))
1466 cp += ret;
1467 nbytes -= ret;
1470 return (ret);
1474 * Procedure getok
1476 * Purpose: Reads a line from the server. If the return indicator is
1477 * positive, return with a zero exit status. If not, return with
1478 * a negative exit status.
1480 * Arguments:
1481 * server The server to read from.
1483 * Returns: 0 for success, else for failure and puts error in pop_error.
1485 * Side effects: On failure, may make the connection unusable.
1487 static int
1488 getok (popserver server)
1490 char *fromline;
1492 if (pop_getline (server, &fromline) < 0)
1494 return (-1);
1497 if (! strncmp (fromline, "+OK", 3))
1498 return (0);
1499 else if (! strncmp (fromline, "-ERR", 4))
1501 strncpy (pop_error, fromline, ERROR_MAX);
1502 pop_error[ERROR_MAX-1] = '\0';
1503 return (-1);
1505 else
1507 strcpy (pop_error,
1508 "Unexpected response from server; expecting +OK or -ERR");
1509 pop_trash (server);
1510 return (-1);
1514 #if 0
1516 * Function: gettermination
1518 * Purpose: Gets the next line and verifies that it is a termination
1519 * line (nothing but a dot).
1521 * Return value: 0 on success, non-zero with pop_error set on error.
1523 * Side effects: Closes the connection on error.
1525 static int
1526 gettermination (server)
1527 popserver server;
1529 char *fromserver;
1531 if (pop_getline (server, &fromserver) < 0)
1532 return (-1);
1534 if (strcmp (fromserver, "."))
1536 strcpy (pop_error,
1537 "Unexpected response from server in gettermination");
1538 pop_trash (server);
1539 return (-1);
1542 return (0);
1544 #endif
1547 * Function pop_close
1549 * Purpose: Close a pop connection, sending a "RSET" command to try to
1550 * preserve any changes that were made and a "QUIT" command to
1551 * try to get the server to quit, but ignoring any responses that
1552 * are received.
1554 * Side effects: The server is unusable after this function returns.
1555 * Changes made to the maildrop since the session was started (or
1556 * since the last pop_reset) may be lost.
1558 void
1559 pop_close (popserver server)
1561 pop_trash (server);
1562 free ((char *) server);
1564 return;
1568 * Function: pop_trash
1570 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1571 * memory associated with the server. It is valid to call
1572 * pop_close or pop_quit after this function has been called.
1574 static void
1575 pop_trash (popserver server)
1577 if (server->file >= 0)
1579 /* avoid recursion; sendline can call pop_trash */
1580 if (server->trash_started)
1581 return;
1582 server->trash_started = 1;
1584 sendline (server, "RSET");
1585 sendline (server, "QUIT");
1587 CLOSESOCKET (server->file);
1588 server->file = -1;
1589 if (server->buffer)
1591 free (server->buffer);
1592 server->buffer = 0;
1596 #ifdef WINDOWSNT
1597 if (have_winsock)
1598 WSACleanup ();
1599 #endif
1602 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1603 embedded nulls and has LEN characters in it not including the final
1604 null, or 0 if it does not contain one. */
1606 static char *
1607 find_crlf (char *in_string, int len)
1609 while (len--)
1611 if (*in_string == '\r')
1613 if (*++in_string == '\n')
1614 return (in_string - 1);
1616 else
1617 in_string++;
1619 return (0);
1622 #endif /* MAIL_USE_POP */