xemacs-beta: lib-src/pop.c comparison

comparison lib-src/pop.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	11cf20601dec
children	bbff43aa5eb7

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 #include <krb5/ext-proto.h>
 #include <ctype.h>
 #endif /* KRB5 */
 #endif /* KERBEROS */
-extern char *getenv (/* char * */);
-extern char *getlogin (/* void */);
-extern char *getpass (/* char * */);
-extern char *strerror (/* int */);
-extern char *index ();
 #ifdef KERBEROS
 #ifndef KRB5
 extern int krb_sendauth (/* long, int, KTEXT, char *, char *, char *,
 			    u_long, MSG_DAT *, CREDENTIALS *, Key_schedule,
 			    struct sockaddr_in *, struct sockaddr_in *,
 #if !defined(HAVE_H_ERRNO) || !defined(HAVE_CONFIG_H)
 extern int h_errno;
 #endif
 #endif
-static int socket_connection (/* char *, int */);
+static int socket_connection (char *, int);
-static char *getline (/* popserver */);
+static char *pop_getline (popserver);
-static int sendline (/* popserver, char * */);
+static int sendline (popserver, char *);
-static int fullwrite (/* int, char *, int */);
+static int fullwrite (int, char *, int);
-static int getok (/* popserver */);
+static int getok (popserver);
 #if 0
-static int gettermination (/* popserver */);
+static int gettermination (popserver);
 #endif
-static void pop_trash (/* popserver */);
+static void pop_trash (popserver);
-static char *find_crlf (/* char * */);
+static char *find_crlf (char *);
 #define ERROR_MAX 80		/* a pretty arbitrary size */
 #define POP_PORT 110
 #define KPOP_PORT 1109
 #if defined(WINDOWSNT) || defined(__CYGWIN32__)
 * 	non-null popserver will be returned.  Otherwise, null will be
 * 	returned, and the string variable pop_error will contain an
 * 	explanation of the error.
 */
 popserver
