-/* Copyright 1993-95 by Carl Harris, Jr. Copyright 1996 by Eric S. Raymond
- * All rights reserved.
+/*
+ * socket.c -- socket library functions
+ *
+ * Copyright 1998 by Eric S. Raymond.
* For license terms, see the file COPYING in this directory.
*/
-/***********************************************************************
- module: socket.c
- project: popclient
- programmer: Carl Harris, ceharris@mal.com
- description: socket library functions
-
- ***********************************************************************/
-
-#include <config.h>
-
-#include <fcntl.h>
+#include "config.h"
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#ifdef HAVE_MEMORY_H
+#include <memory.h>
+#endif /* HAVE_MEMORY_H */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
-#include <sys/time.h>
#if defined(STDC_HEADERS)
-#include <string.h>
+#include <stdlib.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif
-#include <stdlib.h>
+#if defined(HAVE_STDARG_H)
+#include <stdarg.h>
+#else
#include <varargs.h>
-
-#include "bzero.h"
+#endif
#include "socket.h"
+#include "fetchmail.h"
+#include "i18n.h"
+
+/* We need to define h_errno only if it is not already */
+#ifndef h_errno
+
+#ifdef HAVE_RES_SEARCH
+/* some versions of FreeBSD should declare this but don't */
+extern int h_errno;
+#else
+/* pretend we have h_errno to avoid some #ifdef's later */
+static int h_errno;
+#endif
+
+#endif /* ndef h_errno */
+
+#if NET_SECURITY
+#include <net/security.h>
+#endif /* NET_SECURITY */
+
+#ifdef HAVE_SOCKETPAIR
+static int handle_plugin(const char *host,
+ const char *service, const char *plugin)
+/* get a socket mediated through a given external command */
+{
+ int fds[2];
+ if (socketpair(AF_UNIX,SOCK_STREAM,0,fds))
+ {
+ report(stderr, _("fetchmail: socketpair failed\n"));
+ return -1;
+ }
+ switch (fork()) {
+ case -1:
+ /* error */
+ report(stderr, _("fetchmail: fork failed\n"));
+ return -1;
+ break;
+ case 0: /* child */
+ /* fds[1] is the parent's end; close it for proper EOF
+ ** detection */
+ (void) close(fds[1]);
+ if ( (dup2(fds[0],0) == -1) || (dup2(fds[0],1) == -1) ) {
+ report(stderr, _("dup2 failed\n"));
+ exit(1);
+ }
+ /* fds[0] is now connected to 0 and 1; close it */
+ (void) close(fds[0]);
+ if (outlevel >= O_VERBOSE)
+ report(stderr, _("running %s %s %s\n"), plugin, host, service);
+ execlp(plugin,plugin,host,service,0);
+ report(stderr, _("execl(%s) failed\n"), plugin);
+ exit(0);
+ break;
+ default: /* parent */
+ /* NOP */
+ break;
+ }
+ /* fds[0] is the child's end; close it for proper EOF detection */
+ (void) close(fds[0]);
+ return fds[1];
+}
+#endif /* HAVE_SOCKETPAIR */
+
+#ifdef __UNUSED__
+#include <sys/time.h>
-/* Size of buffer for internal buffering read function
- don't increase beyond the maximum atomic read/write size for
- your sockets, or you'll take a potentially huge performance hit */
+int SockCheckOpen(int fd)
+/* poll given socket; is it selectable? */
+{
+ fd_set r, w, e;
+ int rt;
+ struct timeval tv;
+
+ for (;;)
+ {
+ FD_ZERO(&r); FD_ZERO(&w); FD_ZERO(&e);
+ FD_SET(fd, &e);
+
+ tv.tv_sec = 0; tv.tv_usec = 0;
+ rt = select(fd+1, &r, &w, &e, &tv);
+ if (rt == -1 && (errno != EAGAIN && errno != EINTR))
+ return 0;
+ if (rt != -1)
+ return 1;
+ }
+}
+#endif /* __UNUSED__ */
+
+#if INET6
+int SockOpen(const char *host, const char *service, const char *options,
+ const char *plugin)
+{
+ struct addrinfo *ai, req;
+#if NET_SECURITY
+ void *request = NULL;
+ int requestlen;
+#endif /* NET_SECURITY */
+
+#ifdef HAVE_SOCKETPAIR
+ if (plugin)
+ return handle_plugin(host,service,plugin);
+#endif /* HAVE_SOCKETPAIR */
+ memset(&req, 0, sizeof(struct addrinfo));
+ req.ai_socktype = SOCK_STREAM;
+
+ if (getaddrinfo(host, service, &req, &ai)) {
+ report(stderr, _("fetchmail: getaddrinfo(%s.%s)\n"), host,service);
+ return -1;
+ };
+
+#if NET_SECURITY
+ if (!options)
+ requestlen = 0;
+ else
+ if (net_security_strtorequest((char *)options, &request, &requestlen))
+ goto ret;
+
+ i = inner_connect(ai, request, requestlen, NULL, NULL, "fetchmail", NULL);
+ if (request)
+ free(request);
-#define INTERNAL_BUFSIZE 2048
+ ret:
+#else /* NET_SECURITY */
+ i = inner_connect(ai, NULL, 0, NULL, NULL, "fetchmail", NULL);
+#endif /* NET_SECURITY */
+ freeaddrinfo(ai);
-int Socket(host, clientPort)
-char *host;
-int clientPort;
+ return i;
+};
+#else /* INET6 */
+#ifndef HAVE_INET_ATON
+#ifndef INADDR_NONE
+#ifdef INADDR_BROADCAST
+#define INADDR_NONE INADDR_BROADCAST
+#else
+#define INADDR_NONE -1
+#endif
+#endif
+#endif /* HAVE_INET_ATON */
+
+int SockOpen(const char *host, int clientPort, const char *options,
+ const char *plugin)
{
- int sock;
+ int sock = -1; /* pacify -Wall */
+#ifndef HAVE_INET_ATON
unsigned long inaddr;
- struct sockaddr_in ad;
+#endif /* HAVE_INET_ATON */
+ struct sockaddr_in ad, **pptr;
struct hostent *hp;
-
+
+#ifdef HAVE_SOCKETPAIR
+ if (plugin) {
+ char buf[10];
+ sprintf(buf,"%d",clientPort);
+ return handle_plugin(host,buf,plugin);
+ }
+#endif /* HAVE_SOCKETPAIR */
+
memset(&ad, 0, sizeof(ad));
ad.sin_family = AF_INET;
+ /* we'll accept a quad address */
+#ifndef HAVE_INET_ATON
inaddr = inet_addr(host);
if (inaddr != INADDR_NONE)
memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));
else
+#else
+ if (!inet_aton(host, &ad.sin_addr))
+#endif /* HAVE_INET_ATON */
{
hp = gethostbyname(host);
+
if (hp == NULL)
- return -1;
- memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);
+ {
+ errno = 0;
+ return -1;
+ }
+ /*
+ * Add a check to make sure the address has a valid IPv4 or IPv6
+ * length. This prevents buffer spamming by a broken DNS.
+ */
+ if(hp->h_length != 4 && hp->h_length != 8)
+ {
+ h_errno = errno = 0;
+ report(stderr,
+ _("fetchmail: illegal address length received for host %s\n"),host);
+ return -1;
+ }
+ /*
+ * Try all addresses of a possibly multihomed host until we get
+ * a successful connect or until we run out of addresses.
+ */
+ pptr = (struct sockaddr_in **)hp->h_addr_list;
+ for(; *pptr != NULL; pptr++)
+ {
+ sock = socket(AF_INET, SOCK_STREAM, 0);
+ if (sock < 0)
+ {
+ h_errno = 0;
+ return -1;
+ }
+ ad.sin_port = htons(clientPort);
+ memcpy(&ad.sin_addr, *pptr, sizeof(struct in_addr));
+ if (connect(sock, (struct sockaddr *) &ad, sizeof(ad)) == 0)
+ break; /* success */
+ close(sock);
+ memset(&ad, 0, sizeof(ad));
+ ad.sin_family = AF_INET;
+ }
+ if(*pptr == NULL)
+ {
+ int olderr = errno;
+ close(sock);
+ h_errno = 0;
+ errno = olderr;
+ return -1;
+ }
}
- ad.sin_port = htons(clientPort);
-
- sock = socket(AF_INET, SOCK_STREAM, 0);
- if (sock < 0)
- return sock;
- if (connect(sock, (struct sockaddr *) &ad, sizeof(ad)) < 0)
- return -1;
- return sock;
+ return(sock);
}
+#endif /* INET6 */
-int SockGets(socket,buf,len)
-int socket;
-char *buf;
-int len;
-{
- while (--len)
- {
- if (SockInternalRead(socket, buf, 1) != 1)
- return -1;
- if (*buf == '\n')
- break;
- if (*buf != '\r') /* remove all CRs */
- buf++;
- }
- *buf = 0;
- return 0;
-}
-int SockPuts(socket,buf)
-int socket;
-char *buf;
+#if defined(HAVE_STDARG_H)
+int SockPrintf(int sock, const char* format, ...)
{
- int rc;
-
- if (rc = SockWrite(socket, buf, strlen(buf)))
- return rc;
- return SockWrite(socket, "\r\n", 2);
+#else
+int SockPrintf(sock,format,va_alist)
+int sock;
+char *format;
+va_dcl {
+#endif
+
+ va_list ap;
+ char buf[8192];
+
+#if defined(HAVE_STDARG_H)
+ va_start(ap, format) ;
+#else
+ va_start(ap);
+#endif
+#ifdef HAVE_VSNPRINTF
+ vsnprintf(buf, sizeof(buf), format, ap);
+#else
+ vsprintf(buf, format, ap);
+#endif
+ va_end(ap);
+ return SockWrite(sock, buf, strlen(buf));
+
}
-int SockWrite(socket,buf,len)
-int socket;
-char *buf;
-int len;
+int SockWrite(int sock, char *buf, int len)
{
- int n;
-
+ int n, wrlen = 0;
+
while (len)
{
- n = write(socket, buf, len);
+ n = write(sock, buf, len);
if (n <= 0)
return -1;
len -= n;
- buf += n;
+ wrlen += n;
+ buf += n;
}
- return 0;
+ return wrlen;
}
-int SockRead(socket,buf,len)
-int socket;
-char *buf;
-int len;
+int SockRead(int sock, char *buf, int len)
{
+ char *newline, *bp = buf;
int n;
-
- while (len)
- {
- n = SockInternalRead(socket, buf, len);
- if (n <= 0)
- return -1;
- len -= n;
- buf += n;
- }
- return 0;
+
+ if (--len < 1)
+ return(-1);
+ do {
+ /*
+ * The reason for these gymnastics is that we want two things:
+ * (1) to read \n-terminated lines,
+ * (2) to return the true length of data read, even if the
+ * data coming in has embedded NULS.
+ */
+ if ((n = recv(sock, bp, len, MSG_PEEK)) <= 0)
+ return(-1);
+ if ((newline = memchr(bp, '\n', n)) != NULL)
+ n = newline - bp + 1;
+ if ((n = read(sock, bp, n)) == -1)
+ return(-1);
+ bp += n;
+ len -= n;
+ } while
+ (!newline && len);
+ *bp = '\0';
+ return bp - buf;
}
-int SockInternalRead (socket,buf,len)
-int socket;
-char *buf;
-int len;
+int SockPeek(int sock)
+/* peek at the next socket character without actually reading it */
{
- static int sbuflen = 0;
- static char sbuf [INTERNAL_BUFSIZE];
- static char *bp;
-
- if (sbuflen == 0) {
- /* buffer is empty; refresh. */
- if ((sbuflen = read(socket,sbuf,INTERNAL_BUFSIZE)) < 0) {
- perror("SockInternalRead: read");
- exit(9);
- }
- else
- bp = sbuf;
- }
- else
- ; /* already some data in the buffer */
-
- /* can't get more than we have right now. */
- /* XXX -- should probably try to load any unused part of sbuf
- so that as much of 'len' as possible can be satisfied */
- if (len > sbuflen)
- len = sbuflen;
- else
- ; /* wants no more than we already have */
-
- /* transfer to caller's buffer */
- if (len == 1) {
- /* special case: if caller only wants one character, it probably
- costs a lot more to call bcopy than to do it ourselves. */
- *buf = *(bp++);
- sbuflen--;
- }
- else {
- bcopy(bp,buf,len);
- sbuflen -= len;
- bp += len;
- }
- return(len);
+ int n;
+ char ch;
+
+ if ((n = recv(sock, &ch, 1, MSG_PEEK)) == -1)
+ return -1;
+ else
+ return(ch);
}
+int SockClose(int sock)
+/* close a socket (someday we may do other cleanup here) */
+{
+ return(close(sock));
+}
-int SockPrintf(socket,format,va_alist)
-int socket;
-char *format;
-va_dcl {
+#ifdef MAIN
+/*
+ * Use the chargen service to test input buffering directly.
+ * You may have to uncomment the `chargen' service description in your
+ * inetd.conf (and then SIGHUP inetd) for this to work.
+ */
+main()
+{
+ int sock = SockOpen("localhost", 19, NULL);
+ char buf[80];
- va_list ap;
- char buf[8192];
-
- va_start(ap);
- vsprintf(buf, format, ap);
- va_end(ap);
- return SockWrite(socket, buf, strlen(buf));
+ while (SockRead(sock, buf, sizeof(buf)-1))
+ SockWrite(1, buf, strlen(buf));
+ SockClose(sock);
}
+#endif /* MAIN */
+
+/* socket.c ends here */
projects / ~andy / fetchmail / blobdiff