1 /* pop.c: client routines for talking to a POP3-protocol post-office server
2 Copyright (C) 1991, 1993, 1996, 1997, 1999, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 Written by Jonathan Kamens, jik@security.ov.com.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 #define NO_SHORTNAMES /* Tell config not to load remap.h */
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 * */);
83 # ifdef HAVE_KERBEROSIV_KRB_H
84 # include <kerberosIV/krb.h>
86 # ifdef HAVE_KERBEROS_KRB_H
87 # include <kerberos/krb.h>
91 # ifdef HAVE_COM_ERR_H
98 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
99 u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
100 struct sockaddr_in *, struct sockaddr_in *,
102 extern char *krb_realmofhost (/* char * */);
103 #endif /* ! KERBEROS5 */
104 #endif /* KERBEROS */
107 #if !defined(HAVE_H_ERRNO) || !defined(HAVE_CONFIG_H)
117 # endif /* __STDC__ */
120 static int socket_connection
__P((char *, int));
121 static int pop_getline
__P((popserver
, char **));
122 static int sendline
__P((popserver
, char *));
123 static int fullwrite
__P((int, char *, int));
124 static int getok
__P((popserver
));
126 static int gettermination
__P((popserver
));
128 static void pop_trash
__P((popserver
));
129 static char *find_crlf
__P((char *, int));
131 #define ERROR_MAX 160 /* a pretty arbitrary size, but needs
132 to be bigger than the original
135 #define KPOP_PORT 1109
136 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
138 #define KPOP_SERVICE "kpop" /* never used: look for 20060515 to see why */
141 char pop_error
[ERROR_MAX
];
145 #define min(a,b) (((a) < (b)) ? (a) : (b))
149 * Function: pop_open (char *host, char *username, char *password,
152 * Purpose: Establishes a connection with a post-office server, and
153 * completes the authorization portion of the session.
156 * host The server host with which the connection should be
157 * established. Optional. If omitted, internal
158 * heuristics will be used to determine the server host,
161 * The username of the mail-drop to access. Optional.
162 * If omitted, internal heuristics will be used to
163 * determine the username, if possible.
165 * The password to use for authorization. If omitted,
166 * internal heuristics will be used to determine the
167 * password, if possible.
168 * flags A bit mask containing flags controlling certain
169 * functions of the routine. Valid flags are defined in
172 * Return value: Upon successful establishment of a connection, a
173 * non-null popserver will be returned. Otherwise, null will be
174 * returned, and the string variable pop_error will contain an
175 * explanation of the error.
178 pop_open (host
, username
, password
, flags
)
187 /* Determine the user name */
190 username
= getenv ("USER");
191 if (! (username
&& *username
))
193 username
= getlogin ();
194 if (! (username
&& *username
))
196 struct passwd
*passwd
;
197 passwd
= getpwuid (getuid ());
198 if (passwd
&& passwd
->pw_name
&& *passwd
->pw_name
)
200 username
= passwd
->pw_name
;
204 strcpy (pop_error
, "Could not determine username");
212 * Determine the mail host.
217 host
= getenv ("MAILHOST");
221 if ((! host
) && (! (flags
& POP_NO_HESIOD
)))
223 struct hes_postoffice
*office
;
224 office
= hes_getmailhost (username
);
225 if (office
&& office
->po_type
&& (! strcmp (office
->po_type
, "POP"))
226 && office
->po_name
&& *office
->po_name
&& office
->po_host
229 host
= office
->po_host
;
230 username
= office
->po_name
;
244 strcpy (pop_error
, "Could not determine POP server");
248 /* Determine the password */
250 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
252 #define DONT_NEED_PASSWORD 0
255 if ((! password
) && (! DONT_NEED_PASSWORD
))
257 if (! (flags
& POP_NO_GETPASS
))
259 password
= getpass ("Enter POP password:");
263 strcpy (pop_error
, "Could not determine POP password");
267 if (password
) /* always true, detected 20060515 */
268 flags
|= POP_NO_KERBEROS
;
270 password
= username
; /* dead code, detected 20060515 */
271 /** "kpop" service is never used: look for 20060515 to see why **/
273 sock
= socket_connection (host
, flags
);
277 server
= (popserver
) malloc (sizeof (struct _popserver
));
280 strcpy (pop_error
, "Out of memory in pop_open");
283 server
->buffer
= (char *) malloc (GETLINE_MIN
);
284 if (! server
->buffer
)
286 strcpy (pop_error
, "Out of memory in pop_open");
287 free ((char *) server
);
293 server
->buffer_index
= 0;
294 server
->buffer_size
= GETLINE_MIN
;
295 server
->in_multi
= 0;
296 server
->trash_started
= 0;
302 * I really shouldn't use the pop_error variable like this, but....
304 if (strlen (username
) > ERROR_MAX
- 6)
308 "Username too long; recompile pop.c with larger ERROR_MAX");
311 sprintf (pop_error
, "USER %s", username
);
313 if (sendline (server
, pop_error
) || getok (server
))
318 if (strlen (password
) > ERROR_MAX
- 6)
322 "Password too long; recompile pop.c with larger ERROR_MAX");
325 sprintf (pop_error
, "PASS %s", password
);
327 if (sendline (server
, pop_error
) || getok (server
))
338 * Purpose: Issue the STAT command to the server and return (in the
339 * value parameters) the number of messages in the maildrop and
340 * the total size of the maildrop.
342 * Return value: 0 on success, or non-zero with an error in pop_error
345 * Side effects: On failure, may make further operations on the
346 * connection impossible.
349 pop_stat (server
, count
, size
)
357 if (server
->in_multi
)
359 strcpy (pop_error
, "In multi-line query in pop_stat");
363 if (sendline (server
, "STAT") || (pop_getline (server
, &fromserver
) < 0))
366 if (strncmp (fromserver
, "+OK ", 4))
368 if (0 == strncmp (fromserver
, "-ERR", 4))
370 strncpy (pop_error
, fromserver
, ERROR_MAX
);
375 "Unexpected response from POP server in pop_stat");
382 *count
= strtol (&fromserver
[4], &end_ptr
, 10);
383 /* Check validity of string-to-integer conversion. */
384 if (fromserver
+ 4 == end_ptr
|| *end_ptr
!= ' ' || errno
)
386 strcpy (pop_error
, "Unexpected response from POP server in pop_stat");
391 fromserver
= end_ptr
;
394 *size
= strtol (fromserver
+ 1, &end_ptr
, 10);
395 if (fromserver
+ 1 == end_ptr
|| errno
)
397 strcpy (pop_error
, "Unexpected response from POP server in pop_stat");
408 * Purpose: Performs the POP "list" command and returns (in value
409 * parameters) two malloc'd zero-terminated arrays -- one of
410 * message IDs, and a parallel one of sizes.
413 * server The pop connection to talk to.
414 * message The number of the one message about which to get
415 * information, or 0 to get information about all
418 * Return value: 0 on success, non-zero with error in pop_error on
421 * Side effects: On failure, may make further operations on the
422 * connection impossible.
425 pop_list (server
, message
, IDs
, sizes
)
434 if (server
->in_multi
)
436 strcpy (pop_error
, "In multi-line query in pop_list");
445 if (pop_stat (server
, &count
, &size
))
450 *IDs
= (int *) malloc ((how_many
+ 1) * sizeof (int));
451 *sizes
= (int *) malloc ((how_many
+ 1) * sizeof (int));
452 if (! (*IDs
&& *sizes
))
454 strcpy (pop_error
, "Out of memory in pop_list");
460 sprintf (pop_error
, "LIST %d", message
);
461 if (sendline (server
, pop_error
))
463 free ((char *) *IDs
);
464 free ((char *) *sizes
);
467 if (pop_getline (server
, &fromserver
) < 0)
469 free ((char *) *IDs
);
470 free ((char *) *sizes
);
473 if (strncmp (fromserver
, "+OK ", 4))
475 if (! strncmp (fromserver
, "-ERR", 4))
476 strncpy (pop_error
, fromserver
, ERROR_MAX
);
480 "Unexpected response from server in pop_list");
483 free ((char *) *IDs
);
484 free ((char *) *sizes
);
487 (*IDs
)[0] = atoi (&fromserver
[4]);
488 fromserver
= index (&fromserver
[4], ' ');
492 "Badly formatted response from server in pop_list");
494 free ((char *) *IDs
);
495 free ((char *) *sizes
);
498 (*sizes
)[0] = atoi (fromserver
);
499 (*IDs
)[1] = (*sizes
)[1] = 0;
504 if (pop_multi_first (server
, "LIST", &fromserver
))
506 free ((char *) *IDs
);
507 free ((char *) *sizes
);
510 for (i
= 0; i
< how_many
; i
++)
512 if (pop_multi_next (server
, &fromserver
) <= 0)
514 free ((char *) *IDs
);
515 free ((char *) *sizes
);
518 (*IDs
)[i
] = atoi (fromserver
);
519 fromserver
= index (fromserver
, ' ');
523 "Badly formatted response from server in pop_list");
524 free ((char *) *IDs
);
525 free ((char *) *sizes
);
529 (*sizes
)[i
] = atoi (fromserver
);
531 if (pop_multi_next (server
, &fromserver
) < 0)
533 free ((char *) *IDs
);
534 free ((char *) *sizes
);
540 "Too many response lines from server in pop_list");
541 free ((char *) *IDs
);
542 free ((char *) *sizes
);
545 (*IDs
)[i
] = (*sizes
)[i
] = 0;
551 * Function: pop_retrieve
553 * Purpose: Retrieve a specified message from the maildrop.
556 * server The server to retrieve from.
557 * message The message number to retrieve.
559 * If true, then mark the string "From " at the beginning
561 * msg_buf Output parameter to which a buffer containing the
562 * message is assigned.
564 * Return value: The number of bytes in msg_buf, which may contain
565 * embedded nulls, not including its final null, or -1 on error
566 * with pop_error set.
568 * Side effects: May kill connection on error.
571 pop_retrieve (server
, message
, markfrom
, msg_buf
)
577 int *IDs
, *sizes
, bufsize
, fromcount
= 0, cp
= 0;
578 char *ptr
, *fromserver
;
581 if (server
->in_multi
)
583 strcpy (pop_error
, "In multi-line query in pop_retrieve");
587 if (pop_list (server
, message
, &IDs
, &sizes
))
590 if (pop_retrieve_first (server
, message
, &fromserver
))
596 * The "5" below is an arbitrary constant -- I assume that if
597 * there are "From" lines in the text to be marked, there
598 * probably won't be more than 5 of them. If there are, I
599 * allocate more space for them below.
601 bufsize
= sizes
[0] + (markfrom
? 5 : 0);
602 ptr
= (char *)malloc (bufsize
);
604 free ((char *) sizes
);
608 strcpy (pop_error
, "Out of memory in pop_retrieve");
609 pop_retrieve_flush (server
);
613 while ((ret
= pop_retrieve_next (server
, &fromserver
)) >= 0)
621 if (markfrom
&& fromserver
[0] == 'F' && fromserver
[1] == 'r' &&
622 fromserver
[2] == 'o' && fromserver
[3] == 'm' &&
623 fromserver
[4] == ' ')
625 if (++fromcount
== 5)
628 ptr
= (char *)realloc (ptr
, bufsize
);
631 strcpy (pop_error
, "Out of memory in pop_retrieve");
632 pop_retrieve_flush (server
);
639 bcopy (fromserver
, &ptr
[cp
], ret
);
649 pop_retrieve_first (server
, message
, response
)
654 sprintf (pop_error
, "RETR %d", message
);
655 return (pop_multi_first (server
, pop_error
, response
));
659 Returns a negative number on error, 0 to indicate that the data has
660 all been read (i.e., the server has returned a "." termination
661 line), or a positive number indicating the number of bytes in the
662 returned buffer (which is null-terminated and may contain embedded
663 nulls, but the returned bytecount doesn't include the final null).
667 pop_retrieve_next (server
, line
)
671 return (pop_multi_next (server
, line
));
675 pop_retrieve_flush (server
)
678 return (pop_multi_flush (server
));
682 pop_top_first (server
, message
, lines
, response
)
687 sprintf (pop_error
, "TOP %d %d", message
, lines
);
688 return (pop_multi_first (server
, pop_error
, response
));
692 Returns a negative number on error, 0 to indicate that the data has
693 all been read (i.e., the server has returned a "." termination
694 line), or a positive number indicating the number of bytes in the
695 returned buffer (which is null-terminated and may contain embedded
696 nulls, but the returned bytecount doesn't include the final null).
700 pop_top_next (server
, line
)
704 return (pop_multi_next (server
, line
));
708 pop_top_flush (server
)
711 return (pop_multi_flush (server
));
715 pop_multi_first (server
, command
, response
)
720 if (server
->in_multi
)
723 "Already in multi-line query in pop_multi_first");
727 if (sendline (server
, command
) || (pop_getline (server
, response
) < 0))
732 if (0 == strncmp (*response
, "-ERR", 4))
734 strncpy (pop_error
, *response
, ERROR_MAX
);
737 else if (0 == strncmp (*response
, "+OK", 3))
739 for (*response
+= 3; **response
== ' '; (*response
)++) /* empty */;
740 server
->in_multi
= 1;
746 "Unexpected response from server in pop_multi_first");
752 Read the next line of data from SERVER and place a pointer to it
753 into LINE. Return -1 on error, 0 if there are no more lines to read
754 (i.e., the server has returned a line containing only "."), or a
755 positive number indicating the number of bytes in the LINE buffer
756 (not including the final null). The data in that buffer may contain
757 embedded nulls, but does not contain the final CRLF. When returning
758 0, LINE is set to null. */
761 pop_multi_next (server
, line
)
768 if (! server
->in_multi
)
770 strcpy (pop_error
, "Not in multi-line query in pop_multi_next");
774 if ((ret
= pop_getline (server
, &fromserver
)) < 0)
779 if (fromserver
[0] == '.')
784 server
->in_multi
= 0;
789 *line
= fromserver
+ 1;
801 pop_multi_flush (server
)
807 if (! server
->in_multi
)
812 while ((ret
= pop_multi_next (server
, &line
)))
821 /* Function: pop_delete
823 * Purpose: Delete a specified message.
826 * server Server from which to delete the message.
827 * message Message to delete.
829 * Return value: 0 on success, non-zero with error in pop_error
833 pop_delete (server
, message
)
837 if (server
->in_multi
)
839 strcpy (pop_error
, "In multi-line query in pop_delete");
843 sprintf (pop_error
, "DELE %d", message
);
845 if (sendline (server
, pop_error
) || getok (server
))
854 * Purpose: Send a noop command to the server.
857 * server The server to send to.
859 * Return value: 0 on success, non-zero with error in pop_error
862 * Side effects: Closes connection on error.
868 if (server
->in_multi
)
870 strcpy (pop_error
, "In multi-line query in pop_noop");
874 if (sendline (server
, "NOOP") || getok (server
))
883 * Purpose: Find out the highest seen message from the server.
888 * Return value: If successful, the highest seen message, which is
889 * greater than or equal to 0. Otherwise, a negative number with
890 * the error explained in pop_error.
892 * Side effects: Closes the connection on error.
900 if (server
->in_multi
)
902 strcpy (pop_error
, "In multi-line query in pop_last");
906 if (sendline (server
, "LAST"))
909 if (pop_getline (server
, &fromserver
) < 0)
912 if (! strncmp (fromserver
, "-ERR", 4))
914 strncpy (pop_error
, fromserver
, ERROR_MAX
);
917 else if (strncmp (fromserver
, "+OK ", 4))
919 strcpy (pop_error
, "Unexpected response from server in pop_last");
928 count
= strtol (&fromserver
[4], &end_ptr
, 10);
929 if (fromserver
+ 4 == end_ptr
|| errno
)
931 strcpy (pop_error
, "Unexpected response from server in pop_last");
940 * Function: pop_reset
942 * Purpose: Reset the server to its initial connect state
947 * Return value: 0 for success, non-0 with error in pop_error
950 * Side effects: Closes the connection on error.
956 if (pop_retrieve_flush (server
))
961 if (sendline (server
, "RSET") || getok (server
))
970 * Purpose: Quit the connection to the server,
973 * server The server to quit.
975 * Return value: 0 for success, non-zero otherwise with error in
978 * Side Effects: The popserver passed in is unusable after this
979 * function is called, even if an error occurs.
987 if (server
->file
>= 0)
989 if (pop_retrieve_flush (server
))
994 if (sendline (server
, "QUIT") || getok (server
))
999 close (server
->file
);
1003 free (server
->buffer
);
1004 free ((char *) server
);
1010 static int have_winsock
= 0;
1014 * Function: socket_connection
1016 * Purpose: Opens the network connection with the mail host, without
1017 * doing any sort of I/O with it or anything.
1020 * host The host to which to connect.
1021 * flags Option flags.
1023 * Return value: A file descriptor indicating the connection, or -1
1024 * indicating failure, in which case an error has been copied
1028 socket_connection (host
, flags
)
1032 #ifdef HAVE_GETADDRINFO
1033 struct addrinfo
*res
, *it
;
1034 struct addrinfo hints
;
1036 #else /* !HAVE_GETADDRINFO */
1037 struct hostent
*hostent
;
1039 struct servent
*servent
;
1040 struct sockaddr_in addr
;
1041 char found_port
= 0;
1047 krb5_error_code rem
;
1048 krb5_context kcontext
= 0;
1049 krb5_auth_context auth_context
= 0;
1051 krb5_principal client
, server
;
1052 krb5_error
*err_ret
;
1058 Key_schedule schedule
;
1060 #endif /* KERBEROS5 */
1061 #endif /* KERBEROS */
1068 WSADATA winsockData
;
1069 if (WSAStartup (0x101, &winsockData
) == 0)
1074 bzero ((char *) &addr
, sizeof (addr
));
1075 addr
.sin_family
= AF_INET
;
1077 /** "kpop" service is never used: look for 20060515 to see why **/
1079 service
= (flags
& POP_NO_KERBEROS
) ? POP_SERVICE
: KPOP_SERVICE
;
1081 service
= POP_SERVICE
;
1085 if (! (flags
& POP_NO_HESIOD
))
1087 servent
= hes_getservbyname (service
, "tcp");
1090 addr
.sin_port
= servent
->s_port
;
1097 servent
= getservbyname (service
, "tcp");
1100 addr
.sin_port
= servent
->s_port
;
1104 /** "kpop" service is never used: look for 20060515 to see why **/
1106 addr
.sin_port
= htons ((flags
& POP_NO_KERBEROS
) ?
1107 POP_PORT
: KPOP_PORT
);
1109 addr
.sin_port
= htons (POP_PORT
);
1114 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1116 sock
= socket (PF_INET
, SOCK_STREAM
, 0);
1119 strcpy (pop_error
, POP_SOCKET_ERROR
);
1120 strncat (pop_error
, strerror (errno
),
1121 ERROR_MAX
- sizeof (POP_SOCKET_ERROR
));
1126 #ifdef HAVE_GETADDRINFO
1127 memset (&hints
, 0, sizeof(hints
));
1128 hints
.ai_socktype
= SOCK_STREAM
;
1129 hints
.ai_flags
= AI_CANONNAME
;
1130 hints
.ai_family
= AF_INET
;
1133 ret
= getaddrinfo (host
, service
, &hints
, &res
);
1135 if (ret
!= 0 && (ret
!= EAI_AGAIN
|| try_count
== 5))
1137 strcpy (pop_error
, "Could not determine POP server's address");
1147 if (it
->ai_addrlen
== sizeof (addr
))
1149 struct sockaddr_in
*in_a
= (struct sockaddr_in
*) it
->ai_addr
;
1150 bcopy (&in_a
->sin_addr
, (char *) &addr
.sin_addr
,
1151 sizeof (addr
.sin_addr
));
1152 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1157 connect_ok
= it
!= NULL
;
1160 realhost
= alloca (strlen (it
->ai_canonname
) + 1);
1161 strcpy (realhost
, it
->ai_canonname
);
1165 #else /* !HAVE_GETADDRINFO */
1168 hostent
= gethostbyname (host
);
1170 if ((! hostent
) && ((h_errno
!= TRY_AGAIN
) || (try_count
== 5)))
1172 strcpy (pop_error
, "Could not determine POP server's address");
1175 } while (! hostent
);
1177 while (*hostent
->h_addr_list
)
1179 bcopy (*hostent
->h_addr_list
, (char *) &addr
.sin_addr
,
1181 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1183 hostent
->h_addr_list
++;
1185 connect_ok
= *hostent
->h_addr_list
!= NULL
;
1188 realhost
= alloca (strlen (hostent
->h_name
) + 1);
1189 strcpy (realhost
, hostent
->h_name
);
1192 #endif /* !HAVE_GETADDRINFO */
1194 #define CONNECT_ERROR "Could not connect to POP server: "
1199 strcpy (pop_error
, CONNECT_ERROR
);
1200 strncat (pop_error
, strerror (errno
),
1201 ERROR_MAX
- sizeof (CONNECT_ERROR
));
1208 #define KRB_ERROR "Kerberos error connecting to POP server: "
1209 if (! (flags
& POP_NO_KERBEROS
))
1212 if ((rem
= krb5_init_context (&kcontext
)))
1216 krb5_auth_con_free (kcontext
, auth_context
);
1218 krb5_free_context (kcontext
);
1219 strcpy (pop_error
, KRB_ERROR
);
1220 strncat (pop_error
, error_message (rem
),
1221 ERROR_MAX
- sizeof(KRB_ERROR
));
1226 if ((rem
= krb5_auth_con_init (kcontext
, &auth_context
)))
1229 if (rem
= krb5_cc_default (kcontext
, &ccdef
))
1232 if (rem
= krb5_cc_get_principal (kcontext
, ccdef
, &client
))
1235 for (cp
= realhost
; *cp
; cp
++)
1239 *cp
= tolower (*cp
);
1243 if (rem
= krb5_sname_to_principal (kcontext
, realhost
,
1244 POP_SERVICE
, FALSE
, &server
))
1247 rem
= krb5_sendauth (kcontext
, &auth_context
,
1248 (krb5_pointer
) &sock
, "KPOPV1.0", client
, server
,
1249 AP_OPTS_MUTUAL_REQUIRED
,
1250 0, /* no checksum */
1251 0, /* no creds, use ccache instead */
1254 0, /* don't need subsession key */
1255 0); /* don't need reply */
1256 krb5_free_principal (kcontext
, server
);
1259 if (err_ret
&& err_ret
->text
.length
)
1261 strcpy (pop_error
, KRB_ERROR
);
1262 strncat (pop_error
, error_message (rem
),
1263 ERROR_MAX
- sizeof (KRB_ERROR
));
1264 strncat (pop_error
, " [server says '",
1265 ERROR_MAX
- strlen (pop_error
) - 1);
1266 strncat (pop_error
, err_ret
->text
.data
,
1267 min (ERROR_MAX
- strlen (pop_error
) - 1,
1268 err_ret
->text
.length
));
1269 strncat (pop_error
, "']",
1270 ERROR_MAX
- strlen (pop_error
) - 1);
1274 strcpy (pop_error
, KRB_ERROR
);
1275 strncat (pop_error
, error_message (rem
),
1276 ERROR_MAX
- sizeof (KRB_ERROR
));
1279 krb5_free_error (kcontext
, err_ret
);
1280 krb5_auth_con_free (kcontext
, auth_context
);
1281 krb5_free_context (kcontext
);
1286 #else /* ! KERBEROS5 */
1287 ticket
= (KTEXT
) malloc (sizeof (KTEXT_ST
));
1288 rem
= krb_sendauth (0L, sock
, ticket
, "pop", realhost
,
1289 (char *) krb_realmofhost (realhost
),
1290 (unsigned long) 0, &msg_data
, &cred
, schedule
,
1291 (struct sockaddr_in
*) 0,
1292 (struct sockaddr_in
*) 0,
1294 free ((char *) ticket
);
1295 if (rem
!= KSUCCESS
)
1297 strcpy (pop_error
, KRB_ERROR
);
1298 strncat (pop_error
, krb_err_txt
[rem
],
1299 ERROR_MAX
- sizeof (KRB_ERROR
));
1303 #endif /* KERBEROS5 */
1305 #endif /* KERBEROS */
1308 } /* socket_connection */
1311 * Function: pop_getline
1313 * Purpose: Get a line of text from the connection and return a
1314 * pointer to it. The carriage return and linefeed at the end of
1315 * the line are stripped, but periods at the beginnings of lines
1316 * are NOT dealt with in any special way.
1319 * server The server from which to get the line of text.
1321 * Returns: The number of characters in the line, which is returned in
1322 * LINE, not including the final null. A return value of 0
1323 * indicates a blank line. A negative return value indicates an
1324 * error (in which case the contents of LINE are undefined. In
1325 * case of error, an error message is copied into pop_error.
1327 * Notes: The line returned is overwritten with each call to pop_getline.
1329 * Side effects: Closes the connection on error.
1331 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1334 pop_getline (server
, line
)
1338 #define GETLINE_ERROR "Error reading from server: "
1341 int search_offset
= 0;
1345 char *cp
= find_crlf (server
->buffer
+ server
->buffer_index
,
1352 found
= server
->buffer_index
;
1353 data_used
= (cp
+ 2) - server
->buffer
- found
;
1355 *cp
= '\0'; /* terminate the string to be returned */
1356 server
->data
-= data_used
;
1357 server
->buffer_index
+= data_used
;
1360 /* Embedded nulls will truncate this output prematurely,
1361 but that's OK because it's just for debugging anyway. */
1362 fprintf (stderr
, "<<< %s\n", server
->buffer
+ found
);
1363 *line
= server
->buffer
+ found
;
1364 return (data_used
- 2);
1368 bcopy (server
->buffer
+ server
->buffer_index
,
1369 server
->buffer
, server
->data
);
1370 /* Record the fact that we've searched the data already in
1371 the buffer for a CRLF, so that when we search below, we
1372 don't have to search the same data twice. There's a "-
1373 1" here to account for the fact that the last character
1374 of the data we have may be the CR of a CRLF pair, of
1375 which we haven't read the second half yet, so we may have
1376 to search it again when we read more data. */
1377 search_offset
= server
->data
- 1;
1378 server
->buffer_index
= 0;
1383 server
->buffer_index
= 0;
1388 /* There's a "- 1" here to leave room for the null that we put
1389 at the end of the read data below. We put the null there so
1390 that find_crlf knows where to stop when we call it. */
1391 if (server
->data
== server
->buffer_size
- 1)
1393 server
->buffer_size
+= GETLINE_INCR
;
1394 server
->buffer
= (char *)realloc (server
->buffer
, server
->buffer_size
);
1395 if (! server
->buffer
)
1397 strcpy (pop_error
, "Out of memory in pop_getline");
1402 ret
= RECV (server
->file
, server
->buffer
+ server
->data
,
1403 server
->buffer_size
- server
->data
- 1, 0);
1406 strcpy (pop_error
, GETLINE_ERROR
);
1407 strncat (pop_error
, strerror (errno
),
1408 ERROR_MAX
- sizeof (GETLINE_ERROR
));
1414 strcpy (pop_error
, "Unexpected EOF from server in pop_getline");
1421 server
->data
+= ret
;
1422 server
->buffer
[server
->data
] = '\0';
1424 cp
= find_crlf (server
->buffer
+ search_offset
,
1425 server
->data
- search_offset
);
1428 int data_used
= (cp
+ 2) - server
->buffer
;
1430 server
->data
-= data_used
;
1431 server
->buffer_index
= data_used
;
1434 fprintf (stderr
, "<<< %s\n", server
->buffer
);
1435 *line
= server
->buffer
;
1436 return (data_used
- 2);
1438 /* As above, the "- 1" here is to account for the fact that
1439 we may have read a CR without its accompanying LF. */
1440 search_offset
+= ret
- 1;
1448 * Function: sendline
1450 * Purpose: Sends a line of text to the POP server. The line of text
1451 * passed into this function should NOT have the carriage return
1452 * and linefeed on the end of it. Periods at beginnings of lines
1453 * will NOT be treated specially by this function.
1456 * server The server to which to send the text.
1457 * line The line of text to send.
1459 * Return value: Upon successful completion, a value of 0 will be
1460 * returned. Otherwise, a non-zero value will be returned, and
1461 * an error will be copied into pop_error.
1463 * Side effects: Closes the connection on error.
1466 sendline (server
, line
)
1470 #define SENDLINE_ERROR "Error writing to POP server: "
1474 /* Combine the string and the CR-LF into one buffer. Otherwise, two
1475 reasonable network stack optimizations, Nagle's algorithm and
1476 delayed acks, combine to delay us a fraction of a second on every
1477 message we send. (Movemail writes line without \r\n, client
1478 kernel sends packet, server kernel delays the ack to see if it
1479 can combine it with data, movemail writes \r\n, client kernel
1480 waits because it has unacked data already in its outgoing queue,
1481 client kernel eventually times out and sends.)
1483 This can be something like 0.2s per command, which can add up
1484 over a few dozen messages, and is a big chunk of the time we
1485 spend fetching mail from a server close by. */
1486 buf
= alloca (strlen (line
) + 3);
1488 strcat (buf
, "\r\n");
1489 ret
= fullwrite (server
->file
, buf
, strlen (buf
));
1494 strcpy (pop_error
, SENDLINE_ERROR
);
1495 strncat (pop_error
, strerror (errno
),
1496 ERROR_MAX
- sizeof (SENDLINE_ERROR
));
1501 fprintf (stderr
, ">>> %s\n", line
);
1507 * Procedure: fullwrite
1509 * Purpose: Just like write, but keeps trying until the entire string
1512 * Return value: Same as write. Pop_error is not set.
1515 fullwrite (fd
, buf
, nbytes
)
1524 while (nbytes
&& ((ret
= SEND (fd
, cp
, nbytes
, 0)) > 0))
1536 * Purpose: Reads a line from the server. If the return indicator is
1537 * positive, return with a zero exit status. If not, return with
1538 * a negative exit status.
1541 * server The server to read from.
1543 * Returns: 0 for success, else for failure and puts error in pop_error.
1545 * Side effects: On failure, may make the connection unusable.
1553 if (pop_getline (server
, &fromline
) < 0)
1558 if (! strncmp (fromline
, "+OK", 3))
1560 else if (! strncmp (fromline
, "-ERR", 4))
1562 strncpy (pop_error
, fromline
, ERROR_MAX
);
1563 pop_error
[ERROR_MAX
-1] = '\0';
1569 "Unexpected response from server; expecting +OK or -ERR");
1577 * Function: gettermination
1579 * Purpose: Gets the next line and verifies that it is a termination
1580 * line (nothing but a dot).
1582 * Return value: 0 on success, non-zero with pop_error set on error.
1584 * Side effects: Closes the connection on error.
1587 gettermination (server
)
1592 if (pop_getline (server
, &fromserver
) < 0)
1595 if (strcmp (fromserver
, "."))
1598 "Unexpected response from server in gettermination");
1608 * Function pop_close
1610 * Purpose: Close a pop connection, sending a "RSET" command to try to
1611 * preserve any changes that were made and a "QUIT" command to
1612 * try to get the server to quit, but ignoring any responses that
1615 * Side effects: The server is unusable after this function returns.
1616 * Changes made to the maildrop since the session was started (or
1617 * since the last pop_reset) may be lost.
1624 free ((char *) server
);
1630 * Function: pop_trash
1632 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1633 * memory associated with the server. It is legal to call
1634 * pop_close or pop_quit after this function has been called.
1640 if (server
->file
>= 0)
1642 /* avoid recursion; sendline can call pop_trash */
1643 if (server
->trash_started
)
1645 server
->trash_started
= 1;
1647 sendline (server
, "RSET");
1648 sendline (server
, "QUIT");
1650 CLOSESOCKET (server
->file
);
1654 free (server
->buffer
);
1665 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1666 embedded nulls and has LEN characters in it not including the final
1667 null, or 0 if it does not contain one. */
1670 find_crlf (in_string
, len
)
1676 if (*in_string
== '\r')
1678 if (*++in_string
== '\n')
1679 return (in_string
- 1);
1687 #endif /* MAIL_USE_POP */
1689 /* arch-tag: ceb37041-b7ad-49a8-a63d-286618b8367d
1690 (do not change this comment) */