-pop_open (host, username, password, flags)
+pop_open (char *host, char *username, char *password, int flags)
-char *host;
-char *username;
-char *password;
-int flags;
 {
 int sock;
 popserver server;
 /* Determine the user name */
 *
 * Side effects: On failure, may make further operations on the
 * 	connection impossible.
 */
 int
-pop_stat (server, count, size)
+pop_stat (popserver server, int *count, int *size)
-popserver server;
-int *count;
-int *size;
 {
 char *fromserver;
 if (server->in_multi)
 {
 strcpy (pop_error, "In multi-line query in pop_stat");
 return (-1);
 }
-if (sendline (server, "STAT") || (! (fromserver = getline (server))))
+if (sendline (server, "STAT") || (! (fromserver = pop_getline (server))))
 return (-1);
 if (strncmp (fromserver, "+OK ", 4))
 {
 if (0 == strncmp (fromserver, "-ERR", 4))
 return (-1);
 }
 *count = atoi (&fromserver[4]);
-fromserver = index (&fromserver[4], ' ');
+fromserver = strchr (&fromserver[4], ' ');
 if (! fromserver)
 {
 strcpy (pop_error,
 	      "Badly formatted response from server in pop_stat");
 pop_trash (server);
 *
 * Side effects: On failure, may make further operations on the
 * 	connection impossible.
 */
 int
-pop_list (server, message, IDs, sizes)
+pop_list (popserver server, int message, int **IDs, int **sizes)
-popserver server;
-int message;
-int **IDs;
-int **sizes;
 {
 int how_many, i;
 char *fromserver;
 if (server->in_multi)
 	{
 	  free ((char *) *IDs);
 	  free ((char *) *sizes);
 	  return (-1);
 	}
-if (! (fromserver = getline (server)))
+if (! (fromserver = pop_getline (server)))
 	{
 	  free ((char *) *IDs);
 	  free ((char *) *sizes);
 	  return (-1);
 	}
 	  free ((char *) *IDs);
 	  free ((char *) *sizes);
 	  return (-1);
 	}
 (*IDs)[0] = atoi (&fromserver[4]);
-fromserver = index (&fromserver[4], ' ');
+fromserver = strchr (&fromserver[4], ' ');
 if (! fromserver)
 	{
 	  strcpy (pop_error,
 		  "Badly formatted response from server in pop_list");
 	  pop_trash (server);
 	      free ((char *) *IDs);
 	      free ((char *) *sizes);
 	      return (-1);
 	    }
 	  (*IDs)[i] = atoi (fromserver);
-	  fromserver = index (fromserver, ' ');
+	  fromserver = strchr (fromserver, ' ');
 	  if (! fromserver)
 	    {
 	      strcpy (pop_error,
 		      "Badly formatted response from server in pop_list");
 	      free ((char *) *IDs);
 * 	null with pop_error set if not.
 *
 * Side effects: May kill connection on error.
 */
 char *
-pop_retrieve (server, message, markfrom)
+pop_retrieve (popserver server, int message, int markfrom)
-popserver server;
-int message;
-int markfrom;
 {
 int *IDs, *sizes, bufsize, fromcount = 0, cp = 0;
 char *ptr, *fromserver;
 int ret;
 	      fromcount = 0;
 	    }
 	  ptr[cp++] = '>';
 	}
 linesize = strlen (fromserver);
-bcopy (fromserver, &ptr[cp], linesize);
+memcpy (&ptr[cp], fromserver, linesize);
 cp += linesize;
 ptr[cp++] = '\n';
 }
 if (ret)
 /* This function used to fall off the end, but that doesn't make any sense */
 return (0);
 }
 int
-pop_retrieve_first (server, message, response)
+pop_retrieve_first (popserver server, int message, char **response)
-popserver server;
-int message;
-char **response;
 {
 sprintf (pop_error, "RETR %d", message);
 return (pop_multi_first (server, pop_error, response));
 }
 int
-pop_retrieve_next (server, line)
+pop_retrieve_next (popserver server, char **line)
-popserver server;
-char **line;
 {
 return (pop_multi_next (server, line));
 }
 int
-pop_retrieve_flush (server)
+pop_retrieve_flush (popserver server)
-popserver server;
 {
 return (pop_multi_flush (server));
 }
 int
-pop_top_first (server, message, lines, response)
+pop_top_first (popserver server, int message, int lines, char **response)
-popserver server;
-int message, lines;
-char **response;
 {
 sprintf (pop_error, "TOP %d %d", message, lines);
 return (pop_multi_first (server, pop_error, response));
 }
 int
-pop_top_next (server, line)
+pop_top_next (popserver server, char **line)
-popserver server;
-char **line;
 {
 return (pop_multi_next (server, line));
 }
 int
-pop_top_flush (server)
+pop_top_flush (popserver server)
-popserver server;
 {
 return (pop_multi_flush (server));
 }
 int
-pop_multi_first (server, command, response)
+pop_multi_first (popserver server, char *command, char **response)
-popserver server;
-char *command;
-char **response;
 {
 if (server->in_multi)
 {
 strcpy (pop_error,
 	      "Already in multi-line query in pop_multi_first");
 return (-1);
 }
-if (sendline (server, command) || (! (*response = getline (server))))
+if (sendline (server, command) || (! (*response = pop_getline (server))))
 {
 return (-1);
 }
 if (0 == strncmp (*response, "-ERR", 4))
 return (-1);
 }
 }
 int
-pop_multi_next (server, line)
+pop_multi_next (popserver server, char **line)
-popserver server;
-char **line;
 {
 char *fromserver;
 if (! server->in_multi)
 {
 strcpy (pop_error, "Not in multi-line query in pop_multi_next");
 return (-1);
 }
-fromserver = getline (server);
+fromserver = pop_getline (server);
 if (! fromserver)
 {
 return (-1);
 }
 return (0);
 }
 }
 int
