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/>. */
32 #include <sys/types.h>
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)
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)
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
61 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
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 *,
99 extern char *krb_realmofhost (/* char * */);
100 #endif /* ! KERBEROS5 */
101 #endif /* KERBEROS */
104 #if !defined(HAVE_H_ERRNO) || !defined(HAVE_CONFIG_H)
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
);
115 static int gettermination (popserver
);
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
124 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
126 #define KPOP_PORT 1109
127 #define KPOP_SERVICE "kpop" /* never used: look for 20060515 to see why */
130 char pop_error
[ERROR_MAX
];
134 #define min(a,b) (((a) < (b)) ? (a) : (b))
138 * Function: pop_open (char *host, char *username, char *password,
141 * Purpose: Establishes a connection with a post-office server, and
142 * completes the authorization portion of the session.
145 * host The server host with which the connection should be
146 * established. Optional. If omitted, internal
147 * heuristics will be used to determine the server host,
150 * The username of the mail-drop to access. Optional.
151 * If omitted, internal heuristics will be used to
152 * determine the username, if possible.
154 * The password to use for authorization. If omitted,
155 * internal heuristics will be used to determine the
156 * password, if possible.
157 * flags A bit mask containing flags controlling certain
158 * functions of the routine. Valid flags are defined in
161 * Return value: Upon successful establishment of a connection, a
162 * non-null popserver will be returned. Otherwise, null will be
163 * returned, and the string variable pop_error will contain an
164 * explanation of the error.
167 pop_open (char *host
, char *username
, char *password
, int flags
)
172 /* Determine the user name */
175 username
= getenv ("USER");
176 if (! (username
&& *username
))
178 username
= getlogin ();
179 if (! (username
&& *username
))
181 struct passwd
*passwd
;
182 passwd
= getpwuid (getuid ());
183 if (passwd
&& passwd
->pw_name
&& *passwd
->pw_name
)
185 username
= passwd
->pw_name
;
189 strcpy (pop_error
, "Could not determine username");
197 * Determine the mail host.
202 host
= getenv ("MAILHOST");
206 if ((! host
) && (! (flags
& POP_NO_HESIOD
)))
208 struct hes_postoffice
*office
;
209 office
= hes_getmailhost (username
);
210 if (office
&& office
->po_type
&& (! strcmp (office
->po_type
, "POP"))
211 && office
->po_name
&& *office
->po_name
&& office
->po_host
214 host
= office
->po_host
;
215 username
= office
->po_name
;
229 strcpy (pop_error
, "Could not determine POP server");
233 /* Determine the password */
235 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
237 #define DONT_NEED_PASSWORD 0
240 if ((! password
) && (! DONT_NEED_PASSWORD
))
242 if (! (flags
& POP_NO_GETPASS
))
244 password
= getpass ("Enter POP password:");
248 strcpy (pop_error
, "Could not determine POP password");
252 if (password
) /* always true, detected 20060515 */
253 flags
|= POP_NO_KERBEROS
;
255 password
= username
; /* dead code, detected 20060515 */
256 /** "kpop" service is never used: look for 20060515 to see why **/
258 sock
= socket_connection (host
, flags
);
262 server
= (popserver
) malloc (sizeof (struct _popserver
));
265 strcpy (pop_error
, "Out of memory in pop_open");
268 server
->buffer
= (char *) malloc (GETLINE_MIN
);
269 if (! server
->buffer
)
271 strcpy (pop_error
, "Out of memory in pop_open");
272 free ((char *) server
);
278 server
->buffer_index
= 0;
279 server
->buffer_size
= GETLINE_MIN
;
280 server
->in_multi
= 0;
281 server
->trash_started
= 0;
287 * I really shouldn't use the pop_error variable like this, but....
289 if (strlen (username
) > ERROR_MAX
- 6)
293 "Username too long; recompile pop.c with larger ERROR_MAX");
296 sprintf (pop_error
, "USER %s", username
);
298 if (sendline (server
, pop_error
) || getok (server
))
303 if (strlen (password
) > ERROR_MAX
- 6)
307 "Password too long; recompile pop.c with larger ERROR_MAX");
310 sprintf (pop_error
, "PASS %s", password
);
312 if (sendline (server
, pop_error
) || getok (server
))
323 * Purpose: Issue the STAT command to the server and return (in the
324 * value parameters) the number of messages in the maildrop and
325 * the total size of the maildrop.
327 * Return value: 0 on success, or non-zero with an error in pop_error
330 * Side effects: On failure, may make further operations on the
331 * connection impossible.
334 pop_stat (popserver server
, int *count
, int *size
)
339 if (server
->in_multi
)
341 strcpy (pop_error
, "In multi-line query in pop_stat");
345 if (sendline (server
, "STAT") || (pop_getline (server
, &fromserver
) < 0))
348 if (strncmp (fromserver
, "+OK ", 4))
350 if (0 == strncmp (fromserver
, "-ERR", 4))
352 strncpy (pop_error
, fromserver
, ERROR_MAX
);
357 "Unexpected response from POP server in pop_stat");
364 *count
= strtol (&fromserver
[4], &end_ptr
, 10);
365 /* Check validity of string-to-integer conversion. */
366 if (fromserver
+ 4 == end_ptr
|| *end_ptr
!= ' ' || errno
)
368 strcpy (pop_error
, "Unexpected response from POP server in pop_stat");
373 fromserver
= end_ptr
;
376 *size
= strtol (fromserver
+ 1, &end_ptr
, 10);
377 if (fromserver
+ 1 == end_ptr
|| errno
)
379 strcpy (pop_error
, "Unexpected response from POP server in pop_stat");
390 * Purpose: Performs the POP "list" command and returns (in value
391 * parameters) two malloc'd zero-terminated arrays -- one of
392 * message IDs, and a parallel one of sizes.
395 * server The pop connection to talk to.
396 * message The number of the one message about which to get
397 * information, or 0 to get information about all
400 * Return value: 0 on success, non-zero with error in pop_error on
403 * Side effects: On failure, may make further operations on the
404 * connection impossible.
407 pop_list (popserver server
, int message
, int **IDs
, int **sizes
)
412 if (server
->in_multi
)
414 strcpy (pop_error
, "In multi-line query in pop_list");
423 if (pop_stat (server
, &count
, &size
))
428 *IDs
= (int *) malloc ((how_many
+ 1) * sizeof (int));
429 *sizes
= (int *) malloc ((how_many
+ 1) * sizeof (int));
430 if (! (*IDs
&& *sizes
))
432 strcpy (pop_error
, "Out of memory in pop_list");
438 sprintf (pop_error
, "LIST %d", message
);
439 if (sendline (server
, pop_error
))
441 free ((char *) *IDs
);
442 free ((char *) *sizes
);
445 if (pop_getline (server
, &fromserver
) < 0)
447 free ((char *) *IDs
);
448 free ((char *) *sizes
);
451 if (strncmp (fromserver
, "+OK ", 4))
453 if (! strncmp (fromserver
, "-ERR", 4))
454 strncpy (pop_error
, fromserver
, ERROR_MAX
);
458 "Unexpected response from server in pop_list");
461 free ((char *) *IDs
);
462 free ((char *) *sizes
);
465 (*IDs
)[0] = atoi (&fromserver
[4]);
466 fromserver
= strchr (&fromserver
[4], ' ');
470 "Badly formatted response from server in pop_list");
472 free ((char *) *IDs
);
473 free ((char *) *sizes
);
476 (*sizes
)[0] = atoi (fromserver
);
477 (*IDs
)[1] = (*sizes
)[1] = 0;
482 if (pop_multi_first (server
, "LIST", &fromserver
))
484 free ((char *) *IDs
);
485 free ((char *) *sizes
);
488 for (i
= 0; i
< how_many
; i
++)
490 if (pop_multi_next (server
, &fromserver
) <= 0)
492 free ((char *) *IDs
);
493 free ((char *) *sizes
);
496 (*IDs
)[i
] = atoi (fromserver
);
497 fromserver
= strchr (fromserver
, ' ');
501 "Badly formatted response from server in pop_list");
502 free ((char *) *IDs
);
503 free ((char *) *sizes
);
507 (*sizes
)[i
] = atoi (fromserver
);
509 if (pop_multi_next (server
, &fromserver
) < 0)
511 free ((char *) *IDs
);
512 free ((char *) *sizes
);
518 "Too many response lines from server in pop_list");
519 free ((char *) *IDs
);
520 free ((char *) *sizes
);
523 (*IDs
)[i
] = (*sizes
)[i
] = 0;
529 * Function: pop_retrieve
531 * Purpose: Retrieve a specified message from the maildrop.
534 * server The server to retrieve from.
535 * message The message number to retrieve.
537 * If true, then mark the string "From " at the beginning
539 * msg_buf Output parameter to which a buffer containing the
540 * message is assigned.
542 * Return value: The number of bytes in msg_buf, which may contain
543 * embedded nulls, not including its final null, or -1 on error
544 * with pop_error set.
546 * Side effects: May kill connection on error.
549 pop_retrieve (popserver server
, int message
, int markfrom
, char **msg_buf
)
551 int *IDs
, *sizes
, bufsize
, fromcount
= 0, cp
= 0;
552 char *ptr
, *fromserver
;
555 if (server
->in_multi
)
557 strcpy (pop_error
, "In multi-line query in pop_retrieve");
561 if (pop_list (server
, message
, &IDs
, &sizes
))
564 if (pop_retrieve_first (server
, message
, &fromserver
))
570 * The "5" below is an arbitrary constant -- I assume that if
571 * there are "From" lines in the text to be marked, there
572 * probably won't be more than 5 of them. If there are, I
573 * allocate more space for them below.
575 bufsize
= sizes
[0] + (markfrom
? 5 : 0);
576 ptr
= (char *)malloc (bufsize
);
578 free ((char *) sizes
);
582 strcpy (pop_error
, "Out of memory in pop_retrieve");
583 pop_retrieve_flush (server
);
587 while ((ret
= pop_retrieve_next (server
, &fromserver
)) >= 0)
595 if (markfrom
&& fromserver
[0] == 'F' && fromserver
[1] == 'r' &&
596 fromserver
[2] == 'o' && fromserver
[3] == 'm' &&
597 fromserver
[4] == ' ')
599 if (++fromcount
== 5)
602 ptr
= (char *)realloc (ptr
, bufsize
);
605 strcpy (pop_error
, "Out of memory in pop_retrieve");
606 pop_retrieve_flush (server
);
613 memcpy (&ptr
[cp
], fromserver
, ret
);
623 pop_retrieve_first (popserver server
, int message
, char **response
)
625 sprintf (pop_error
, "RETR %d", message
);
626 return (pop_multi_first (server
, pop_error
, response
));
630 Returns a negative number on error, 0 to indicate that the data has
631 all been read (i.e., the server has returned a "." termination
632 line), or a positive number indicating the number of bytes in the
633 returned buffer (which is null-terminated and may contain embedded
634 nulls, but the returned bytecount doesn't include the final null).
638 pop_retrieve_next (popserver server
, char **line
)
640 return (pop_multi_next (server
, line
));
644 pop_retrieve_flush (popserver server
)
646 return (pop_multi_flush (server
));
650 pop_top_first (popserver server
, int message
, int lines
, char **response
)
652 sprintf (pop_error
, "TOP %d %d", message
, lines
);
653 return (pop_multi_first (server
, pop_error
, response
));
657 Returns a negative number on error, 0 to indicate that the data has
658 all been read (i.e., the server has returned a "." termination
659 line), or a positive number indicating the number of bytes in the
660 returned buffer (which is null-terminated and may contain embedded
661 nulls, but the returned bytecount doesn't include the final null).
665 pop_top_next (popserver server
, char **line
)
667 return (pop_multi_next (server
, line
));
671 pop_top_flush (popserver server
)
673 return (pop_multi_flush (server
));
677 pop_multi_first (popserver server
, const char *command
, char **response
)
679 if (server
->in_multi
)
682 "Already in multi-line query in pop_multi_first");
686 if (sendline (server
, command
) || (pop_getline (server
, response
) < 0))
691 if (0 == strncmp (*response
, "-ERR", 4))
693 strncpy (pop_error
, *response
, ERROR_MAX
);
696 else if (0 == strncmp (*response
, "+OK", 3))
698 for (*response
+= 3; **response
== ' '; (*response
)++) /* empty */;
699 server
->in_multi
= 1;
705 "Unexpected response from server in pop_multi_first");
711 Read the next line of data from SERVER and place a pointer to it
712 into LINE. Return -1 on error, 0 if there are no more lines to read
713 (i.e., the server has returned a line containing only "."), or a
714 positive number indicating the number of bytes in the LINE buffer
715 (not including the final null). The data in that buffer may contain
716 embedded nulls, but does not contain the final CRLF. When returning
717 0, LINE is set to null. */
720 pop_multi_next (popserver server
, char **line
)
725 if (! server
->in_multi
)
727 strcpy (pop_error
, "Not in multi-line query in pop_multi_next");
731 if ((ret
= pop_getline (server
, &fromserver
)) < 0)
736 if (fromserver
[0] == '.')
741 server
->in_multi
= 0;
746 *line
= fromserver
+ 1;
758 pop_multi_flush (popserver server
)
763 if (! server
->in_multi
)
768 while ((ret
= pop_multi_next (server
, &line
)))
777 /* Function: pop_delete
779 * Purpose: Delete a specified message.
782 * server Server from which to delete the message.
783 * message Message to delete.
785 * Return value: 0 on success, non-zero with error in pop_error
789 pop_delete (popserver server
, int message
)
791 if (server
->in_multi
)
793 strcpy (pop_error
, "In multi-line query in pop_delete");
797 sprintf (pop_error
, "DELE %d", message
);
799 if (sendline (server
, pop_error
) || getok (server
))
808 * Purpose: Send a noop command to the server.
811 * server The server to send to.
813 * Return value: 0 on success, non-zero with error in pop_error
816 * Side effects: Closes connection on error.
819 pop_noop (popserver server
)
821 if (server
->in_multi
)
823 strcpy (pop_error
, "In multi-line query in pop_noop");
827 if (sendline (server
, "NOOP") || getok (server
))
836 * Purpose: Find out the highest seen message from the server.
841 * Return value: If successful, the highest seen message, which is
842 * greater than or equal to 0. Otherwise, a negative number with
843 * the error explained in pop_error.
845 * Side effects: Closes the connection on error.
848 pop_last (popserver server
)
852 if (server
->in_multi
)
854 strcpy (pop_error
, "In multi-line query in pop_last");
858 if (sendline (server
, "LAST"))
861 if (pop_getline (server
, &fromserver
) < 0)
864 if (! strncmp (fromserver
, "-ERR", 4))
866 strncpy (pop_error
, fromserver
, ERROR_MAX
);
869 else if (strncmp (fromserver
, "+OK ", 4))
871 strcpy (pop_error
, "Unexpected response from server in pop_last");
880 count
= strtol (&fromserver
[4], &end_ptr
, 10);
881 if (fromserver
+ 4 == end_ptr
|| errno
)
883 strcpy (pop_error
, "Unexpected response from server in pop_last");
892 * Function: pop_reset
894 * Purpose: Reset the server to its initial connect state
899 * Return value: 0 for success, non-0 with error in pop_error
902 * Side effects: Closes the connection on error.
905 pop_reset (popserver server
)
907 if (pop_retrieve_flush (server
))
912 if (sendline (server
, "RSET") || getok (server
))
921 * Purpose: Quit the connection to the server,
924 * server The server to quit.
926 * Return value: 0 for success, non-zero otherwise with error in
929 * Side Effects: The popserver passed in is unusable after this
930 * function is called, even if an error occurs.
933 pop_quit (popserver server
)
937 if (server
->file
>= 0)
939 if (pop_retrieve_flush (server
))
944 if (sendline (server
, "QUIT") || getok (server
))
949 close (server
->file
);
952 free (server
->buffer
);
953 free ((char *) server
);
959 static int have_winsock
= 0;
963 * Function: socket_connection
965 * Purpose: Opens the network connection with the mail host, without
966 * doing any sort of I/O with it or anything.
969 * host The host to which to connect.
970 * flags Option flags.
972 * Return value: A file descriptor indicating the connection, or -1
973 * indicating failure, in which case an error has been copied
977 socket_connection (char *host
, int flags
)
979 #ifdef HAVE_GETADDRINFO
980 struct addrinfo
*res
, *it
;
981 struct addrinfo hints
;
983 #else /* !HAVE_GETADDRINFO */
984 struct hostent
*hostent
;
986 struct servent
*servent
;
987 struct sockaddr_in addr
;
995 krb5_context kcontext
= 0;
996 krb5_auth_context auth_context
= 0;
998 krb5_principal client
, server
;
1005 Key_schedule schedule
;
1007 #endif /* KERBEROS5 */
1008 #endif /* KERBEROS */
1015 WSADATA winsockData
;
1016 if (WSAStartup (0x101, &winsockData
) == 0)
1021 memset (&addr
, 0, sizeof (addr
));
1022 addr
.sin_family
= AF_INET
;
1024 /** "kpop" service is never used: look for 20060515 to see why **/
1026 service
= (flags
& POP_NO_KERBEROS
) ? POP_SERVICE
: KPOP_SERVICE
;
1028 service
= POP_SERVICE
;
1032 if (! (flags
& POP_NO_HESIOD
))
1034 servent
= hes_getservbyname (service
, "tcp");
1037 addr
.sin_port
= servent
->s_port
;
1044 servent
= getservbyname (service
, "tcp");
1047 addr
.sin_port
= servent
->s_port
;
1051 /** "kpop" service is never used: look for 20060515 to see why **/
1053 addr
.sin_port
= htons ((flags
& POP_NO_KERBEROS
) ?
1054 POP_PORT
: KPOP_PORT
);
1056 addr
.sin_port
= htons (POP_PORT
);
1061 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1063 sock
= socket (PF_INET
, SOCK_STREAM
, 0);
1066 strcpy (pop_error
, POP_SOCKET_ERROR
);
1067 strncat (pop_error
, strerror (errno
),
1068 ERROR_MAX
- sizeof (POP_SOCKET_ERROR
));
1073 #ifdef HAVE_GETADDRINFO
1074 memset (&hints
, 0, sizeof(hints
));
1075 hints
.ai_socktype
= SOCK_STREAM
;
1076 hints
.ai_flags
= AI_CANONNAME
;
1077 hints
.ai_family
= AF_INET
;
1080 ret
= getaddrinfo (host
, service
, &hints
, &res
);
1082 if (ret
!= 0 && (ret
!= EAI_AGAIN
|| try_count
== 5))
1084 strcpy (pop_error
, "Could not determine POP server's address");
1094 if (it
->ai_addrlen
== sizeof (addr
))
1096 struct sockaddr_in
*in_a
= (struct sockaddr_in
*) it
->ai_addr
;
1097 memcpy (&addr
.sin_addr
, &in_a
->sin_addr
, sizeof (addr
.sin_addr
));
1098 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1103 connect_ok
= it
!= NULL
;
1106 realhost
= alloca (strlen (it
->ai_canonname
) + 1);
1107 strcpy (realhost
, it
->ai_canonname
);
1111 #else /* !HAVE_GETADDRINFO */
1114 hostent
= gethostbyname (host
);
1116 if ((! hostent
) && ((h_errno
!= TRY_AGAIN
) || (try_count
== 5)))
1118 strcpy (pop_error
, "Could not determine POP server's address");
1121 } while (! hostent
);
1123 while (*hostent
->h_addr_list
)
1125 memcpy (&addr
.sin_addr
, *hostent
->h_addr_list
, hostent
->h_length
);
1126 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1128 hostent
->h_addr_list
++;
1130 connect_ok
= *hostent
->h_addr_list
!= NULL
;
1133 realhost
= alloca (strlen (hostent
->h_name
) + 1);
1134 strcpy (realhost
, hostent
->h_name
);
1137 #endif /* !HAVE_GETADDRINFO */
1139 #define CONNECT_ERROR "Could not connect to POP server: "
1144 strcpy (pop_error
, CONNECT_ERROR
);
1145 strncat (pop_error
, strerror (errno
),
1146 ERROR_MAX
- sizeof (CONNECT_ERROR
));
1153 #define KRB_ERROR "Kerberos error connecting to POP server: "
1154 if (! (flags
& POP_NO_KERBEROS
))
1157 if ((rem
= krb5_init_context (&kcontext
)))
1161 krb5_auth_con_free (kcontext
, auth_context
);
1163 krb5_free_context (kcontext
);
1164 strcpy (pop_error
, KRB_ERROR
);
1165 strncat (pop_error
, error_message (rem
),
1166 ERROR_MAX
- sizeof(KRB_ERROR
));
1171 if ((rem
= krb5_auth_con_init (kcontext
, &auth_context
)))
1174 if (rem
= krb5_cc_default (kcontext
, &ccdef
))
1177 if (rem
= krb5_cc_get_principal (kcontext
, ccdef
, &client
))
1180 for (cp
= realhost
; *cp
; cp
++)
1184 *cp
= tolower (*cp
);
1188 if (rem
= krb5_sname_to_principal (kcontext
, realhost
,
1189 POP_SERVICE
, FALSE
, &server
))
1192 rem
= krb5_sendauth (kcontext
, &auth_context
,
1193 (krb5_pointer
) &sock
, "KPOPV1.0", client
, server
,
1194 AP_OPTS_MUTUAL_REQUIRED
,
1195 0, /* no checksum */
1196 0, /* no creds, use ccache instead */
1199 0, /* don't need subsession key */
1200 0); /* don't need reply */
1201 krb5_free_principal (kcontext
, server
);
1204 strcpy (pop_error
, KRB_ERROR
);
1205 strncat (pop_error
, error_message (rem
),
1206 ERROR_MAX
- sizeof (KRB_ERROR
));
1207 #if defined HAVE_KRB5_ERROR_TEXT
1208 if (err_ret
&& err_ret
->text
.length
)
1210 strncat (pop_error
, " [server says '",
1211 ERROR_MAX
- strlen (pop_error
) - 1);
1212 strncat (pop_error
, err_ret
->text
.data
,
1213 min (ERROR_MAX
- strlen (pop_error
) - 1,
1214 err_ret
->text
.length
));
1215 strncat (pop_error
, "']",
1216 ERROR_MAX
- strlen (pop_error
) - 1);
1218 #elif defined HAVE_KRB5_ERROR_E_TEXT
1219 if (err_ret
&& err_ret
->e_text
&& strlen(*err_ret
->e_text
))
1221 strncat (pop_error
, " [server says '",
1222 ERROR_MAX
- strlen (pop_error
) - 1);
1223 strncat (pop_error
, *err_ret
->e_text
,
1224 ERROR_MAX
- strlen (pop_error
) - 1);
1225 strncat (pop_error
, "']",
1226 ERROR_MAX
- strlen (pop_error
) - 1);
1230 krb5_free_error (kcontext
, err_ret
);
1231 krb5_auth_con_free (kcontext
, auth_context
);
1232 krb5_free_context (kcontext
);
1237 #else /* ! KERBEROS5 */
1238 ticket
= (KTEXT
) malloc (sizeof (KTEXT_ST
));
1239 rem
= krb_sendauth (0L, sock
, ticket
, "pop", realhost
,
1240 (char *) krb_realmofhost (realhost
),
1241 (unsigned long) 0, &msg_data
, &cred
, schedule
,
1242 (struct sockaddr_in
*) 0,
1243 (struct sockaddr_in
*) 0,
1245 free ((char *) ticket
);
1246 if (rem
!= KSUCCESS
)
1248 strcpy (pop_error
, KRB_ERROR
);
1249 strncat (pop_error
, krb_err_txt
[rem
],
1250 ERROR_MAX
- sizeof (KRB_ERROR
));
1254 #endif /* KERBEROS5 */
1256 #endif /* KERBEROS */
1259 } /* socket_connection */
1262 * Function: pop_getline
1264 * Purpose: Get a line of text from the connection and return a
1265 * pointer to it. The carriage return and linefeed at the end of
1266 * the line are stripped, but periods at the beginnings of lines
1267 * are NOT dealt with in any special way.
1270 * server The server from which to get the line of text.
1272 * Returns: The number of characters in the line, which is returned in
1273 * LINE, not including the final null. A return value of 0
1274 * indicates a blank line. A negative return value indicates an
1275 * error (in which case the contents of LINE are undefined. In
1276 * case of error, an error message is copied into pop_error.
1278 * Notes: The line returned is overwritten with each call to pop_getline.
1280 * Side effects: Closes the connection on error.
1282 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1285 pop_getline (popserver server
, char **line
)
1287 #define GETLINE_ERROR "Error reading from server: "
1290 int search_offset
= 0;
1294 char *cp
= find_crlf (server
->buffer
+ server
->buffer_index
,
1301 found
= server
->buffer_index
;
1302 data_used
= (cp
+ 2) - server
->buffer
- found
;
1304 *cp
= '\0'; /* terminate the string to be returned */
1305 server
->data
-= data_used
;
1306 server
->buffer_index
+= data_used
;
1309 /* Embedded nulls will truncate this output prematurely,
1310 but that's OK because it's just for debugging anyway. */
1311 fprintf (stderr
, "<<< %s\n", server
->buffer
+ found
);
1312 *line
= server
->buffer
+ found
;
1313 return (data_used
- 2);
1317 memmove (server
->buffer
, server
->buffer
+ server
->buffer_index
,
1319 /* Record the fact that we've searched the data already in
1320 the buffer for a CRLF, so that when we search below, we
1321 don't have to search the same data twice. There's a "-
1322 1" here to account for the fact that the last character
1323 of the data we have may be the CR of a CRLF pair, of
1324 which we haven't read the second half yet, so we may have
1325 to search it again when we read more data. */
1326 search_offset
= server
->data
- 1;
1327 server
->buffer_index
= 0;
1332 server
->buffer_index
= 0;
1337 /* There's a "- 1" here to leave room for the null that we put
1338 at the end of the read data below. We put the null there so
1339 that find_crlf knows where to stop when we call it. */
1340 if (server
->data
== server
->buffer_size
- 1)
1342 server
->buffer_size
+= GETLINE_INCR
;
1343 server
->buffer
= (char *)realloc (server
->buffer
, server
->buffer_size
);
1344 if (! server
->buffer
)
1346 strcpy (pop_error
, "Out of memory in pop_getline");
1351 ret
= RECV (server
->file
, server
->buffer
+ server
->data
,
1352 server
->buffer_size
- server
->data
- 1, 0);
1355 strcpy (pop_error
, GETLINE_ERROR
);
1356 strncat (pop_error
, strerror (errno
),
1357 ERROR_MAX
- sizeof (GETLINE_ERROR
));
1363 strcpy (pop_error
, "Unexpected EOF from server in pop_getline");
1370 server
->data
+= ret
;
1371 server
->buffer
[server
->data
] = '\0';
1373 cp
= find_crlf (server
->buffer
+ search_offset
,
1374 server
->data
- search_offset
);
1377 int data_used
= (cp
+ 2) - server
->buffer
;
1379 server
->data
-= data_used
;
1380 server
->buffer_index
= data_used
;
1383 fprintf (stderr
, "<<< %s\n", server
->buffer
);
1384 *line
= server
->buffer
;
1385 return (data_used
- 2);
1387 /* As above, the "- 1" here is to account for the fact that
1388 we may have read a CR without its accompanying LF. */
1389 search_offset
+= ret
- 1;
1397 * Function: sendline
1399 * Purpose: Sends a line of text to the POP server. The line of text
1400 * passed into this function should NOT have the carriage return
1401 * and linefeed on the end of it. Periods at beginnings of lines
1402 * will NOT be treated specially by this function.
1405 * server The server to which to send the text.
1406 * line The line of text to send.
1408 * Return value: Upon successful completion, a value of 0 will be
1409 * returned. Otherwise, a non-zero value will be returned, and
1410 * an error will be copied into pop_error.
1412 * Side effects: Closes the connection on error.
1415 sendline (popserver server
, const char *line
)
1417 #define SENDLINE_ERROR "Error writing to POP server: "
1421 /* Combine the string and the CR-LF into one buffer. Otherwise, two
1422 reasonable network stack optimizations, Nagle's algorithm and
1423 delayed acks, combine to delay us a fraction of a second on every
1424 message we send. (Movemail writes line without \r\n, client
1425 kernel sends packet, server kernel delays the ack to see if it
1426 can combine it with data, movemail writes \r\n, client kernel
1427 waits because it has unacked data already in its outgoing queue,
1428 client kernel eventually times out and sends.)
1430 This can be something like 0.2s per command, which can add up
1431 over a few dozen messages, and is a big chunk of the time we
1432 spend fetching mail from a server close by. */
1433 buf
= alloca (strlen (line
) + 3);
1435 strcat (buf
, "\r\n");
1436 ret
= fullwrite (server
->file
, buf
, strlen (buf
));
1441 strcpy (pop_error
, SENDLINE_ERROR
);
1442 strncat (pop_error
, strerror (errno
),
1443 ERROR_MAX
- sizeof (SENDLINE_ERROR
));
1448 fprintf (stderr
, ">>> %s\n", line
);
1454 * Procedure: fullwrite
1456 * Purpose: Just like write, but keeps trying until the entire string
1459 * Return value: Same as write. Pop_error is not set.
1462 fullwrite (int fd
, char *buf
, int nbytes
)
1468 while (nbytes
&& ((ret
= SEND (fd
, cp
, nbytes
, 0)) > 0))
1480 * Purpose: Reads a line from the server. If the return indicator is
1481 * positive, return with a zero exit status. If not, return with
1482 * a negative exit status.
1485 * server The server to read from.
1487 * Returns: 0 for success, else for failure and puts error in pop_error.
1489 * Side effects: On failure, may make the connection unusable.
1492 getok (popserver server
)
1496 if (pop_getline (server
, &fromline
) < 0)
1501 if (! strncmp (fromline
, "+OK", 3))
1503 else if (! strncmp (fromline
, "-ERR", 4))
1505 strncpy (pop_error
, fromline
, ERROR_MAX
);
1506 pop_error
[ERROR_MAX
-1] = '\0';
1512 "Unexpected response from server; expecting +OK or -ERR");
1520 * Function: gettermination
1522 * Purpose: Gets the next line and verifies that it is a termination
1523 * line (nothing but a dot).
1525 * Return value: 0 on success, non-zero with pop_error set on error.
1527 * Side effects: Closes the connection on error.
1530 gettermination (server
)
1535 if (pop_getline (server
, &fromserver
) < 0)
1538 if (strcmp (fromserver
, "."))
1541 "Unexpected response from server in gettermination");
1551 * Function pop_close
1553 * Purpose: Close a pop connection, sending a "RSET" command to try to
1554 * preserve any changes that were made and a "QUIT" command to
1555 * try to get the server to quit, but ignoring any responses that
1558 * Side effects: The server is unusable after this function returns.
1559 * Changes made to the maildrop since the session was started (or
1560 * since the last pop_reset) may be lost.
1563 pop_close (popserver server
)
1566 free ((char *) server
);
1572 * Function: pop_trash
1574 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1575 * memory associated with the server. It is valid to call
1576 * pop_close or pop_quit after this function has been called.
1579 pop_trash (popserver server
)
1581 if (server
->file
>= 0)
1583 /* avoid recursion; sendline can call pop_trash */
1584 if (server
->trash_started
)
1586 server
->trash_started
= 1;
1588 sendline (server
, "RSET");
1589 sendline (server
, "QUIT");
1591 CLOSESOCKET (server
->file
);
1595 free (server
->buffer
);
1606 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1607 embedded nulls and has LEN characters in it not including the final
1608 null, or 0 if it does not contain one. */
1611 find_crlf (char *in_string
, int len
)
1615 if (*in_string
== '\r')
1617 if (*++in_string
== '\n')
1618 return (in_string
- 1);
1626 #endif /* MAIL_USE_POP */