Changed the lookup_domain() function to use the new "dnsserver" API.

Also moved safe_write(), safe_read(), readline(), and write_message()
functions into their own file.

2 files changed, 69 insertions, 266 deletions

diff --git a/src/sock.c b/src/sock.c
index dd5df1d..c364666 100644
--- a/src/sock.c
+++ b/src/sock.c
@@ -1,4 +1,4 @@
-/* $Id: sock.c,v 1.33 2002-04-24 16:48:34 rjkaes Exp $
+/* $Id: sock.c,v 1.34 2002-05-23 18:25:55 rjkaes Exp $
  *
  * Sockets are created and destroyed here. When a new connection comes in from
  * a client, we need to copy the socket and the create a second socket to the
@@ -23,18 +23,11 @@
 
 #include "tinyproxy.h"
 
+#include "dnsclient.h"
 #include "log.h"
+#include "heap.h"
 #include "sock.h"
-#include "utils.h"
-
-/*
- * The mutex is used for locking around any calls which access global
- * variables.
- *	- rjkaes
- */
-static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-#define LOCK()   pthread_mutex_lock(&mutex);
-#define UNLOCK() pthread_mutex_unlock(&mutex);
+#include "text.h"
 
 /*
  * Take a string host address and return a struct in_addr so we can connect
@@ -44,25 +37,23 @@ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  */
 static int
 lookup_domain(struct in_addr *addr, const char *domain)
