1 /* pop.c: client routines for talking to a POP3-protocol post-office server
2 Copyright (c) 1991, 1993, 1996, 1997, 1999 Free Software Foundation, Inc.
3 Written by Jonathan Kamens, jik@security.ov.com.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #define NO_SHORTNAMES /* Tell config not to load remap.h */
31 #include <sys/types.h>
36 #define RECV(s,buf,len,flags) recv(s,buf,len,flags)
37 #define SEND(s,buf,len,flags) send(s,buf,len,flags)
38 #define CLOSESOCKET(s) closesocket(s)
40 #include <netinet/in.h>
41 #include <sys/socket.h>
42 #define RECV(s,buf,len,flags) read(s,buf,len)
43 #define SEND(s,buf,len,flags) write(s,buf,len)
44 #define CLOSESOCKET(s) close(s)
55 * It really shouldn't be necessary to put this declaration here, but
56 * the version of hesiod.h that Athena has installed in release 7.2
57 * doesn't declare this function; I don't know if the 7.3 version of
60 extern struct servent
*hes_getservbyname (/* char *, char * */);
82 # ifdef HAVE_KERBEROSIV_KRB_H
83 # include <kerberosIV/krb.h>
85 # ifdef HAVE_KERBEROS_KRB_H
86 # include <kerberos/krb.h>
90 # 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 */
106 #if !defined(HAVE_H_ERRNO) || !defined(HAVE_CONFIG_H)
116 # endif /* __STDC__ */
119 static int socket_connection
__P((char *, int));
120 static int pop_getline
__P((popserver
, char **));
121 static int sendline
__P((popserver
, char *));
122 static int fullwrite
__P((int, char *, int));
123 static int getok
__P((popserver
));
125 static int gettermination
__P((popserver
));
127 static void pop_trash
__P((popserver
));
128 static char *find_crlf
__P((char *, int));
130 #define ERROR_MAX 160 /* a pretty arbitrary size, but needs
131 to be bigger than the original
134 #define KPOP_PORT 1109
135 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
137 #define KPOP_SERVICE "kpop"
140 char pop_error
[ERROR_MAX
];
144 #define min(a,b) (((a) < (b)) ? (a) : (b))
148 * Function: pop_open (char *host, char *username, char *password,
151 * Purpose: Establishes a connection with a post-office server, and
152 * completes the authorization portion of the session.
155 * host The server host with which the connection should be
156 * established. Optional. If omitted, internal
157 * heuristics will be used to determine the server host,
160 * The username of the mail-drop to access. Optional.
161 * If omitted, internal heuristics will be used to
162 * determine the username, if possible.
164 * The password to use for authorization. If omitted,
165 * internal heuristics will be used to determine the
166 * password, if possible.
167 * flags A bit mask containing flags controlling certain
168 * functions of the routine. Valid flags are defined in
171 * Return value: Upon successful establishment of a connection, a
172 * non-null popserver will be returned. Otherwise, null will be
173 * returned, and the string variable pop_error will contain an
174 * explanation of the error.
177 pop_open (host
, username
, password
, flags
)
186 /* Determine the user name */
189 username
= getenv ("USER");
190 if (! (username
&& *username
))
192 username
= getlogin ();
193 if (! (username
&& *username
))
195 struct passwd
*passwd
;
196 passwd
= getpwuid (getuid ());
197 if (passwd
&& passwd
->pw_name
&& *passwd
->pw_name
)
199 username
= passwd
->pw_name
;
203 strcpy (pop_error
, "Could not determine username");
211 * Determine the mail host.
216 host
= getenv ("MAILHOST");
220 if ((! host
) && (! (flags
& POP_NO_HESIOD
)))
222 struct hes_postoffice
*office
;
223 office
= hes_getmailhost (username
);
224 if (office
&& office
->po_type
&& (! strcmp (office
->po_type
, "POP"))
225 && office
->po_name
&& *office
->po_name
&& office
->po_host
228 host
= office
->po_host
;
229 username
= office
->po_name
;
243 strcpy (pop_error
, "Could not determine POP server");
247 /* Determine the password */
249 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
251 #define DONT_NEED_PASSWORD 0
254 if ((! password
) && (! DONT_NEED_PASSWORD
))
256 if (! (flags
& POP_NO_GETPASS
))
258 password
= getpass ("Enter POP password:");
262 strcpy (pop_error
, "Could not determine POP password");
267 flags
|= POP_NO_KERBEROS
;
271 sock
= socket_connection (host
, flags
);
275 server
= (popserver
) malloc (sizeof (struct _popserver
));
278 strcpy (pop_error
, "Out of memory in pop_open");
281 server
->buffer
= (char *) malloc (GETLINE_MIN
);
282 if (! server
->buffer
)
284 strcpy (pop_error
, "Out of memory in pop_open");
285 free ((char *) server
);
291 server
->buffer_index
= 0;
292 server
->buffer_size
= GETLINE_MIN
;
293 server
->in_multi
= 0;
294 server
->trash_started
= 0;
300 * I really shouldn't use the pop_error variable like this, but....
302 if (strlen (username
) > ERROR_MAX
- 6)
306 "Username too long; recompile pop.c with larger ERROR_MAX");
309 sprintf (pop_error
, "USER %s", username
);
311 if (sendline (server
, pop_error
) || getok (server
))
316 if (strlen (password
) > ERROR_MAX
- 6)
320 "Password too long; recompile pop.c with larger ERROR_MAX");
323 sprintf (pop_error
, "PASS %s", password
);
325 if (sendline (server
, pop_error
) || getok (server
))
336 * Purpose: Issue the STAT command to the server and return (in the
337 * value parameters) the number of messages in the maildrop and
338 * the total size of the maildrop.
340 * Return value: 0 on success, or non-zero with an error in pop_error
343 * Side effects: On failure, may make further operations on the
344 * connection impossible.
347 pop_stat (server
, count
, size
)
354 if (server
->in_multi
)
356 strcpy (pop_error
, "In multi-line query in pop_stat");
360 if (sendline (server
, "STAT") || (pop_getline (server
, &fromserver
) < 0))
363 if (strncmp (fromserver
, "+OK ", 4))
365 if (0 == strncmp (fromserver
, "-ERR", 4))
367 strncpy (pop_error
, fromserver
, ERROR_MAX
);
372 "Unexpected response from POP server in pop_stat");
378 *count
= atoi (&fromserver
[4]);
380 fromserver
= index (&fromserver
[4], ' ');
384 "Badly formatted response from server in pop_stat");
389 *size
= atoi (fromserver
+ 1);
397 * Purpose: Performs the POP "list" command and returns (in value
398 * parameters) two malloc'd zero-terminated arrays -- one of
399 * message IDs, and a parallel one of sizes.
402 * server The pop connection to talk to.
403 * message The number of the one message about which to get
404 * information, or 0 to get information about all
407 * Return value: 0 on success, non-zero with error in pop_error on
410 * Side effects: On failure, may make further operations on the
411 * connection impossible.
414 pop_list (server
, message
, IDs
, sizes
)
423 if (server
->in_multi
)
425 strcpy (pop_error
, "In multi-line query in pop_list");
434 if (pop_stat (server
, &count
, &size
))
439 *IDs
= (int *) malloc ((how_many
+ 1) * sizeof (int));
440 *sizes
= (int *) malloc ((how_many
+ 1) * sizeof (int));
441 if (! (*IDs
&& *sizes
))
443 strcpy (pop_error
, "Out of memory in pop_list");
449 sprintf (pop_error
, "LIST %d", message
);
450 if (sendline (server
, pop_error
))
452 free ((char *) *IDs
);
453 free ((char *) *sizes
);
456 if (pop_getline (server
, &fromserver
) < 0)
458 free ((char *) *IDs
);
459 free ((char *) *sizes
);
462 if (strncmp (fromserver
, "+OK ", 4))
464 if (! strncmp (fromserver
, "-ERR", 4))
465 strncpy (pop_error
, fromserver
, ERROR_MAX
);
469 "Unexpected response from server in pop_list");
472 free ((char *) *IDs
);
473 free ((char *) *sizes
);
476 (*IDs
)[0] = atoi (&fromserver
[4]);
477 fromserver
= index (&fromserver
[4], ' ');
481 "Badly formatted response from server in pop_list");
483 free ((char *) *IDs
);
484 free ((char *) *sizes
);
487 (*sizes
)[0] = atoi (fromserver
);
488 (*IDs
)[1] = (*sizes
)[1] = 0;
493 if (pop_multi_first (server
, "LIST", &fromserver
))
495 free ((char *) *IDs
);
496 free ((char *) *sizes
);
499 for (i
= 0; i
< how_many
; i
++)
501 if (pop_multi_next (server
, &fromserver
) <= 0)
503 free ((char *) *IDs
);
504 free ((char *) *sizes
);
507 (*IDs
)[i
] = atoi (fromserver
);
508 fromserver
= index (fromserver
, ' ');
512 "Badly formatted response from server in pop_list");
513 free ((char *) *IDs
);
514 free ((char *) *sizes
);
518 (*sizes
)[i
] = atoi (fromserver
);
520 if (pop_multi_next (server
, &fromserver
) < 0)
522 free ((char *) *IDs
);
523 free ((char *) *sizes
);
529 "Too many response lines from server in pop_list");
530 free ((char *) *IDs
);
531 free ((char *) *sizes
);
534 (*IDs
)[i
] = (*sizes
)[i
] = 0;
540 * Function: pop_retrieve
542 * Purpose: Retrieve a specified message from the maildrop.
545 * server The server to retrieve from.
546 * message The message number to retrieve.
548 * If true, then mark the string "From " at the beginning
550 * msg_buf Output parameter to which a buffer containing the
551 * message is assigned.
553 * Return value: The number of bytes in msg_buf, which may contain
554 * embedded nulls, not including its final null, or -1 on error
555 * with pop_error set.
557 * Side effects: May kill connection on error.
560 pop_retrieve (server
, message
, markfrom
, msg_buf
)
566 int *IDs
, *sizes
, bufsize
, fromcount
= 0, cp
= 0;
567 char *ptr
, *fromserver
;
570 if (server
->in_multi
)
572 strcpy (pop_error
, "In multi-line query in pop_retrieve");
576 if (pop_list (server
, message
, &IDs
, &sizes
))
579 if (pop_retrieve_first (server
, message
, &fromserver
))
585 * The "5" below is an arbitrary constant -- I assume that if
586 * there are "From" lines in the text to be marked, there
587 * probably won't be more than 5 of them. If there are, I
588 * allocate more space for them below.
590 bufsize
= sizes
[0] + (markfrom
? 5 : 0);
591 ptr
= (char *)malloc (bufsize
);
593 free ((char *) sizes
);
597 strcpy (pop_error
, "Out of memory in pop_retrieve");
598 pop_retrieve_flush (server
);
602 while ((ret
= pop_retrieve_next (server
, &fromserver
)) >= 0)
610 if (markfrom
&& fromserver
[0] == 'F' && fromserver
[1] == 'r' &&
611 fromserver
[2] == 'o' && fromserver
[3] == 'm' &&
612 fromserver
[4] == ' ')
614 if (++fromcount
== 5)
617 ptr
= (char *)realloc (ptr
, bufsize
);
620 strcpy (pop_error
, "Out of memory in pop_retrieve");
621 pop_retrieve_flush (server
);
628 bcopy (fromserver
, &ptr
[cp
], ret
);
638 pop_retrieve_first (server
, message
, response
)
643 sprintf (pop_error
, "RETR %d", message
);
644 return (pop_multi_first (server
, pop_error
, response
));
648 Returns a negative number on error, 0 to indicate that the data has
649 all been read (i.e., the server has returned a "." termination
650 line), or a positive number indicating the number of bytes in the
651 returned buffer (which is null-terminated and may contain embedded
652 nulls, but the returned bytecount doesn't include the final null).
656 pop_retrieve_next (server
, line
)
660 return (pop_multi_next (server
, line
));
664 pop_retrieve_flush (server
)
667 return (pop_multi_flush (server
));
671 pop_top_first (server
, message
, lines
, response
)
676 sprintf (pop_error
, "TOP %d %d", message
, lines
);
677 return (pop_multi_first (server
, pop_error
, response
));
681 Returns a negative number on error, 0 to indicate that the data has
682 all been read (i.e., the server has returned a "." termination
683 line), or a positive number indicating the number of bytes in the
684 returned buffer (which is null-terminated and may contain embedded
685 nulls, but the returned bytecount doesn't include the final null).
689 pop_top_next (server
, line
)
693 return (pop_multi_next (server
, line
));
697 pop_top_flush (server
)
700 return (pop_multi_flush (server
));
704 pop_multi_first (server
, command
, response
)
709 if (server
->in_multi
)
712 "Already in multi-line query in pop_multi_first");
716 if (sendline (server
, command
) || (pop_getline (server
, response
) < 0))
721 if (0 == strncmp (*response
, "-ERR", 4))
723 strncpy (pop_error
, *response
, ERROR_MAX
);
726 else if (0 == strncmp (*response
, "+OK", 3))
728 for (*response
+= 3; **response
== ' '; (*response
)++) /* empty */;
729 server
->in_multi
= 1;
735 "Unexpected response from server in pop_multi_first");
741 Read the next line of data from SERVER and place a pointer to it
742 into LINE. Return -1 on error, 0 if there are no more lines to read
743 (i.e., the server has returned a line containing only "."), or a
744 positive number indicating the number of bytes in the LINE buffer
745 (not including the final null). The data in that buffer may contain
746 embedded nulls, but does not contain the final CRLF. When returning
747 0, LINE is set to null. */
750 pop_multi_next (server
, line
)
757 if (! server
->in_multi
)
759 strcpy (pop_error
, "Not in multi-line query in pop_multi_next");
763 if ((ret
= pop_getline (server
, &fromserver
)) < 0)
768 if (fromserver
[0] == '.')
773 server
->in_multi
= 0;
778 *line
= fromserver
+ 1;
790 pop_multi_flush (server
)
796 if (! server
->in_multi
)
801 while ((ret
= pop_multi_next (server
, &line
)))
810 /* Function: pop_delete
812 * Purpose: Delete a specified message.
815 * server Server from which to delete the message.
816 * message Message to delete.
818 * Return value: 0 on success, non-zero with error in pop_error
822 pop_delete (server
, message
)
826 if (server
->in_multi
)
828 strcpy (pop_error
, "In multi-line query in pop_delete");
832 sprintf (pop_error
, "DELE %d", message
);
834 if (sendline (server
, pop_error
) || getok (server
))
843 * Purpose: Send a noop command to the server.
846 * server The server to send to.
848 * Return value: 0 on success, non-zero with error in pop_error
851 * Side effects: Closes connection on error.
857 if (server
->in_multi
)
859 strcpy (pop_error
, "In multi-line query in pop_noop");
863 if (sendline (server
, "NOOP") || getok (server
))
872 * Purpose: Find out the highest seen message from the server.
877 * Return value: If successful, the highest seen message, which is
878 * greater than or equal to 0. Otherwise, a negative number with
879 * the error explained in pop_error.
881 * Side effects: Closes the connection on error.
889 if (server
->in_multi
)
891 strcpy (pop_error
, "In multi-line query in pop_last");
895 if (sendline (server
, "LAST"))
898 if (pop_getline (server
, &fromserver
) < 0)
901 if (! strncmp (fromserver
, "-ERR", 4))
903 strncpy (pop_error
, fromserver
, ERROR_MAX
);
906 else if (strncmp (fromserver
, "+OK ", 4))
908 strcpy (pop_error
, "Unexpected response from server in pop_last");
914 return (atoi (&fromserver
[4]));
919 * Function: pop_reset
921 * Purpose: Reset the server to its initial connect state
926 * Return value: 0 for success, non-0 with error in pop_error
929 * Side effects: Closes the connection on error.
935 if (pop_retrieve_flush (server
))
940 if (sendline (server
, "RSET") || getok (server
))
949 * Purpose: Quit the connection to the server,
952 * server The server to quit.
954 * Return value: 0 for success, non-zero otherwise with error in
957 * Side Effects: The popserver passed in is unusable after this
958 * function is called, even if an error occurs.
966 if (server
->file
>= 0)
968 if (pop_retrieve_flush (server
))
973 if (sendline (server
, "QUIT") || getok (server
))
978 close (server
->file
);
982 free (server
->buffer
);
983 free ((char *) server
);
989 static int have_winsock
= 0;
993 * Function: socket_connection
995 * Purpose: Opens the network connection with the mail host, without
996 * doing any sort of I/O with it or anything.
999 * host The host to which to connect.
1000 * flags Option flags.
1002 * Return value: A file descriptor indicating the connection, or -1
1003 * indicating failure, in which case an error has been copied
1007 socket_connection (host
, flags
)
1011 struct hostent
*hostent
;
1012 struct servent
*servent
;
1013 struct sockaddr_in addr
;
1014 char found_port
= 0;
1019 krb5_error_code rem
;
1020 krb5_context kcontext
= 0;
1021 krb5_auth_context auth_context
= 0;
1023 krb5_principal client
, server
;
1024 krb5_error
*err_ret
;
1030 Key_schedule schedule
;
1033 #endif /* KERBEROS5 */
1034 #endif /* KERBEROS */
1040 WSADATA winsockData
;
1041 if (WSAStartup (0x101, &winsockData
) == 0)
1046 bzero ((char *) &addr
, sizeof (addr
));
1047 addr
.sin_family
= AF_INET
;
1050 service
= (flags
& POP_NO_KERBEROS
) ? POP_SERVICE
: KPOP_SERVICE
;
1052 service
= POP_SERVICE
;
1056 if (! (flags
& POP_NO_HESIOD
))
1058 servent
= hes_getservbyname (service
, "tcp");
1061 addr
.sin_port
= servent
->s_port
;
1068 servent
= getservbyname (service
, "tcp");
1071 addr
.sin_port
= servent
->s_port
;
1076 addr
.sin_port
= htons ((flags
& POP_NO_KERBEROS
) ?
1077 POP_PORT
: KPOP_PORT
);
1079 addr
.sin_port
= htons (POP_PORT
);
1084 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1086 sock
= socket (PF_INET
, SOCK_STREAM
, 0);
1089 strcpy (pop_error
, POP_SOCKET_ERROR
);
1090 strncat (pop_error
, strerror (errno
),
1091 ERROR_MAX
- sizeof (POP_SOCKET_ERROR
));
1098 hostent
= gethostbyname (host
);
1100 if ((! hostent
) && ((h_errno
!= TRY_AGAIN
) || (try_count
== 5)))
1102 strcpy (pop_error
, "Could not determine POP server's address");
1105 } while (! hostent
);
1107 while (*hostent
->h_addr_list
)
1109 bcopy (*hostent
->h_addr_list
, (char *) &addr
.sin_addr
,
1111 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1113 hostent
->h_addr_list
++;
1116 #define CONNECT_ERROR "Could not connect to POP server: "
1118 if (! *hostent
->h_addr_list
)
1121 strcpy (pop_error
, CONNECT_ERROR
);
1122 strncat (pop_error
, strerror (errno
),
1123 ERROR_MAX
- sizeof (CONNECT_ERROR
));
1129 #define KRB_ERROR "Kerberos error connecting to POP server: "
1130 if (! (flags
& POP_NO_KERBEROS
))
1133 if ((rem
= krb5_init_context (&kcontext
)))
1137 krb5_auth_con_free (kcontext
, auth_context
);
1139 krb5_free_context (kcontext
);
1140 strcpy (pop_error
, KRB_ERROR
);
1141 strncat (pop_error
, error_message (rem
),
1142 ERROR_MAX
- sizeof(KRB_ERROR
));
1147 if ((rem
= krb5_auth_con_init (kcontext
, &auth_context
)))
1150 if (rem
= krb5_cc_default (kcontext
, &ccdef
))
1153 if (rem
= krb5_cc_get_principal (kcontext
, ccdef
, &client
))
1156 for (cp
= hostent
->h_name
; *cp
; cp
++)
1160 *cp
= tolower (*cp
);
1164 if (rem
= krb5_sname_to_principal (kcontext
, hostent
->h_name
,
1165 POP_SERVICE
, FALSE
, &server
))
1168 rem
= krb5_sendauth (kcontext
, &auth_context
,
1169 (krb5_pointer
) &sock
, "KPOPV1.0", client
, server
,
1170 AP_OPTS_MUTUAL_REQUIRED
,
1171 0, /* no checksum */
1172 0, /* no creds, use ccache instead */
1175 0, /* don't need subsession key */
1176 0); /* don't need reply */
1177 krb5_free_principal (kcontext
, server
);
1180 if (err_ret
&& err_ret
->text
.length
)
1182 strcpy (pop_error
, KRB_ERROR
);
1183 strncat (pop_error
, error_message (rem
),
1184 ERROR_MAX
- sizeof (KRB_ERROR
));
1185 strncat (pop_error
, " [server says '",
1186 ERROR_MAX
- strlen (pop_error
) - 1);
1187 strncat (pop_error
, err_ret
->text
.data
,
1188 min (ERROR_MAX
- strlen (pop_error
) - 1,
1189 err_ret
->text
.length
));
1190 strncat (pop_error
, "']",
1191 ERROR_MAX
- strlen (pop_error
) - 1);
1195 strcpy (pop_error
, KRB_ERROR
);
1196 strncat (pop_error
, error_message (rem
),
1197 ERROR_MAX
- sizeof (KRB_ERROR
));
1200 krb5_free_error (kcontext
, err_ret
);
1201 krb5_auth_con_free (kcontext
, auth_context
);
1202 krb5_free_context (kcontext
);
1207 #else /* ! KERBEROS5 */
1208 ticket
= (KTEXT
) malloc (sizeof (KTEXT_ST
));
1209 realhost
= strdup (hostent
->h_name
);
1210 rem
= krb_sendauth (0L, sock
, ticket
, "pop", realhost
,
1211 (char *) krb_realmofhost (realhost
),
1212 (unsigned long) 0, &msg_data
, &cred
, schedule
,
1213 (struct sockaddr_in
*) 0,
1214 (struct sockaddr_in
*) 0,
1216 free ((char *) ticket
);
1218 if (rem
!= KSUCCESS
)
1220 strcpy (pop_error
, KRB_ERROR
);
1221 strncat (pop_error
, krb_err_txt
[rem
],
1222 ERROR_MAX
- sizeof (KRB_ERROR
));
1226 #endif /* KERBEROS5 */
1228 #endif /* KERBEROS */
1231 } /* socket_connection */
1234 * Function: pop_getline
1236 * Purpose: Get a line of text from the connection and return a
1237 * pointer to it. The carriage return and linefeed at the end of
1238 * the line are stripped, but periods at the beginnings of lines
1239 * are NOT dealt with in any special way.
1242 * server The server from which to get the line of text.
1244 * Returns: The number of characters in the line, which is returned in
1245 * LINE, not including the final null. A return value of 0
1246 * indicates a blank line. A negative return value indicates an
1247 * error (in which case the contents of LINE are undefined. In
1248 * case of error, an error message is copied into pop_error.
1250 * Notes: The line returned is overwritten with each call to pop_getline.
1252 * Side effects: Closes the connection on error.
1254 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1257 pop_getline (server
, line
)
1261 #define GETLINE_ERROR "Error reading from server: "
1264 int search_offset
= 0;
1268 char *cp
= find_crlf (server
->buffer
+ server
->buffer_index
,
1275 found
= server
->buffer_index
;
1276 data_used
= (cp
+ 2) - server
->buffer
- found
;
1278 *cp
= '\0'; /* terminate the string to be returned */
1279 server
->data
-= data_used
;
1280 server
->buffer_index
+= data_used
;
1283 /* Embedded nulls will truncate this output prematurely,
1284 but that's OK because it's just for debugging anyway. */
1285 fprintf (stderr
, "<<< %s\n", server
->buffer
+ found
);
1286 *line
= server
->buffer
+ found
;
1287 return (data_used
- 2);
1291 bcopy (server
->buffer
+ server
->buffer_index
,
1292 server
->buffer
, server
->data
);
1293 /* Record the fact that we've searched the data already in
1294 the buffer for a CRLF, so that when we search below, we
1295 don't have to search the same data twice. There's a "-
1296 1" here to account for the fact that the last character
1297 of the data we have may be the CR of a CRLF pair, of
1298 which we haven't read the second half yet, so we may have
1299 to search it again when we read more data. */
1300 search_offset
= server
->data
- 1;
1301 server
->buffer_index
= 0;
1306 server
->buffer_index
= 0;
1311 /* There's a "- 1" here to leave room for the null that we put
1312 at the end of the read data below. We put the null there so
1313 that find_crlf knows where to stop when we call it. */
1314 if (server
->data
== server
->buffer_size
- 1)
1316 server
->buffer_size
+= GETLINE_INCR
;
1317 server
->buffer
= (char *)realloc (server
->buffer
, server
->buffer_size
);
1318 if (! server
->buffer
)
1320 strcpy (pop_error
, "Out of memory in pop_getline");
1325 ret
= RECV (server
->file
, server
->buffer
+ server
->data
,
1326 server
->buffer_size
- server
->data
- 1, 0);
1329 strcpy (pop_error
, GETLINE_ERROR
);
1330 strncat (pop_error
, strerror (errno
),
1331 ERROR_MAX
- sizeof (GETLINE_ERROR
));
1337 strcpy (pop_error
, "Unexpected EOF from server in pop_getline");
1344 server
->data
+= ret
;
1345 server
->buffer
[server
->data
] = '\0';
1347 cp
= find_crlf (server
->buffer
+ search_offset
,
1348 server
->data
- search_offset
);
1351 int data_used
= (cp
+ 2) - server
->buffer
;
1353 server
->data
-= data_used
;
1354 server
->buffer_index
= data_used
;
1357 fprintf (stderr
, "<<< %s\n", server
->buffer
);
1358 *line
= server
->buffer
;
1359 return (data_used
- 2);
1361 /* As above, the "- 1" here is to account for the fact that
1362 we may have read a CR without its accompanying LF. */
1363 search_offset
+= ret
- 1;
1371 * Function: sendline
1373 * Purpose: Sends a line of text to the POP server. The line of text
1374 * passed into this function should NOT have the carriage return
1375 * and linefeed on the end of it. Periods at beginnings of lines
1376 * will NOT be treated specially by this function.
1379 * server The server to which to send the text.
1380 * line The line of text to send.
1382 * Return value: Upon successful completion, a value of 0 will be
1383 * returned. Otherwise, a non-zero value will be returned, and
1384 * an error will be copied into pop_error.
1386 * Side effects: Closes the connection on error.
1389 sendline (server
, line
)
1393 #define SENDLINE_ERROR "Error writing to POP server: "
1397 /* Combine the string and the CR-LF into one buffer. Otherwise, two
1398 reasonable network stack optimizations, Nagle's algorithm and
1399 delayed acks, combine to delay us a fraction of a second on every
1400 message we send. (Movemail writes line without \r\n, client
1401 kernel sends packet, server kernel delays the ack to see if it
1402 can combine it with data, movemail writes \r\n, client kernel
1403 waits because it has unacked data already in its outgoing queue,
1404 client kernel eventually times out and sends.)
1406 This can be something like 0.2s per command, which can add up
1407 over a few dozen messages, and is a big chunk of the time we
1408 spend fetching mail from a server close by. */
1409 buf
= alloca (strlen (line
) + 3);
1411 strcat (buf
, "\r\n");
1412 ret
= fullwrite (server
->file
, buf
, strlen (buf
));
1417 strcpy (pop_error
, SENDLINE_ERROR
);
1418 strncat (pop_error
, strerror (errno
),
1419 ERROR_MAX
- sizeof (SENDLINE_ERROR
));
1424 fprintf (stderr
, ">>> %s\n", line
);
1430 * Procedure: fullwrite
1432 * Purpose: Just like write, but keeps trying until the entire string
1435 * Return value: Same as write. Pop_error is not set.
1438 fullwrite (fd
, buf
, nbytes
)
1447 while (nbytes
&& ((ret
= SEND (fd
, cp
, nbytes
, 0)) > 0))
1459 * Purpose: Reads a line from the server. If the return indicator is
1460 * positive, return with a zero exit status. If not, return with
1461 * a negative exit status.
1464 * server The server to read from.
1466 * Returns: 0 for success, else for failure and puts error in pop_error.
1468 * Side effects: On failure, may make the connection unusable.
1476 if (pop_getline (server
, &fromline
) < 0)
1481 if (! strncmp (fromline
, "+OK", 3))
1483 else if (! strncmp (fromline
, "-ERR", 4))
1485 strncpy (pop_error
, fromline
, ERROR_MAX
);
1486 pop_error
[ERROR_MAX
-1] = '\0';
1492 "Unexpected response from server; expecting +OK or -ERR");
1500 * Function: gettermination
1502 * Purpose: Gets the next line and verifies that it is a termination
1503 * line (nothing but a dot).
1505 * Return value: 0 on success, non-zero with pop_error set on error.
1507 * Side effects: Closes the connection on error.
1510 gettermination (server
)
1515 if (pop_getline (server
, &fromserver
) < 0)
1518 if (strcmp (fromserver
, "."))
1521 "Unexpected response from server in gettermination");
1531 * Function pop_close
1533 * Purpose: Close a pop connection, sending a "RSET" command to try to
1534 * preserve any changes that were made and a "QUIT" command to
1535 * try to get the server to quit, but ignoring any responses that
1538 * Side effects: The server is unusable after this function returns.
1539 * Changes made to the maildrop since the session was started (or
1540 * since the last pop_reset) may be lost.
1547 free ((char *) server
);
1553 * Function: pop_trash
1555 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1556 * memory associated with the server. It is legal to call
1557 * pop_close or pop_quit after this function has been called.
1563 if (server
->file
>= 0)
1565 /* avoid recursion; sendline can call pop_trash */
1566 if (server
->trash_started
)
1568 server
->trash_started
= 1;
1570 sendline (server
, "RSET");
1571 sendline (server
, "QUIT");
1573 CLOSESOCKET (server
->file
);
1577 free (server
->buffer
);
1588 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1589 embedded nulls and has LEN characters in it not including the final
1590 null, or 0 if it does not contain one. */
1593 find_crlf (in_string
, len
)
1599 if (*in_string
== '\r')
1601 if (*++in_string
== '\n')
1602 return (in_string
- 1);
1610 #endif /* MAIL_USE_POP */
1612 /* arch-tag: ceb37041-b7ad-49a8-a63d-286618b8367d
1613 (do not change this comment) */