-pop_multi_flush (server)
+pop_multi_flush (popserver server)
-popserver server;
 {
 char *line;
 if (! server->in_multi)
 {
 *
 * Return value: 0 on success, non-zero with error in pop_error
 * 	otherwise.
 */
 int
-pop_delete (server, message)
+pop_delete (popserver server, int message)
-popserver server;
-int message;
 {
 if (server->in_multi)
 {
 strcpy (pop_error, "In multi-line query in pop_delete");
 return (-1);
 * 	otherwise.
 *
 * Side effects: Closes connection on error.
 */
 int
-pop_noop (server)
+pop_noop (popserver server)
-popserver server;
 {
 if (server->in_multi)
 {
 strcpy (pop_error, "In multi-line query in pop_noop");
 return (-1);
 * 	the error explained in pop_error.
 *
 * Side effects: Closes the connection on error.
 */
 int
-pop_last (server)
+pop_last (popserver server)
-popserver server;
 {
 char *fromserver;
 if (server->in_multi)
 {
 }
 if (sendline (server, "LAST"))
 return (-1);
-if (! (fromserver = getline (server)))
+if (! (fromserver = pop_getline (server)))
 return (-1);
 if (! strncmp (fromserver, "-ERR", 4))
 {
 strncpy (pop_error, fromserver, ERROR_MAX);
 * 	otherwise.
 *
 * Side effects: Closes the connection on error.
 */
 int
-pop_reset (server)
+pop_reset (popserver server)
-popserver server;
 {
 if (pop_retrieve_flush (server))
 {
 return (-1);
 }
 *
 * Side Effects: The popserver passed in is unusable after this
 * 	function is called, even if an error occurs.
 */
 int
-pop_quit (server)
+pop_quit (popserver server)
-popserver server;
 {
 int ret = 0;
 if (server->file >= 0)
 {
 * Return value: A file descriptor indicating the connection, or -1
 * 	indicating failure, in which case an error has been copied
 * 	into pop_error.
 */
 static int
-socket_connection (host, flags)
+socket_connection (char *host, int flags)
-char *host;
-int flags;
 {
 struct hostent *hostent;
 struct servent *servent;
 struct sockaddr_in addr;
 char found_port = 0;
 	  strcpy (pop_error, "Could not determine POP server's address");
 	  return (-1);
 	}
 } while (! hostent);
-bzero ((char *) &addr, sizeof (addr));
+memset (&addr, 0, sizeof (addr));
 addr.sin_family = AF_INET;
 #ifdef KERBEROS
 service = (flags & POP_NO_KERBEROS) ? POP_SERVICE : KPOP_SERVICE;
 #else
 }
 while (*hostent->h_addr_list)
 {
-bcopy (*hostent->h_addr_list, (char *) &addr.sin_addr,
+memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
-	     hostent->h_length);
 if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
 	break;
 hostent->h_addr_list++;
 }
 return (sock);
 } /* socket_connection */
 /*
-* Function: getline
+* Function: pop_getline
 *
 * Purpose: Get a line of text from the connection and return a
 * 	pointer to it.  The carriage return and linefeed at the end of
 * 	the line are stripped, but periods at the beginnings of lines
 * 	are NOT dealt with in any special way.
 * 	server	The server from which to get the line of text.
 *
 * Returns: A non-null pointer if successful, or a null pointer on any
 * 	error, with an error message copied into pop_error.
 *
-* Notes: The line returned is overwritten with each call to getline.
+* Notes: The line returned is overwritten with each call to pop_getline.
 *
 * Side effects: Closes the connection on error.
 */
 static char *
-getline (server)
+pop_getline (popserver server)
-popserver server;
 {
 #define GETLINE_ERROR "Error reading from server: "
 int ret;
 int search_offset = 0;
 	    fprintf (stderr, "<<< %s\n", server->buffer + found);
 	  return (server->buffer + found);
 	}
 else
 	{
-	  bcopy (server->buffer + server->buffer_index,
+	  memcpy (server->buffer,
-		 server->buffer, server->data);
+		  server->buffer + server->buffer_index,
+		  server->data);
 	  /* Record the fact that we've searched the data already in
 the buffer for a CRLF, so that when we search below, we
 don't have to search the same data twice.  There's a "-
 1" here to account for the fact that the last character
 of the data we have may be the CR of a CRLF pair, of
 	{
 	  server->buffer_size += GETLINE_INCR;
 	  server->buffer = (char *)realloc (server->buffer, server->buffer_size);
 	  if (! server->buffer)
 	    {
-	      strcpy (pop_error, "Out of memory in getline");
+	      strcpy (pop_error, "Out of memory in pop_getline");
 	      pop_trash (server);
 	      return (0);
 	    }
 	}
 ret = RECV (server->file, server->buffer + server->data,
 	  pop_trash (server);
 	  return (0);
 	}
 else if (ret == 0)
 	{
-	  strcpy (pop_error, "Unexpected EOF from server in getline");
+	  strcpy (pop_error, "Unexpected EOF from server in pop_getline");
 	  pop_trash (server);
 	  return (0);
 	}
 else
 	{
 * 	an error will be copied into pop_error.
 *
 * Side effects: Closes the connection on error.
 */
 static int
-sendline (server, line)
+sendline (popserver server, char *line)
-popserver server;
-char *line;
 {
 #define SENDLINE_ERROR "Error writing to POP server: "
 int ret;
 ret = fullwrite (server->file, line, strlen (line));
 * 	has been written.
 *
 * Return value: Same as write.  Pop_error is not set.
 */
 static int
-fullwrite (fd, buf, nbytes)
+fullwrite (int fd, char *buf, int nbytes)
-int fd;
-char *buf;
-int nbytes;
 {
 char *cp;
 int ret;
 cp = buf;
 * Returns: 0 for success, else for failure and puts error in pop_error.
 *
 * Side effects: On failure, may make the connection unusable.
 */
 static int
-getok (server)
+getok (popserver server)
-popserver server;
 {
 char *fromline;
-if (! (fromline = getline (server)))
+if (! (fromline = pop_getline (server)))
 {
 return (-1);
 }
 if (! strncmp (fromline, "+OK", 3))
 * Return value: 0 on success, non-zero with pop_error set on error.
 *
 * Side effects: Closes the connection on error.
 */
 static int
-gettermination (server)
+gettermination (popserver server)
-popserver server;
 {
 char *fromserver;
-fromserver = getline (server);
+fromserver = pop_getline (server);
 if (! fromserver)
 return (-1);
 if (strcmp (fromserver, "."))
 {
 * Side effects: The server is unusable after this function returns.
 * 	Changes made to the maildrop since the session was started (or
 * 	since the last pop_reset) may be lost.
 */
 void
-pop_close (server)
+pop_close (popserver server)
-popserver server;
 {
 pop_trash (server);
 free ((char *) server);
 return;
 * Purpose: Like pop_close or pop_quit, but doesn't deallocate the
 * 	memory associated with the server.  It is legal to call
 * 	pop_close or pop_quit after this function has been called.
 */
 static void
-pop_trash (server)
+pop_trash (popserver server)
-popserver server;
 {
 if (server->file >= 0)
 {
 /* avoid recursion; sendline can call pop_trash */
 if (server->trash_started)
 /* Return a pointer to the first CRLF in IN_STRING,
 or 0 if it does not contain one.  */
 static char *
-find_crlf (in_string)
+find_crlf (char *in_string)
-char *in_string;
 {
 while (1)
 {
 if (! *in_string)
 	return (0);

Mercurial > hg > xemacs-beta

comparison lib-src/pop.c @ 272:c5d627a313b1 r21-0b34