-{
-	struct hostent *resolv;
-
-	if (!addr || !domain)
+{	
+	struct in_addr *addresses;
+	int dns;
+	
+	dns = dns_connect();
+	if (dns < 0)
 		return -1;
 
-	/*
-	 * Okay, it's an alpha-numeric domain, so look it up.
-	 */
-	LOCK();
-	if (!(resolv = gethostbyname(domain))) {
-		UNLOCK();
+	if (dns_getaddrbyname(dns, domain, &addresses) < 0) {
+		dns_disconnect(dns);
 		return -1;
 	}
 
-	memcpy(addr, resolv->h_addr_list[0], resolv->h_length);
-
-	UNLOCK();
-
+	memcpy(addr, addresses, sizeof(addr));
+	
+	dns_disconnect(dns);
+	safefree(addresses);
 	return 0;
 }
 
@@ -209,285 +200,106 @@ listen_sock(uint16_t port, socklen_t * addrlen)
 }
 
 /*
- * Takes a socket descriptor and returns the string contain the peer's
- * IP address.
+ * Return the peer's socket information.
  */
-char *
-getpeer_ip(int fd, char *ipaddr)
+int
+getpeer_information(int fd, char* ipaddr, char* string_addr)
 {
 	struct sockaddr_in name;
 	size_t namelen = sizeof(name);
+	int dns;
 
 	assert(fd >= 0);
 	assert(ipaddr != NULL);
+	assert(string_addr != NULL);
 
 	/*
-	 * Make sure the user's buffer is initialized to an empty string.
+	 * Clear the memory.
 	 */
-	*ipaddr = '\0';
+	memset(ipaddr, '\0', PEER_IP_LENGTH);
+	memset(string_addr, '\0', PEER_STRING_LENGTH);
 
-	if (getpeername(fd, (struct sockaddr *) &name, &namelen) != 0) {
-		log_message(LOG_ERR, "getpeer_ip: getpeername() error \"%s\".",
+	if (getpeername(fd, (struct sockaddr *)&name, &namelen) != 0) {
+		log_message(LOG_ERR, "getpeer_information: getpeername() error: %s",
 			    strerror(errno));
+		return -1;
 	} else {
 		strlcpy(ipaddr,
-			inet_ntoa(*(struct in_addr *) &name.sin_addr.s_addr),
+			inet_ntoa(*(struct in_addr *)&name.sin_addr.s_addr),
 			PEER_IP_LENGTH);
 	}
 
-	return ipaddr;
+	dns = dns_connect();
+	if (dns < 0)
+		return -1;
+	dns_gethostbyaddr(dns, ipaddr, &string_addr, PEER_STRING_LENGTH);
+	dns_disconnect(dns);
+       
+	return 0;
 }
 
+#if 0
 /*
- * Takes a socket descriptor and returns the string containing the peer's
- * address.
+ * Takes a socket descriptor and returns the string contain the peer's
+ * IP address.
  */
 char *
-getpeer_string(int fd, char *string)
+getpeer_ip(int fd, char *ipaddr)
 {
 	struct sockaddr_in name;
 	size_t namelen = sizeof(name);
-	struct hostent *peername;
 
 	assert(fd >= 0);
-	assert(string != NULL);
+	assert(ipaddr != NULL);
 
 	/*
 	 * Make sure the user's buffer is initialized to an empty string.
 	 */
-	*string = '\0';
+	*ipaddr = '\0';
 
 	if (getpeername(fd, (struct sockaddr *) &name, &namelen) != 0) {
-		log_message(LOG_ERR,
-			    "getpeer_string: getpeername() error \"%s\".",
+		log_message(LOG_ERR, "getpeer_ip: getpeername() error \"%s\".",
 			    strerror(errno));
 	} else {
-		LOCK();
-		peername = gethostbyaddr((char *) &name.sin_addr.s_addr,
-					 sizeof(name.sin_addr.s_addr), AF_INET);
-		if (peername)
-			strlcpy(string, peername->h_name, PEER_STRING_LENGTH);
-		else
-			log_message(LOG_ERR,
-				    "getpeer_string: gethostbyaddr() error");
-
-		UNLOCK();
-	}
-
-	return string;
-}
-
-/*
- * Write the buffer to the socket. If an EINTR occurs, pick up and try
- * again. Keep sending until the buffer has been sent.
- */
-ssize_t
-safe_write(int fd, const char *buffer, size_t count)
-{
-	ssize_t len;
-	size_t bytestosend;
-
-	assert(fd >= 0);
-	assert(buffer != NULL);
-	assert(count > 0);
-
-	bytestosend = count;
-
-	while (1) {
-		len = send(fd, buffer, bytestosend, MSG_NOSIGNAL);
-
-		if (len < 0) {
-			if (errno == EINTR)
-				continue;
-			else
-				return -errno;
-		}
-
-		if (len == bytestosend)
-			break;
-
-		buffer += len;
-		bytestosend -= len;
+		strlcpy(ipaddr,
+			inet_ntoa(*(struct in_addr *) &name.sin_addr.s_addr),
+			PEER_IP_LENGTH);
 	}
 
-	return count;
+	return ipaddr;
 }
 
 /*
- * Matched pair for safe_write(). If an EINTR occurs, pick up and try
- * again.
+ * Takes a socket descriptor and returns the string containing the peer's
+ * address.
  */
-ssize_t
-safe_read(int fd, char *buffer, size_t count)
+char *
+getpeer_string(int fd, char *string)
 {
-	ssize_t len;
-
-	do {
-		len = read(fd, buffer, count);
-	} while (len < 0 && errno == EINTR);
+	int dns;
+	char peer_ip_buffer[PEER_IP_LENGTH];
 
-	return len;
-}
 
-/*
- * Send a "message" to the file descriptor provided. This handles the
- * differences between the various implementations of vsnprintf. This code
- * was basically stolen from the snprintf() man page of Debian Linux
- * (although I did fix a memory leak. :)
- */
-int
-write_message(int fd, const char *fmt, ...)
-{
-	ssize_t n;
-	size_t size = (1024 * 8);	/* start with 8 KB and go from there */
-	char *buf, *tmpbuf;
-	va_list ap;
+	assert(fd >= 0);
+	assert(string != NULL);
 
-	if ((buf = safemalloc(size)) == NULL)
-		return -1;
+	/*
+	 * Make sure the user's buffer is initialized to an empty string.
+	 */
+	*string = '\0';
 
-	while (1) {
-		va_start(ap, fmt);
-		n = vsnprintf(buf, size, fmt, ap);
-		va_end(ap);
-
-		/* If that worked, break out so we can send the buffer */
-		if (n > -1 && n < size)
-			break;
-
-		/* Else, try again with more space */
-		if (n > -1)
-			/* precisely what is needed (glibc2.1) */
-			size = n + 1;
-		else
-			/* twice the old size (glibc2.0) */
-			size *= 2;
-
-		if ((tmpbuf = saferealloc(buf, size)) == NULL) {
-			safefree(buf);
-			return -1;
-		} else
-			buf = tmpbuf;
-	}
+	return string;
 
-	if (safe_write(fd, buf, n) < 0) {
-		DEBUG2("Error in write_message(): %d", fd);
+	getpeer_ip(fd, peer_ip_buffer);
 
-		safefree(buf);
-		return -1;
+	dns = connect_to_dns();
+	if (dns < 0) {
+		return string;
 	}
+	dns_gethostbyaddr(dns, peer_ip_buffer, &string, PEER_STRING_LENGTH);
+	shutdown_dns_connection(dns);
 
-	safefree(buf);
-	return 0;
+	return string;
 }
 
-/*
- * Read in a "line" from the socket. It might take a few loops through
- * the read sequence. The full string is allocate off the heap and stored
- * at the whole_buffer pointer. The caller needs to free the memory when
- * it is no longer in use. The returned line is NULL terminated.
- *
- * Returns the length of the buffer on success (not including the NULL
- * termination), 0 if the socket was closed, and -1 on all other errors.
- */
-#define SEGMENT_LEN (512)
-#define MAXIMUM_BUFFER_LENGTH (128 * 1024)
-ssize_t
-readline(int fd, char **whole_buffer)
-{
-	ssize_t whole_buffer_len;
-	char buffer[SEGMENT_LEN];
-	char *ptr;
-
-	ssize_t ret;
-	ssize_t diff;
-
-	struct read_lines_s {
-		char *data;
-		size_t len;
-		struct read_lines_s *next;
-	};
-	struct read_lines_s *first_line, *line_ptr;
-
-	first_line = safecalloc(sizeof(struct read_lines_s), 1);
-	if (!first_line)
-		return -ENOMEMORY;
-
-	line_ptr = first_line;
-
-	whole_buffer_len = 0;
-	for (;;) {
-		ret = recv(fd, buffer, SEGMENT_LEN, MSG_PEEK);
-		if (ret <= 0)
-			goto CLEANUP;
-
-		ptr = memchr(buffer, '\n', ret);
-		if (ptr)
-			diff = ptr - buffer + 1;
-		else
-			diff = ret;
-
-		whole_buffer_len += diff;
-
-		/*
-		 * Don't allow the buffer to grow without bound. If we
-		 * get to more than MAXIMUM_BUFFER_LENGTH close.
-		 */
-		if (whole_buffer_len > MAXIMUM_BUFFER_LENGTH) {
-			ret = -EOUTRANGE;
-			goto CLEANUP;
-		}
-
-		line_ptr->data = safemalloc(diff);
-		if (!line_ptr->data) {
-			ret = -ENOMEMORY;
-			goto CLEANUP;
-		}
-
-		recv(fd, line_ptr->data, diff, 0);
-		line_ptr->len = diff;
-
-		if (ptr) {
-			line_ptr->next = NULL;
-			break;
-		}
-
-		line_ptr->next = safecalloc(sizeof(struct read_lines_s), 1);
-		if (!line_ptr->next) {
-			ret = -ENOMEMORY;
-			goto CLEANUP;
-		}
-		line_ptr = line_ptr->next;
-	}
-
-	*whole_buffer = safemalloc(whole_buffer_len + 1);
-	if (!*whole_buffer) {
-		ret = -ENOMEMORY;
-		goto CLEANUP;
-	}
-
-	*(*whole_buffer + whole_buffer_len) = '\0';
-
-	whole_buffer_len = 0;
-	line_ptr = first_line;
-	while (line_ptr) {
-		memcpy(*whole_buffer + whole_buffer_len, line_ptr->data,
-		       line_ptr->len);
-		whole_buffer_len += line_ptr->len;
-
-		line_ptr = line_ptr->next;
-	}
-
-	ret = whole_buffer_len;
-
-      CLEANUP:
-	do {
-		line_ptr = first_line->next;
-		if (first_line->data)
-			safefree(first_line->data);
-		safefree(first_line);
-		first_line = line_ptr;
-	} while (first_line);
-
-	return ret;
-}
+#endif
diff --git a/src/sock.h b/src/sock.h
index 67a8200..7d0f79e 100644
--- a/src/sock.h
+++ b/src/sock.h
@@ -1,4 +1,4 @@
-/* $Id: sock.h,v 1.9 2001-12-24 00:01:32 rjkaes Exp $
+/* $Id: sock.h,v 1.10 2002-05-23 18:25:55 rjkaes Exp $
  *
  * See 'sock.c' for a detailed description.
  *
@@ -19,8 +19,6 @@
 #ifndef TINYPROXY_SOCK_H
 #define TINYPROXY_SOCK_H
 
-#include "tinyproxy.h"
-
 #define PEER_IP_LENGTH		16
 #define PEER_STRING_LENGTH	256
 
@@ -32,13 +30,6 @@ extern int listen_sock(uint16_t port, socklen_t * addrlen);
 extern int socket_nonblocking(int sock);
 extern int socket_blocking(int sock);
 
-extern char *getpeer_ip(int fd, char *ipaddr);
-extern char *getpeer_string(int fd, char *string);
-
-extern ssize_t safe_write(int fd, const char *buffer, size_t count);
-extern ssize_t safe_read(int fd, char *buffer, size_t count);
-
-extern int write_message(int fd, const char *fmt, ...);
-extern ssize_t readline(int fd, char **whole_buffer);
+extern int getpeer_information(int fd, char* ipaddr, char* string_addr);
 
 #endif