1 /* pop.c: client routines for talking to a POP3-protocol post-office server
3 Copyright (C) 1991, 1993, 1996-1997, 1999, 2001-2016 Free Software
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/>. */
28 #include <sys/types.h>
32 #define _WIN32_WINNT 0x0501 /* for getaddrinfo stuff */
36 #define getaddrinfo sys_getaddrinfo
38 #define freeaddrinfo sys_freeaddrinfo
39 int sys_getaddrinfo (const char * node
, const char * service
,
40 const struct addrinfo
* hints
, struct addrinfo
** res
);
41 void sys_freeaddrinfo (struct addrinfo
* ai
);
43 #define RECV(s,buf,len,flags) recv (s,buf,len,flags)
44 #define SEND(s,buf,len,flags) send (s,buf,len,flags)
45 #define CLOSESOCKET(s) closesocket (s)
47 #include <netinet/in.h>
48 #include <sys/socket.h>
49 #define RECV(s,buf,len,flags) read (s,buf,len)
50 #define SEND(s,buf,len,flags) write (s,buf,len)
51 #define CLOSESOCKET(s) close (s)
58 * It really shouldn't be necessary to put this declaration here, but
59 * the version of hesiod.h that Athena has installed in release 7.2
60 * doesn't declare this function; I don't know if the 7.3 version of
63 extern struct servent
*hes_getservbyname (/* char *, char * */);
80 # ifdef HAVE_KERBEROSIV_KRB_H
81 # include <kerberosIV/krb.h>
83 # ifdef HAVE_KERBEROS_KRB_H
84 # include <kerberos/krb.h>
88 # ifdef HAVE_COM_ERR_H
97 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
98 u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
99 struct sockaddr_in *, struct sockaddr_in *,
101 extern char *krb_realmofhost (/* char * */);
102 #endif /* ! KERBEROS5 */
103 #endif /* KERBEROS */
111 static int socket_connection (char *, int);
112 static int pop_getline (popserver
, char **);
113 static int sendline (popserver
, const char *);
114 static int fullwrite (int, char *, int);
115 static int getok (popserver
);
117 static int gettermination (popserver
);
119 static void pop_trash (popserver
);
120 static char *find_crlf (char *, int);
122 #define ERROR_MAX 160 /* a pretty arbitrary size, but needs
123 to be bigger than the original
126 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
128 #define KPOP_PORT 1109
129 #define KPOP_SERVICE "kpop" /* never used: look for 20060515 to see why */
132 char pop_error
[ERROR_MAX
];
133 bool pop_debug
= false;
136 * Function: pop_open (char *host, char *username, char *password,
139 * Purpose: Establishes a connection with a post-office server, and
140 * completes the authorization portion of the session.
143 * host The server host with which the connection should be
144 * established. Optional. If omitted, internal
145 * heuristics will be used to determine the server host,
148 * The username of the mail-drop to access. Optional.
149 * If omitted, internal heuristics will be used to
150 * determine the username, if possible.
152 * The password to use for authorization. If omitted,
153 * internal heuristics will be used to determine the
154 * password, if possible.
155 * flags A bit mask containing flags controlling certain
156 * functions of the routine. Valid flags are defined in
159 * Return value: Upon successful establishment of a connection, a
160 * non-null popserver will be returned. Otherwise, null will be
161 * returned, and the string variable pop_error will contain an
162 * explanation of the error.
165 pop_open (char *host
, char *username
, char *password
, int flags
)
170 /* Determine the user name */
173 username
= getenv ("USER");
174 if (! (username
&& *username
))
176 username
= getlogin ();
177 if (! (username
&& *username
))
179 struct passwd
*passwd
;
180 passwd
= getpwuid (getuid ());
181 if (passwd
&& passwd
->pw_name
&& *passwd
->pw_name
)
183 username
= passwd
->pw_name
;
187 strcpy (pop_error
, "Could not determine username");
195 * Determine the mail host.
200 host
= getenv ("MAILHOST");
204 if ((! host
) && (! (flags
& POP_NO_HESIOD
)))
206 struct hes_postoffice
*office
;
207 office
= hes_getmailhost (username
);
208 if (office
&& office
->po_type
&& (! strcmp (office
->po_type
, "POP"))
209 && office
->po_name
&& *office
->po_name
&& office
->po_host
212 host
= office
->po_host
;
213 username
= office
->po_name
;
227 strcpy (pop_error
, "Could not determine POP server");
231 /* Determine the password */
233 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
235 #define DONT_NEED_PASSWORD 0
238 if ((! password
) && (! DONT_NEED_PASSWORD
))
240 if (! (flags
& POP_NO_GETPASS
))
242 password
= getpass ("Enter POP password:");
246 strcpy (pop_error
, "Could not determine POP password");
250 if (password
) /* always true, detected 20060515 */
251 flags
|= POP_NO_KERBEROS
;
253 password
= username
; /* dead code, detected 20060515 */
254 /** "kpop" service is never used: look for 20060515 to see why **/
256 sock
= socket_connection (host
, flags
);
260 server
= (popserver
) malloc (sizeof (struct _popserver
));
263 strcpy (pop_error
, "Out of memory in pop_open");
266 server
->buffer
= (char *) malloc (GETLINE_MIN
);
267 if (! server
->buffer
)
269 strcpy (pop_error
, "Out of memory in pop_open");
270 free ((char *) server
);
276 server
->buffer_index
= 0;
277 server
->buffer_size
= GETLINE_MIN
;
278 server
->in_multi
= false;
279 server
->trash_started
= false;
285 * I really shouldn't use the pop_error variable like this, but....
287 if (strlen (username
) > ERROR_MAX
- 6)
291 "Username too long; recompile pop.c with larger ERROR_MAX");
294 sprintf (pop_error
, "USER %s", username
);
296 if (sendline (server
, pop_error
) || getok (server
))
301 if (strlen (password
) > ERROR_MAX
- 6)
305 "Password too long; recompile pop.c with larger ERROR_MAX");
308 sprintf (pop_error
, "PASS %s", password
);
310 if (sendline (server
, pop_error
) || getok (server
))
321 * Purpose: Issue the STAT command to the server and return (in the
322 * value parameters) the number of messages in the maildrop and
323 * the total size of the maildrop.
325 * Return value: 0 on success, or non-zero with an error in pop_error
328 * Side effects: On failure, may make further operations on the
329 * connection impossible.
332 pop_stat (popserver server
, int *count
, int *size
)
337 if (server
->in_multi
)
339 strcpy (pop_error
, "In multi-line query in pop_stat");
343 if (sendline (server
, "STAT") || (pop_getline (server
, &fromserver
) < 0))
346 if (strncmp (fromserver
, "+OK ", 4))
348 if (0 == strncmp (fromserver
, "-ERR", 4))
349 snprintf (pop_error
, ERROR_MAX
, "%s", fromserver
);
353 "Unexpected response from POP server in pop_stat");
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");
369 fromserver
= end_ptr
;
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");
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.
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
396 * Return value: 0 on success, non-zero with error in pop_error on
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
)
408 if (server
->in_multi
)
410 strcpy (pop_error
, "In multi-line query in pop_list");
419 if (pop_stat (server
, &count
, &size
))
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");
434 sprintf (pop_error
, "LIST %d", message
);
435 if (sendline (server
, pop_error
))
437 free ((char *) *IDs
);
438 free ((char *) *sizes
);
441 if (pop_getline (server
, &fromserver
) < 0)
443 free ((char *) *IDs
);
444 free ((char *) *sizes
);
447 if (strncmp (fromserver
, "+OK ", 4))
449 if (! strncmp (fromserver
, "-ERR", 4))
450 snprintf (pop_error
, ERROR_MAX
, "%s", fromserver
);
454 "Unexpected response from server in pop_list");
457 free ((char *) *IDs
);
458 free ((char *) *sizes
);
461 (*IDs
)[0] = atoi (&fromserver
[4]);
462 fromserver
= strchr (&fromserver
[4], ' ');
466 "Badly formatted response from server in pop_list");
468 free ((char *) *IDs
);
469 free ((char *) *sizes
);
472 (*sizes
)[0] = atoi (fromserver
);
473 (*IDs
)[1] = (*sizes
)[1] = 0;
478 if (pop_multi_first (server
, "LIST", &fromserver
))
480 free ((char *) *IDs
);
481 free ((char *) *sizes
);
484 for (i
= 0; i
< how_many
; i
++)
486 if (pop_multi_next (server
, &fromserver
) <= 0)
488 free ((char *) *IDs
);
489 free ((char *) *sizes
);
492 (*IDs
)[i
] = atoi (fromserver
);
493 fromserver
= strchr (fromserver
, ' ');
497 "Badly formatted response from server in pop_list");
498 free ((char *) *IDs
);
499 free ((char *) *sizes
);
503 (*sizes
)[i
] = atoi (fromserver
);
505 if (pop_multi_next (server
, &fromserver
) < 0)
507 free ((char *) *IDs
);
508 free ((char *) *sizes
);
514 "Too many response lines from server in pop_list");
515 free ((char *) *IDs
);
516 free ((char *) *sizes
);
519 (*IDs
)[i
] = (*sizes
)[i
] = 0;
525 * Function: pop_retrieve
527 * Purpose: Retrieve a specified message from the maildrop.
530 * server The server to retrieve from.
531 * message The message number to retrieve.
533 * If true, then mark the string "From " at the beginning
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
;
551 if (server
->in_multi
)
553 strcpy (pop_error
, "In multi-line query in pop_retrieve");
557 if (pop_list (server
, message
, &IDs
, &sizes
))
560 if (pop_retrieve_first (server
, message
, &fromserver
))
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
);
574 free ((char *) sizes
);
578 strcpy (pop_error
, "Out of memory in pop_retrieve");
579 pop_retrieve_flush (server
);
583 while ((ret
= pop_retrieve_next (server
, &fromserver
)) >= 0)
591 if (markfrom
&& fromserver
[0] == 'F' && fromserver
[1] == 'r' &&
592 fromserver
[2] == 'o' && fromserver
[3] == 'm' &&
593 fromserver
[4] == ' ')
595 if (++fromcount
== 5)
598 ptr
= (char *)realloc (ptr
, bufsize
);
601 strcpy (pop_error
, "Out of memory in pop_retrieve");
602 pop_retrieve_flush (server
);
609 memcpy (&ptr
[cp
], fromserver
, ret
);
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
)
678 "Already in multi-line query in pop_multi_first");
682 if (sendline (server
, command
) || (pop_getline (server
, response
) < 0))
687 if (0 == strncmp (*response
, "-ERR", 4))
689 snprintf (pop_error
, ERROR_MAX
, "%s", *response
);
692 else if (0 == strncmp (*response
, "+OK", 3))
694 for (*response
+= 3; **response
== ' '; (*response
)++) /* empty */;
695 server
->in_multi
= true;
701 "Unexpected response from server in pop_multi_first");
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
)
721 if (! server
->in_multi
)
723 strcpy (pop_error
, "Not in multi-line query in pop_multi_next");
727 if ((ret
= pop_getline (server
, &fromserver
)) < 0)
732 if (fromserver
[0] == '.')
737 server
->in_multi
= false;
742 *line
= fromserver
+ 1;
754 pop_multi_flush (popserver server
)
759 if (! server
->in_multi
)
764 while ((ret
= pop_multi_next (server
, &line
)))
773 /* Function: pop_delete
775 * Purpose: Delete a specified message.
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
785 pop_delete (popserver server
, int message
)
787 if (server
->in_multi
)
789 strcpy (pop_error
, "In multi-line query in pop_delete");
793 sprintf (pop_error
, "DELE %d", message
);
795 if (sendline (server
, pop_error
) || getok (server
))
804 * Purpose: Send a noop command to the server.
807 * server The server to send to.
809 * Return value: 0 on success, non-zero with error in pop_error
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");
823 if (sendline (server
, "NOOP") || getok (server
))
832 * Purpose: Find out the highest seen message from 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
)
848 if (server
->in_multi
)
850 strcpy (pop_error
, "In multi-line query in pop_last");
854 if (sendline (server
, "LAST"))
857 if (pop_getline (server
, &fromserver
) < 0)
860 if (! strncmp (fromserver
, "-ERR", 4))
862 snprintf (pop_error
, ERROR_MAX
, "%s", fromserver
);
865 else if (strncmp (fromserver
, "+OK ", 4))
867 strcpy (pop_error
, "Unexpected response from server in pop_last");
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");
888 * Function: pop_reset
890 * Purpose: Reset the server to its initial connect state
895 * Return value: 0 for success, non-0 with error in pop_error
898 * Side effects: Closes the connection on error.
901 pop_reset (popserver server
)
903 if (pop_retrieve_flush (server
))
908 if (sendline (server
, "RSET") || getok (server
))
917 * Purpose: Quit the connection to the server,
920 * server The server to quit.
922 * Return value: 0 for success, non-zero otherwise with error in
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
)
933 if (server
->file
>= 0)
935 if (pop_retrieve_flush (server
))
940 if (sendline (server
, "QUIT") || getok (server
))
945 close (server
->file
);
948 free (server
->buffer
);
949 free ((char *) server
);
955 static int have_winsock
= 0;
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.
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
973 socket_connection (char *host
, int flags
)
975 #ifdef HAVE_GETADDRINFO
976 struct addrinfo
*res
, *it
;
977 struct addrinfo hints
;
979 #else /* !HAVE_GETADDRINFO */
980 struct hostent
*hostent
;
982 struct servent
*servent
;
983 struct sockaddr_in addr
;
991 krb5_context kcontext
= 0;
992 krb5_auth_context auth_context
= 0;
994 krb5_principal client
, server
;
1001 Key_schedule schedule
;
1003 #endif /* KERBEROS5 */
1004 #endif /* KERBEROS */
1011 WSADATA winsockData
;
1012 if (WSAStartup (0x101, &winsockData
) == 0)
1017 memset (&addr
, 0, sizeof (addr
));
1018 addr
.sin_family
= AF_INET
;
1020 /** "kpop" service is never used: look for 20060515 to see why **/
1022 service
= (flags
& POP_NO_KERBEROS
) ? POP_SERVICE
: KPOP_SERVICE
;
1024 service
= POP_SERVICE
;
1028 if (! (flags
& POP_NO_HESIOD
))
1030 servent
= hes_getservbyname (service
, "tcp");
1033 addr
.sin_port
= servent
->s_port
;
1040 servent
= getservbyname (service
, "tcp");
1043 addr
.sin_port
= servent
->s_port
;
1047 /** "kpop" service is never used: look for 20060515 to see why **/
1049 addr
.sin_port
= htons ((flags
& POP_NO_KERBEROS
) ?
1050 POP_PORT
: KPOP_PORT
);
1052 addr
.sin_port
= htons (POP_PORT
);
1057 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1059 sock
= socket (PF_INET
, SOCK_STREAM
, 0);
1062 snprintf (pop_error
, ERROR_MAX
, "%s%s",
1063 POP_SOCKET_ERROR
, strerror (errno
));
1068 #ifdef HAVE_GETADDRINFO
1069 memset (&hints
, 0, sizeof (hints
));
1070 hints
.ai_socktype
= SOCK_STREAM
;
1071 hints
.ai_flags
= AI_CANONNAME
;
1072 hints
.ai_family
= AF_INET
;
1075 ret
= getaddrinfo (host
, service
, &hints
, &res
);
1077 if (ret
!= 0 && (ret
!= EAI_AGAIN
|| try_count
== 5))
1079 strcpy (pop_error
, "Could not determine POP server's address");
1084 for (it
= res
; it
; it
= it
->ai_next
)
1085 if (it
->ai_addrlen
== sizeof addr
)
1087 struct sockaddr_in
*in_a
= (struct sockaddr_in
*) it
->ai_addr
;
1088 addr
.sin_addr
= in_a
->sin_addr
;
1089 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof addr
))
1092 connect_ok
= it
!= NULL
;
1095 realhost
= alloca (strlen (it
->ai_canonname
) + 1);
1096 strcpy (realhost
, it
->ai_canonname
);
1100 #else /* !HAVE_GETADDRINFO */
1103 hostent
= gethostbyname (host
);
1105 if ((! hostent
) && ((h_errno
!= TRY_AGAIN
) || (try_count
== 5)))
1107 strcpy (pop_error
, "Could not determine POP server's address");
1110 } while (! hostent
);
1112 while (*hostent
->h_addr_list
)
1114 memcpy (&addr
.sin_addr
, *hostent
->h_addr_list
, hostent
->h_length
);
1115 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1117 hostent
->h_addr_list
++;
1119 connect_ok
= *hostent
->h_addr_list
!= NULL
;
1122 realhost
= alloca (strlen (hostent
->h_name
) + 1);
1123 strcpy (realhost
, hostent
->h_name
);
1126 #endif /* !HAVE_GETADDRINFO */
1128 #define CONNECT_ERROR "Could not connect to POP server: "
1133 snprintf (pop_error
, ERROR_MAX
, "%s%s", CONNECT_ERROR
, strerror (errno
));
1140 #define KRB_ERROR "Kerberos error connecting to POP server: "
1141 if (! (flags
& POP_NO_KERBEROS
))
1144 if ((rem
= krb5_init_context (&kcontext
)))
1148 krb5_auth_con_free (kcontext
, auth_context
);
1150 krb5_free_context (kcontext
);
1151 snprintf (pop_error
, ERROR_MAX
, "%s%s",
1152 KRB_ERROR
, error_message (rem
));
1157 if ((rem
= krb5_auth_con_init (kcontext
, &auth_context
)))
1160 if (rem
= krb5_cc_default (kcontext
, &ccdef
))
1163 if (rem
= krb5_cc_get_principal (kcontext
, ccdef
, &client
))
1166 for (cp
= realhost
; *cp
; cp
++)
1170 *cp
= tolower (*cp
);
1174 if (rem
= krb5_sname_to_principal (kcontext
, realhost
,
1175 POP_SERVICE
, FALSE
, &server
))
1178 rem
= krb5_sendauth (kcontext
, &auth_context
,
1179 (krb5_pointer
) &sock
, "KPOPV1.0", client
, server
,
1180 AP_OPTS_MUTUAL_REQUIRED
,
1181 0, /* no checksum */
1182 0, /* no creds, use ccache instead */
1185 0, /* don't need subsession key */
1186 0); /* don't need reply */
1187 krb5_free_principal (kcontext
, server
);
1190 int pop_error_len
= snprintf (pop_error
, ERROR_MAX
, "%s%s",
1191 KRB_ERROR
, error_message (rem
));
1192 #if defined HAVE_KRB5_ERROR_TEXT
1193 if (err_ret
&& err_ret
->text
.length
)
1195 int errlen
= err_ret
->text
.length
;
1196 snprintf (pop_error
+ pop_error_len
, ERROR_MAX
- pop_error_len
,
1197 " [server says '%.*s']", errlen
, err_ret
->text
.data
);
1199 #elif defined HAVE_KRB5_ERROR_E_TEXT
1200 if (err_ret
&& err_ret
->e_text
&& **err_ret
->e_text
)
1201 snprintf (pop_error
+ pop_error_len
, ERROR_MAX
- pop_error_len
,
1202 " [server says '%s']", *err_ret
->e_text
);
1205 krb5_free_error (kcontext
, err_ret
);
1206 krb5_auth_con_free (kcontext
, auth_context
);
1207 krb5_free_context (kcontext
);
1212 #else /* ! KERBEROS5 */
1213 ticket
= (KTEXT
) malloc (sizeof (KTEXT_ST
));
1214 rem
= krb_sendauth (0L, sock
, ticket
, "pop", realhost
,
1215 (char *) krb_realmofhost (realhost
),
1216 (unsigned long) 0, &msg_data
, &cred
, schedule
,
1217 (struct sockaddr_in
*) 0,
1218 (struct sockaddr_in
*) 0,
1220 free ((char *) ticket
);
1221 if (rem
!= KSUCCESS
)
1223 snprintf (pop_error
, ERROR_MAX
, "%s%s", KRB_ERROR
, krb_err_txt
[rem
]);
1227 #endif /* KERBEROS5 */
1229 #endif /* KERBEROS */
1232 } /* socket_connection */
1235 * Function: pop_getline
1237 * Purpose: Get a line of text from the connection and return a
1238 * pointer to it. The carriage return and linefeed at the end of
1239 * the line are stripped, but periods at the beginnings of lines
1240 * are NOT dealt with in any special way.
1243 * server The server from which to get the line of text.
1245 * Returns: The number of characters in the line, which is returned in
1246 * LINE, not including the final null. A return value of 0
1247 * indicates a blank line. A negative return value indicates an
1248 * error (in which case the contents of LINE are undefined. In
1249 * case of error, an error message is copied into pop_error.
1251 * Notes: The line returned is overwritten with each call to pop_getline.
1253 * Side effects: Closes the connection on error.
1255 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1258 pop_getline (popserver server
, char **line
)
1260 #define GETLINE_ERROR "Error reading from server: "
1263 int search_offset
= 0;
1267 char *cp
= find_crlf (server
->buffer
+ server
->buffer_index
,
1274 found
= server
->buffer_index
;
1275 data_used
= (cp
+ 2) - server
->buffer
- found
;
1277 *cp
= '\0'; /* terminate the string to be returned */
1278 server
->data
-= data_used
;
1279 server
->buffer_index
+= data_used
;
1282 /* Embedded nulls will truncate this output prematurely,
1283 but that's OK because it's just for debugging anyway. */
1284 fprintf (stderr
, "<<< %s\n", server
->buffer
+ found
);
1285 *line
= server
->buffer
+ found
;
1286 return (data_used
- 2);
1290 memmove (server
->buffer
, server
->buffer
+ server
->buffer_index
,
1292 /* Record the fact that we've searched the data already in
1293 the buffer for a CRLF, so that when we search below, we
1294 don't have to search the same data twice. There's a "-
1295 1" here to account for the fact that the last character
1296 of the data we have may be the CR of a CRLF pair, of
1297 which we haven't read the second half yet, so we may have
1298 to search it again when we read more data. */
1299 search_offset
= server
->data
- 1;
1300 server
->buffer_index
= 0;
1305 server
->buffer_index
= 0;
1310 /* There's a "- 1" here to leave room for the null that we put
1311 at the end of the read data below. We put the null there so
1312 that find_crlf knows where to stop when we call it. */
1313 if (server
->data
== server
->buffer_size
- 1)
1315 server
->buffer_size
+= GETLINE_INCR
;
1316 server
->buffer
= (char *)realloc (server
->buffer
, server
->buffer_size
);
1317 if (! server
->buffer
)
1319 strcpy (pop_error
, "Out of memory in pop_getline");
1324 ret
= RECV (server
->file
, server
->buffer
+ server
->data
,
1325 server
->buffer_size
- server
->data
- 1, 0);
1328 snprintf (pop_error
, ERROR_MAX
, "%s%s",
1329 GETLINE_ERROR
, strerror (errno
));
1335 strcpy (pop_error
, "Unexpected EOF from server in pop_getline");
1342 server
->data
+= ret
;
1343 server
->buffer
[server
->data
] = '\0';
1345 cp
= find_crlf (server
->buffer
+ search_offset
,
1346 server
->data
- search_offset
);
1349 int data_used
= (cp
+ 2) - server
->buffer
;
1351 server
->data
-= data_used
;
1352 server
->buffer_index
= data_used
;
1355 fprintf (stderr
, "<<< %s\n", server
->buffer
);
1356 *line
= server
->buffer
;
1357 return (data_used
- 2);
1359 /* As above, the "- 1" here is to account for the fact that
1360 we may have read a CR without its accompanying LF. */
1361 search_offset
+= ret
- 1;
1369 * Function: sendline
1371 * Purpose: Sends a line of text to the POP server. The line of text
1372 * passed into this function should NOT have the carriage return
1373 * and linefeed on the end of it. Periods at beginnings of lines
1374 * will NOT be treated specially by this function.
1377 * server The server to which to send the text.
1378 * line The line of text to send.
1380 * Return value: Upon successful completion, a value of 0 will be
1381 * returned. Otherwise, a non-zero value will be returned, and
1382 * an error will be copied into pop_error.
1384 * Side effects: Closes the connection on error.
1387 sendline (popserver server
, const char *line
)
1389 #define SENDLINE_ERROR "Error writing to POP server: "
1393 /* Combine the string and the CR-LF into one buffer. Otherwise, two
1394 reasonable network stack optimizations, Nagle's algorithm and
1395 delayed acks, combine to delay us a fraction of a second on every
1396 message we send. (Movemail writes line without \r\n, client
1397 kernel sends packet, server kernel delays the ack to see if it
1398 can combine it with data, movemail writes \r\n, client kernel
1399 waits because it has unacked data already in its outgoing queue,
1400 client kernel eventually times out and sends.)
1402 This can be something like 0.2s per command, which can add up
1403 over a few dozen messages, and is a big chunk of the time we
1404 spend fetching mail from a server close by. */
1405 buf
= alloca (strlen (line
) + 3);
1406 strcpy (stpcpy (buf
, line
), "\r\n");
1407 ret
= fullwrite (server
->file
, buf
, strlen (buf
));
1412 snprintf (pop_error
, ERROR_MAX
, "%s%s", SENDLINE_ERROR
, strerror (errno
));
1417 fprintf (stderr
, ">>> %s\n", line
);
1423 * Procedure: fullwrite
1425 * Purpose: Just like write, but keeps trying until the entire string
1428 * Return value: Same as write. Pop_error is not set.
1431 fullwrite (int fd
, char *buf
, int nbytes
)
1437 while (nbytes
&& ((ret
= SEND (fd
, cp
, nbytes
, 0)) > 0))
1449 * Purpose: Reads a line from the server. If the return indicator is
1450 * positive, return with a zero exit status. If not, return with
1451 * a negative exit status.
1454 * server The server to read from.
1456 * Returns: 0 for success, else for failure and puts error in pop_error.
1458 * Side effects: On failure, may make the connection unusable.
1461 getok (popserver server
)
1465 if (pop_getline (server
, &fromline
) < 0)
1470 if (! strncmp (fromline
, "+OK", 3))
1472 else if (! strncmp (fromline
, "-ERR", 4))
1474 snprintf (pop_error
, ERROR_MAX
, "%s", fromline
);
1480 "Unexpected response from server; expecting +OK or -ERR");
1488 * Function: gettermination
1490 * Purpose: Gets the next line and verifies that it is a termination
1491 * line (nothing but a dot).
1493 * Return value: 0 on success, non-zero with pop_error set on error.
1495 * Side effects: Closes the connection on error.
1498 gettermination (server
)
1503 if (pop_getline (server
, &fromserver
) < 0)
1506 if (strcmp (fromserver
, "."))
1509 "Unexpected response from server in gettermination");
1519 * Function pop_close
1521 * Purpose: Close a pop connection, sending a "RSET" command to try to
1522 * preserve any changes that were made and a "QUIT" command to
1523 * try to get the server to quit, but ignoring any responses that
1526 * Side effects: The server is unusable after this function returns.
1527 * Changes made to the maildrop since the session was started (or
1528 * since the last pop_reset) may be lost.
1531 pop_close (popserver server
)
1534 free ((char *) server
);
1540 * Function: pop_trash
1542 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1543 * memory associated with the server. It is valid to call
1544 * pop_close or pop_quit after this function has been called.
1547 pop_trash (popserver server
)
1549 if (server
->file
>= 0)
1551 /* avoid recursion; sendline can call pop_trash */
1552 if (server
->trash_started
)
1554 server
->trash_started
= true;
1556 sendline (server
, "RSET");
1557 sendline (server
, "QUIT");
1559 CLOSESOCKET (server
->file
);
1563 free (server
->buffer
);
1574 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1575 embedded nulls and has LEN characters in it not including the final
1576 null, or 0 if it does not contain one. */
1579 find_crlf (char *in_string
, int len
)
1583 if (*in_string
== '\r')
1585 if (*++in_string
== '\n')
1586 return (in_string
- 1);
1595 /* The following 2 functions are only available since XP, so we load
1596 them dynamically and provide fallbacks. */
1598 int (WINAPI
*pfn_getaddrinfo
) (const char *, const char *,
1599 const struct addrinfo
*, struct addrinfo
**);
1600 void (WINAPI
*pfn_freeaddrinfo
) (struct addrinfo
*);
1605 static int ws2_loaded
= 0;
1609 HANDLE ws2_lib
= LoadLibrary ("Ws2_32.dll");
1611 if (ws2_lib
!= NULL
)
1614 pfn_getaddrinfo
= (void *) GetProcAddress (ws2_lib
, "getaddrinfo");
1615 pfn_freeaddrinfo
= (void *) GetProcAddress (ws2_lib
, "freeaddrinfo");
1616 /* Paranoia: these two functions should go together, so if
1617 one is absent, we cannot use the other. */
1618 if (pfn_getaddrinfo
== NULL
)
1619 pfn_freeaddrinfo
= NULL
;
1620 else if (pfn_freeaddrinfo
== NULL
)
1621 pfn_getaddrinfo
= NULL
;
1634 sys_getaddrinfo (const char *node
, const char *service
,
1635 const struct addrinfo
*hints
, struct addrinfo
**res
)
1639 if (load_ws2 () != 0)
1642 return WSANO_RECOVERY
;
1645 if (pfn_getaddrinfo
)
1646 rc
= pfn_getaddrinfo (node
, service
, hints
, res
);
1650 struct hostent
*host_info
;
1651 struct gai_storage
{
1652 struct addrinfo addrinfo
;
1653 struct sockaddr_in sockaddr_in
;
1656 /* We don't support any flags besides AI_CANONNAME. */
1657 if (hints
&& (hints
->ai_flags
& ~(AI_CANONNAME
)) != 0)
1659 /* NODE cannot be NULL, since pop.c has fallbacks for that. */
1661 return WSAHOST_NOT_FOUND
;
1665 const char *protocol
=
1666 (hints
&& hints
->ai_socktype
== SOCK_DGRAM
) ? "udp" : "tcp";
1667 struct servent
*srv
= getservbyname (service
, protocol
);
1672 return WSAHOST_NOT_FOUND
;
1675 gai_storage
= calloc (1, sizeof *gai_storage
);
1676 gai_storage
->sockaddr_in
.sin_port
= port
;
1677 host_info
= gethostbyname (node
);
1680 memcpy (&gai_storage
->sockaddr_in
.sin_addr
,
1681 host_info
->h_addr
, host_info
->h_length
);
1682 gai_storage
->sockaddr_in
.sin_family
= host_info
->h_addrtype
;
1687 return WSAHOST_NOT_FOUND
;
1690 gai_storage
->addrinfo
.ai_addr
=
1691 (struct sockaddr
*)&gai_storage
->sockaddr_in
;
1692 gai_storage
->addrinfo
.ai_addrlen
= sizeof (gai_storage
->sockaddr_in
);
1693 if (hints
&& (hints
->ai_flags
& AI_CANONNAME
) != 0)
1695 gai_storage
->addrinfo
.ai_canonname
= strdup (host_info
->h_name
);
1696 if (!gai_storage
->addrinfo
.ai_canonname
)
1699 return WSA_NOT_ENOUGH_MEMORY
;
1702 gai_storage
->addrinfo
.ai_protocol
= (hints
) ? hints
->ai_protocol
: 0;
1703 gai_storage
->addrinfo
.ai_socktype
= (hints
) ? hints
->ai_socktype
: 0;
1704 gai_storage
->addrinfo
.ai_family
= gai_storage
->sockaddr_in
.sin_family
;
1705 gai_storage
->addrinfo
.ai_next
= NULL
;
1707 *res
= &gai_storage
->addrinfo
;
1715 sys_freeaddrinfo (struct addrinfo
*ai
)
1717 if (load_ws2 () != 0)
1723 if (pfn_freeaddrinfo
)
1724 pfn_freeaddrinfo (ai
);
1727 if (ai
->ai_canonname
)
1728 free (ai
->ai_canonname
);
1732 #endif /* WINDOWSNT */
1733 #endif /* MAIL_USE_POP */