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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #define NO_SHORTNAMES /* Tell config not to load remap.h */
24 #include <../src/config.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_DES_H
83 # include <kerberosIV/des.h>
85 # ifdef HAVE_KERBEROS_DES_H
86 # include <kerberos/des.h>
93 # ifdef HAVE_KERBEROSIV_KRB_H
94 # include <kerberosIV/krb.h>
96 # ifdef HAVE_KERBEROS_KRB_H
97 # include <kerberos/krb.h>
101 # ifdef HAVE_COM_ERR_H
102 # include <com_err.h>
104 #endif /* KERBEROS */
108 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
109 u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
110 struct sockaddr_in *, struct sockaddr_in *,
112 extern char *krb_realmofhost (/* char * */);
113 #endif /* ! KERBEROS5 */
114 #endif /* KERBEROS */
117 #if !defined(HAVE_H_ERRNO) || !defined(HAVE_CONFIG_H)
127 # endif /* __STDC__ */
130 static int socket_connection
_P((char *, int));
131 static int pop_getline
_P((popserver
, char **));
132 static int sendline
_P((popserver
, char *));
133 static int fullwrite
_P((int, char *, int));
134 static int getok
_P((popserver
));
136 static int gettermination
_P((popserver
));
138 static void pop_trash
_P((popserver
));
139 static char *find_crlf
_P((char *, int));
141 #define ERROR_MAX 160 /* a pretty arbitrary size, but needs
142 to be bigger than the one-time 80 */
144 #define KPOP_PORT 1109
145 #define POP_SERVICE "pop3" /* we don't want the POP2 port! */
147 #define KPOP_SERVICE "kpop"
150 char pop_error
[ERROR_MAX
];
154 #define min(a,b) (((a) < (b)) ? (a) : (b))
158 * Function: pop_open (char *host, char *username, char *password,
161 * Purpose: Establishes a connection with a post-office server, and
162 * completes the authorization portion of the session.
165 * host The server host with which the connection should be
166 * established. Optional. If omitted, internal
167 * heuristics will be used to determine the server host,
170 * The username of the mail-drop to access. Optional.
171 * If omitted, internal heuristics will be used to
172 * determine the username, if possible.
174 * The password to use for authorization. If omitted,
175 * internal heuristics will be used to determine the
176 * password, if possible.
177 * flags A bit mask containing flags controlling certain
178 * functions of the routine. Valid flags are defined in
181 * Return value: Upon successful establishment of a connection, a
182 * non-null popserver will be returned. Otherwise, null will be
183 * returned, and the string variable pop_error will contain an
184 * explanation of the error.
187 pop_open (host
, username
, password
, flags
)
196 /* Determine the user name */
199 username
= getenv ("USER");
200 if (! (username
&& *username
))
202 username
= getlogin ();
203 if (! (username
&& *username
))
205 struct passwd
*passwd
;
206 passwd
= getpwuid (getuid ());
207 if (passwd
&& passwd
->pw_name
&& *passwd
->pw_name
)
209 username
= passwd
->pw_name
;
213 strcpy (pop_error
, "Could not determine username");
221 * Determine the mail host.
226 host
= getenv ("MAILHOST");
230 if ((! host
) && (! (flags
& POP_NO_HESIOD
)))
232 struct hes_postoffice
*office
;
233 office
= hes_getmailhost (username
);
234 if (office
&& office
->po_type
&& (! strcmp (office
->po_type
, "POP"))
235 && office
->po_name
&& *office
->po_name
&& office
->po_host
238 host
= office
->po_host
;
239 username
= office
->po_name
;
253 strcpy (pop_error
, "Could not determine POP server");
257 /* Determine the password */
259 #define DONT_NEED_PASSWORD (! (flags & POP_NO_KERBEROS))
261 #define DONT_NEED_PASSWORD 0
264 if ((! password
) && (! DONT_NEED_PASSWORD
))
266 if (! (flags
& POP_NO_GETPASS
))
268 password
= getpass ("Enter POP password:");
272 strcpy (pop_error
, "Could not determine POP password");
277 flags
|= POP_NO_KERBEROS
;
281 sock
= socket_connection (host
, flags
);
285 server
= (popserver
) malloc (sizeof (struct _popserver
));
288 strcpy (pop_error
, "Out of memory in pop_open");
291 server
->buffer
= (char *) malloc (GETLINE_MIN
);
292 if (! server
->buffer
)
294 strcpy (pop_error
, "Out of memory in pop_open");
295 free ((char *) server
);
301 server
->buffer_index
= 0;
302 server
->buffer_size
= GETLINE_MIN
;
303 server
->in_multi
= 0;
304 server
->trash_started
= 0;
310 * I really shouldn't use the pop_error variable like this, but....
312 if (strlen (username
) > ERROR_MAX
- 6)
316 "Username too long; recompile pop.c with larger ERROR_MAX");
319 sprintf (pop_error
, "USER %s", username
);
321 if (sendline (server
, pop_error
) || getok (server
))
326 if (strlen (password
) > ERROR_MAX
- 6)
330 "Password too long; recompile pop.c with larger ERROR_MAX");
333 sprintf (pop_error
, "PASS %s", password
);
335 if (sendline (server
, pop_error
) || getok (server
))
346 * Purpose: Issue the STAT command to the server and return (in the
347 * value parameters) the number of messages in the maildrop and
348 * the total size of the maildrop.
350 * Return value: 0 on success, or non-zero with an error in pop_error
353 * Side effects: On failure, may make further operations on the
354 * connection impossible.
357 pop_stat (server
, count
, size
)
364 if (server
->in_multi
)
366 strcpy (pop_error
, "In multi-line query in pop_stat");
370 if (sendline (server
, "STAT") || (pop_getline (server
, &fromserver
) < 0))
373 if (strncmp (fromserver
, "+OK ", 4))
375 if (0 == strncmp (fromserver
, "-ERR", 4))
377 strncpy (pop_error
, fromserver
, ERROR_MAX
);
382 "Unexpected response from POP server in pop_stat");
388 *count
= atoi (&fromserver
[4]);
390 fromserver
= index (&fromserver
[4], ' ');
394 "Badly formatted response from server in pop_stat");
399 *size
= atoi (fromserver
+ 1);
407 * Purpose: Performs the POP "list" command and returns (in value
408 * parameters) two malloc'd zero-terminated arrays -- one of
409 * message IDs, and a parallel one of sizes.
412 * server The pop connection to talk to.
413 * message The number of the one message about which to get
414 * information, or 0 to get information about all
417 * Return value: 0 on success, non-zero with error in pop_error on
420 * Side effects: On failure, may make further operations on the
421 * connection impossible.
424 pop_list (server
, message
, IDs
, sizes
)
433 if (server
->in_multi
)
435 strcpy (pop_error
, "In multi-line query in pop_list");
444 if (pop_stat (server
, &count
, &size
))
449 *IDs
= (int *) malloc ((how_many
+ 1) * sizeof (int));
450 *sizes
= (int *) malloc ((how_many
+ 1) * sizeof (int));
451 if (! (*IDs
&& *sizes
))
453 strcpy (pop_error
, "Out of memory in pop_list");
459 sprintf (pop_error
, "LIST %d", message
);
460 if (sendline (server
, pop_error
))
462 free ((char *) *IDs
);
463 free ((char *) *sizes
);
466 if (pop_getline (server
, &fromserver
) < 0)
468 free ((char *) *IDs
);
469 free ((char *) *sizes
);
472 if (strncmp (fromserver
, "+OK ", 4))
474 if (! strncmp (fromserver
, "-ERR", 4))
475 strncpy (pop_error
, fromserver
, ERROR_MAX
);
479 "Unexpected response from server in pop_list");
482 free ((char *) *IDs
);
483 free ((char *) *sizes
);
486 (*IDs
)[0] = atoi (&fromserver
[4]);
487 fromserver
= index (&fromserver
[4], ' ');
491 "Badly formatted response from server in pop_list");
493 free ((char *) *IDs
);
494 free ((char *) *sizes
);
497 (*sizes
)[0] = atoi (fromserver
);
498 (*IDs
)[1] = (*sizes
)[1] = 0;
503 if (pop_multi_first (server
, "LIST", &fromserver
))
505 free ((char *) *IDs
);
506 free ((char *) *sizes
);
509 for (i
= 0; i
< how_many
; i
++)
511 if (pop_multi_next (server
, &fromserver
) <= 0)
513 free ((char *) *IDs
);
514 free ((char *) *sizes
);
517 (*IDs
)[i
] = atoi (fromserver
);
518 fromserver
= index (fromserver
, ' ');
522 "Badly formatted response from server in pop_list");
523 free ((char *) *IDs
);
524 free ((char *) *sizes
);
528 (*sizes
)[i
] = atoi (fromserver
);
530 if (pop_multi_next (server
, &fromserver
) < 0)
532 free ((char *) *IDs
);
533 free ((char *) *sizes
);
539 "Too many response lines from server in pop_list");
540 free ((char *) *IDs
);
541 free ((char *) *sizes
);
544 (*IDs
)[i
] = (*sizes
)[i
] = 0;
550 * Function: pop_retrieve
552 * Purpose: Retrieve a specified message from the maildrop.
555 * server The server to retrieve from.
556 * message The message number to retrieve.
558 * If true, then mark the string "From " at the beginning
560 * msg_buf Output parameter to which a buffer containing the
561 * message is assigned.
563 * Return value: The number of bytes in msg_buf, which may contain
564 * embedded nulls, not including its final null, or -1 on error
565 * with pop_error set.
567 * Side effects: May kill connection on error.
570 pop_retrieve (server
, message
, markfrom
, msg_buf
)
576 int *IDs
, *sizes
, bufsize
, fromcount
= 0, cp
= 0;
577 char *ptr
, *fromserver
;
580 if (server
->in_multi
)
582 strcpy (pop_error
, "In multi-line query in pop_retrieve");
586 if (pop_list (server
, message
, &IDs
, &sizes
))
589 if (pop_retrieve_first (server
, message
, &fromserver
))
595 * The "5" below is an arbitrary constant -- I assume that if
596 * there are "From" lines in the text to be marked, there
597 * probably won't be more than 5 of them. If there are, I
598 * allocate more space for them below.
600 bufsize
= sizes
[0] + (markfrom
? 5 : 0);
601 ptr
= (char *)malloc (bufsize
);
603 free ((char *) sizes
);
607 strcpy (pop_error
, "Out of memory in pop_retrieve");
608 pop_retrieve_flush (server
);
612 while ((ret
= pop_retrieve_next (server
, &fromserver
)) >= 0)
620 if (markfrom
&& fromserver
[0] == 'F' && fromserver
[1] == 'r' &&
621 fromserver
[2] == 'o' && fromserver
[3] == 'm' &&
622 fromserver
[4] == ' ')
624 if (++fromcount
== 5)
627 ptr
= (char *)realloc (ptr
, bufsize
);
630 strcpy (pop_error
, "Out of memory in pop_retrieve");
631 pop_retrieve_flush (server
);
638 bcopy (fromserver
, &ptr
[cp
], ret
);
648 pop_retrieve_first (server
, message
, response
)
653 sprintf (pop_error
, "RETR %d", message
);
654 return (pop_multi_first (server
, pop_error
, response
));
658 Returns a negative number on error, 0 to indicate that the data has
659 all been read (i.e., the server has returned a "." termination
660 line), or a positive number indicating the number of bytes in the
661 returned buffer (which is null-terminated and may contain embedded
662 nulls, but the returned bytecount doesn't include the final null).
666 pop_retrieve_next (server
, line
)
670 return (pop_multi_next (server
, line
));
674 pop_retrieve_flush (server
)
677 return (pop_multi_flush (server
));
681 pop_top_first (server
, message
, lines
, response
)
686 sprintf (pop_error
, "TOP %d %d", message
, lines
);
687 return (pop_multi_first (server
, pop_error
, response
));
691 Returns a negative number on error, 0 to indicate that the data has
692 all been read (i.e., the server has returned a "." termination
693 line), or a positive number indicating the number of bytes in the
694 returned buffer (which is null-terminated and may contain embedded
695 nulls, but the returned bytecount doesn't include the final null).
699 pop_top_next (server
, line
)
703 return (pop_multi_next (server
, line
));
707 pop_top_flush (server
)
710 return (pop_multi_flush (server
));
714 pop_multi_first (server
, command
, response
)
719 if (server
->in_multi
)
722 "Already in multi-line query in pop_multi_first");
726 if (sendline (server
, command
) || (pop_getline (server
, response
) < 0))
731 if (0 == strncmp (*response
, "-ERR", 4))
733 strncpy (pop_error
, *response
, ERROR_MAX
);
736 else if (0 == strncmp (*response
, "+OK", 3))
738 for (*response
+= 3; **response
== ' '; (*response
)++) /* empty */;
739 server
->in_multi
= 1;
745 "Unexpected response from server in pop_multi_first");
751 Read the next line of data from SERVER and place a pointer to it
752 into LINE. Return -1 on error, 0 if there are no more lines to read
753 (i.e., the server has returned a line containing only "."), or a
754 positive number indicating the number of bytes in the LINE buffer
755 (not including the final null). The data in that buffer may contain
756 embedded nulls, but does not contain the final CRLF. When returning
757 0, LINE is set to null. */
760 pop_multi_next (server
, line
)
767 if (! server
->in_multi
)
769 strcpy (pop_error
, "Not in multi-line query in pop_multi_next");
773 if ((ret
= pop_getline (server
, &fromserver
)) < 0)
778 if (fromserver
[0] == '.')
783 server
->in_multi
= 0;
788 *line
= fromserver
+ 1;
800 pop_multi_flush (server
)
806 if (! server
->in_multi
)
811 while ((ret
= pop_multi_next (server
, &line
)))
820 /* Function: pop_delete
822 * Purpose: Delete a specified message.
825 * server Server from which to delete the message.
826 * message Message to delete.
828 * Return value: 0 on success, non-zero with error in pop_error
832 pop_delete (server
, message
)
836 if (server
->in_multi
)
838 strcpy (pop_error
, "In multi-line query in pop_delete");
842 sprintf (pop_error
, "DELE %d", message
);
844 if (sendline (server
, pop_error
) || getok (server
))
853 * Purpose: Send a noop command to the server.
856 * server The server to send to.
858 * Return value: 0 on success, non-zero with error in pop_error
861 * Side effects: Closes connection on error.
867 if (server
->in_multi
)
869 strcpy (pop_error
, "In multi-line query in pop_noop");
873 if (sendline (server
, "NOOP") || getok (server
))
882 * Purpose: Find out the highest seen message from the server.
887 * Return value: If successful, the highest seen message, which is
888 * greater than or equal to 0. Otherwise, a negative number with
889 * the error explained in pop_error.
891 * Side effects: Closes the connection on error.
899 if (server
->in_multi
)
901 strcpy (pop_error
, "In multi-line query in pop_last");
905 if (sendline (server
, "LAST"))
908 if (pop_getline (server
, &fromserver
) < 0)
911 if (! strncmp (fromserver
, "-ERR", 4))
913 strncpy (pop_error
, fromserver
, ERROR_MAX
);
916 else if (strncmp (fromserver
, "+OK ", 4))
918 strcpy (pop_error
, "Unexpected response from server in pop_last");
924 return (atoi (&fromserver
[4]));
929 * Function: pop_reset
931 * Purpose: Reset the server to its initial connect state
936 * Return value: 0 for success, non-0 with error in pop_error
939 * Side effects: Closes the connection on error.
945 if (pop_retrieve_flush (server
))
950 if (sendline (server
, "RSET") || getok (server
))
959 * Purpose: Quit the connection to the server,
962 * server The server to quit.
964 * Return value: 0 for success, non-zero otherwise with error in
967 * Side Effects: The popserver passed in is unusable after this
968 * function is called, even if an error occurs.
976 if (server
->file
>= 0)
978 if (pop_retrieve_flush (server
))
983 if (sendline (server
, "QUIT") || getok (server
))
988 close (server
->file
);
992 free (server
->buffer
);
993 free ((char *) server
);
999 static int have_winsock
= 0;
1003 * Function: socket_connection
1005 * Purpose: Opens the network connection with the mail host, without
1006 * doing any sort of I/O with it or anything.
1009 * host The host to which to connect.
1010 * flags Option flags.
1012 * Return value: A file descriptor indicating the connection, or -1
1013 * indicating failure, in which case an error has been copied
1017 socket_connection (host
, flags
)
1021 struct hostent
*hostent
;
1022 struct servent
*servent
;
1023 struct sockaddr_in addr
;
1024 char found_port
= 0;
1029 krb5_error_code rem
;
1030 krb5_context kcontext
= 0;
1031 krb5_auth_context auth_context
= 0;
1033 krb5_principal client
, server
;
1034 krb5_error
*err_ret
;
1040 Key_schedule schedule
;
1043 #endif /* KERBEROS5 */
1044 #endif /* KERBEROS */
1050 WSADATA winsockData
;
1051 if (WSAStartup (0x101, &winsockData
) == 0)
1058 hostent
= gethostbyname (host
);
1060 if ((! hostent
) && ((h_errno
!= TRY_AGAIN
) || (try_count
== 5)))
1062 strcpy (pop_error
, "Could not determine POP server's address");
1065 } while (! hostent
);
1067 bzero ((char *) &addr
, sizeof (addr
));
1068 addr
.sin_family
= AF_INET
;
1071 service
= (flags
& POP_NO_KERBEROS
) ? POP_SERVICE
: KPOP_SERVICE
;
1073 service
= POP_SERVICE
;
1077 if (! (flags
& POP_NO_HESIOD
))
1079 servent
= hes_getservbyname (service
, "tcp");
1082 addr
.sin_port
= servent
->s_port
;
1089 servent
= getservbyname (service
, "tcp");
1092 addr
.sin_port
= servent
->s_port
;
1097 addr
.sin_port
= htons ((flags
& POP_NO_KERBEROS
) ?
1098 POP_PORT
: KPOP_PORT
);
1100 addr
.sin_port
= htons (POP_PORT
);
1105 #define POP_SOCKET_ERROR "Could not create socket for POP connection: "
1107 sock
= socket (PF_INET
, SOCK_STREAM
, 0);
1110 strcpy (pop_error
, POP_SOCKET_ERROR
);
1111 strncat (pop_error
, strerror (errno
),
1112 ERROR_MAX
- sizeof (POP_SOCKET_ERROR
));
1117 while (*hostent
->h_addr_list
)
1119 bcopy (*hostent
->h_addr_list
, (char *) &addr
.sin_addr
,
1121 if (! connect (sock
, (struct sockaddr
*) &addr
, sizeof (addr
)))
1123 hostent
->h_addr_list
++;
1126 #define CONNECT_ERROR "Could not connect to POP server: "
1128 if (! *hostent
->h_addr_list
)
1131 strcpy (pop_error
, CONNECT_ERROR
);
1132 strncat (pop_error
, strerror (errno
),
1133 ERROR_MAX
- sizeof (CONNECT_ERROR
));
1139 #define KRB_ERROR "Kerberos error connecting to POP server: "
1140 if (! (flags
& POP_NO_KERBEROS
))
1143 if ((rem
= krb5_init_context (&kcontext
)))
1147 krb5_auth_con_free (kcontext
, auth_context
);
1149 krb5_free_context (kcontext
);
1150 strcpy (pop_error
, KRB_ERROR
);
1151 strncat (pop_error
, error_message (rem
),
1152 ERROR_MAX
- sizeof(KRB_ERROR
));
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
= hostent
->h_name
; *cp
; cp
++)
1170 *cp
= tolower (*cp
);
1174 if (rem
= krb5_sname_to_principal (kcontext
, hostent
->h_name
,
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 if (err_ret
&& err_ret
->text
.length
)
1192 strcpy (pop_error
, KRB_ERROR
);
1193 strncat (pop_error
, error_message (rem
),
1194 ERROR_MAX
- sizeof (KRB_ERROR
));
1195 strncat (pop_error
, " [server says '",
1196 ERROR_MAX
- strlen (pop_error
) - 1);
1197 strncat (pop_error
, err_ret
->text
.data
,
1198 min (ERROR_MAX
- strlen (pop_error
) - 1,
1199 err_ret
->text
.length
));
1200 strncat (pop_error
, "']",
1201 ERROR_MAX
- strlen (pop_error
) - 1);
1205 strcpy (pop_error
, KRB_ERROR
);
1206 strncat (pop_error
, error_message (rem
),
1207 ERROR_MAX
- sizeof (KRB_ERROR
));
1210 krb5_free_error (kcontext
, err_ret
);
1211 krb5_auth_con_free (kcontext
, auth_context
);
1212 krb5_free_context (kcontext
);
1217 #else /* ! KERBEROS5 */
1218 ticket
= (KTEXT
) malloc (sizeof (KTEXT_ST
));
1219 realhost
= strdup (hostent
->h_name
);
1220 rem
= krb_sendauth (0L, sock
, ticket
, "pop", realhost
,
1221 (char *) krb_realmofhost (realhost
),
1222 (unsigned long) 0, &msg_data
, &cred
, schedule
,
1223 (struct sockaddr_in
*) 0,
1224 (struct sockaddr_in
*) 0,
1226 free ((char *) ticket
);
1228 if (rem
!= KSUCCESS
)
1230 strcpy (pop_error
, KRB_ERROR
);
1231 strncat (pop_error
, krb_err_txt
[rem
],
1232 ERROR_MAX
- sizeof (KRB_ERROR
));
1236 #endif /* KERBEROS5 */
1238 #endif /* KERBEROS */
1241 } /* socket_connection */
1244 * Function: pop_getline
1246 * Purpose: Get a line of text from the connection and return a
1247 * pointer to it. The carriage return and linefeed at the end of
1248 * the line are stripped, but periods at the beginnings of lines
1249 * are NOT dealt with in any special way.
1252 * server The server from which to get the line of text.
1254 * Returns: The number of characters in the line, which is returned in
1255 * LINE, not including the final null. A return value of 0
1256 * indicates a blank line. A negative return value indicates an
1257 * error (in which case the contents of LINE are undefined. In
1258 * case of error, an error message is copied into pop_error.
1260 * Notes: The line returned is overwritten with each call to pop_getline.
1262 * Side effects: Closes the connection on error.
1264 * THE RETURNED LINE MAY CONTAIN EMBEDDED NULLS!
1267 pop_getline (server
, line
)
1271 #define GETLINE_ERROR "Error reading from server: "
1274 int search_offset
= 0;
1278 char *cp
= find_crlf (server
->buffer
+ server
->buffer_index
,
1285 found
= server
->buffer_index
;
1286 data_used
= (cp
+ 2) - server
->buffer
- found
;
1288 *cp
= '\0'; /* terminate the string to be returned */
1289 server
->data
-= data_used
;
1290 server
->buffer_index
+= data_used
;
1293 /* Embedded nulls will truncate this output prematurely,
1294 but that's OK because it's just for debugging anyway. */
1295 fprintf (stderr
, "<<< %s\n", server
->buffer
+ found
);
1296 *line
= server
->buffer
+ found
;
1297 return (data_used
- 2);
1301 bcopy (server
->buffer
+ server
->buffer_index
,
1302 server
->buffer
, server
->data
);
1303 /* Record the fact that we've searched the data already in
1304 the buffer for a CRLF, so that when we search below, we
1305 don't have to search the same data twice. There's a "-
1306 1" here to account for the fact that the last character
1307 of the data we have may be the CR of a CRLF pair, of
1308 which we haven't read the second half yet, so we may have
1309 to search it again when we read more data. */
1310 search_offset
= server
->data
- 1;
1311 server
->buffer_index
= 0;
1316 server
->buffer_index
= 0;
1321 /* There's a "- 1" here to leave room for the null that we put
1322 at the end of the read data below. We put the null there so
1323 that find_crlf knows where to stop when we call it. */
1324 if (server
->data
== server
->buffer_size
- 1)
1326 server
->buffer_size
+= GETLINE_INCR
;
1327 server
->buffer
= (char *)realloc (server
->buffer
, server
->buffer_size
);
1328 if (! server
->buffer
)
1330 strcpy (pop_error
, "Out of memory in pop_getline");
1335 ret
= RECV (server
->file
, server
->buffer
+ server
->data
,
1336 server
->buffer_size
- server
->data
- 1, 0);
1339 strcpy (pop_error
, GETLINE_ERROR
);
1340 strncat (pop_error
, strerror (errno
),
1341 ERROR_MAX
- sizeof (GETLINE_ERROR
));
1347 strcpy (pop_error
, "Unexpected EOF from server in pop_getline");
1354 server
->data
+= ret
;
1355 server
->buffer
[server
->data
] = '\0';
1357 cp
= find_crlf (server
->buffer
+ search_offset
,
1358 server
->data
- search_offset
);
1361 int data_used
= (cp
+ 2) - server
->buffer
;
1363 server
->data
-= data_used
;
1364 server
->buffer_index
= data_used
;
1367 fprintf (stderr
, "<<< %s\n", server
->buffer
);
1368 *line
= server
->buffer
;
1369 return (data_used
- 2);
1371 /* As above, the "- 1" here is to account for the fact that
1372 we may have read a CR without its accompanying LF. */
1373 search_offset
+= ret
- 1;
1381 * Function: sendline
1383 * Purpose: Sends a line of text to the POP server. The line of text
1384 * passed into this function should NOT have the carriage return
1385 * and linefeed on the end of it. Periods at beginnings of lines
1386 * will NOT be treated specially by this function.
1389 * server The server to which to send the text.
1390 * line The line of text to send.
1392 * Return value: Upon successful completion, a value of 0 will be
1393 * returned. Otherwise, a non-zero value will be returned, and
1394 * an error will be copied into pop_error.
1396 * Side effects: Closes the connection on error.
1399 sendline (server
, line
)
1403 #define SENDLINE_ERROR "Error writing to POP server: "
1406 ret
= fullwrite (server
->file
, line
, strlen (line
));
1408 { /* 0 indicates that a blank line was written */
1409 ret
= fullwrite (server
->file
, "\r\n", 2);
1415 strcpy (pop_error
, SENDLINE_ERROR
);
1416 strncat (pop_error
, strerror (errno
),
1417 ERROR_MAX
- sizeof (SENDLINE_ERROR
));
1422 fprintf (stderr
, ">>> %s\n", line
);
1428 * Procedure: fullwrite
1430 * Purpose: Just like write, but keeps trying until the entire string
1433 * Return value: Same as write. Pop_error is not set.
1436 fullwrite (fd
, buf
, nbytes
)
1445 while (nbytes
&& ((ret
= SEND (fd
, cp
, nbytes
, 0)) > 0))
1457 * Purpose: Reads a line from the server. If the return indicator is
1458 * positive, return with a zero exit status. If not, return with
1459 * a negative exit status.
1462 * server The server to read from.
1464 * Returns: 0 for success, else for failure and puts error in pop_error.
1466 * Side effects: On failure, may make the connection unusable.
1474 if (pop_getline (server
, &fromline
) < 0)
1479 if (! strncmp (fromline
, "+OK", 3))
1481 else if (! strncmp (fromline
, "-ERR", 4))
1483 strncpy (pop_error
, fromline
, ERROR_MAX
);
1484 pop_error
[ERROR_MAX
-1] = '\0';
1490 "Unexpected response from server; expecting +OK or -ERR");
1498 * Function: gettermination
1500 * Purpose: Gets the next line and verifies that it is a termination
1501 * line (nothing but a dot).
1503 * Return value: 0 on success, non-zero with pop_error set on error.
1505 * Side effects: Closes the connection on error.
1508 gettermination (server
)
1513 if (pop_getline (server
, &fromserver
) < 0)
1516 if (strcmp (fromserver
, "."))
1519 "Unexpected response from server in gettermination");
1529 * Function pop_close
1531 * Purpose: Close a pop connection, sending a "RSET" command to try to
1532 * preserve any changes that were made and a "QUIT" command to
1533 * try to get the server to quit, but ignoring any responses that
1536 * Side effects: The server is unusable after this function returns.
1537 * Changes made to the maildrop since the session was started (or
1538 * since the last pop_reset) may be lost.
1545 free ((char *) server
);
1551 * Function: pop_trash
1553 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
1554 * memory associated with the server. It is legal to call
1555 * pop_close or pop_quit after this function has been called.
1561 if (server
->file
>= 0)
1563 /* avoid recursion; sendline can call pop_trash */
1564 if (server
->trash_started
)
1566 server
->trash_started
= 1;
1568 sendline (server
, "RSET");
1569 sendline (server
, "QUIT");
1571 CLOSESOCKET (server
->file
);
1575 free (server
->buffer
);
1586 /* Return a pointer to the first CRLF in IN_STRING, which can contain
1587 embedded nulls and has LEN characters in it not including the final
1588 null, or 0 if it does not contain one. */
1591 find_crlf (in_string
, len
)
1597 if (*in_string
== '\r')
1599 if (*++in_string
== '\n')
1600 return (in_string
- 1);
1608 #endif /* MAIL_USE_POP */