bughz/tinyproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Also moved safe_write(), safe_read(), readline(), and write_message()
functions into their own file.
This commit is contained in:
Robert James Kaes 2002-05-23 18:25:55 +00:00
parent 47ab97a347
commit 478030c6ff
2 changed files with 70 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
src/sock.c
View File

@ -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 * 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 * a client, we need to copy the socket and the create a second socket to the
@ -23,18 +23,11 @@
#include "tinyproxy.h" #include "tinyproxy.h"
#include "dnsclient.h"
#include "log.h" #include "log.h"
#include "heap.h"
#include "sock.h" #include "sock.h"
#include "utils.h" #include "text.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);
/* /*
* Take a string host address and return a struct in_addr so we can connect * 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 static int
lookup_domain(struct in_addr *addr, const char *domain) lookup_domain(struct in_addr *addr, const char *domain)
{ {
struct hostent *resolv; struct in_addr *addresses;
int dns;
if (!addr || !domain)
dns = dns_connect();
if (dns < 0)
return -1; return -1;
/* if (dns_getaddrbyname(dns, domain, &addresses) < 0) {
* Okay, it's an alpha-numeric domain, so look it up. dns_disconnect(dns);
*/
LOCK();
if (!(resolv = gethostbyname(domain))) {
UNLOCK();
return -1; return -1;
} }
memcpy(addr, resolv->h_addr_list[0], resolv->h_length); memcpy(addr, addresses, sizeof(addr));
UNLOCK(); dns_disconnect(dns);
safefree(addresses);
return 0; return 0;
} }
@ -208,6 +199,46 @@ listen_sock(uint16_t port, socklen_t * addrlen)
return listenfd; return listenfd;
} }
/*
* Return the peer's socket information.
*/
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);
/*
* Clear the memory.
*/
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_information: getpeername() error: %s",
strerror(errno));
return -1;
} else {
strlcpy(ipaddr,
inet_ntoa(*(struct in_addr *)&name.sin_addr.s_addr),
PEER_IP_LENGTH);
}
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 contain the peer's * Takes a socket descriptor and returns the string contain the peer's
* IP address. * IP address.
@ -245,9 +276,9 @@ getpeer_ip(int fd, char *ipaddr)
char * char *
getpeer_string(int fd, char *string) getpeer_string(int fd, char *string)
{ {
struct sockaddr_in name; int dns;
size_t namelen = sizeof(name); char peer_ip_buffer[PEER_IP_LENGTH];
struct hostent *peername;
assert(fd >= 0); assert(fd >= 0);
assert(string != NULL); assert(string != NULL);
@ -257,237 +288,18 @@ getpeer_string(int fd, char *string)
*/ */
*string = '\0'; *string = '\0';
if (getpeername(fd, (struct sockaddr *) &name, &namelen) != 0) { return string;
log_message(LOG_ERR,
"getpeer_string: 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(); getpeer_ip(fd, peer_ip_buffer);
dns = connect_to_dns();
if (dns < 0) {
return string;
} }
dns_gethostbyaddr(dns, peer_ip_buffer, &string, PEER_STRING_LENGTH);
shutdown_dns_connection(dns);
return string; return string;
} }
/* #endif
* 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;
}
return count;
}
/*
* Matched pair for safe_write(). If an EINTR occurs, pick up and try
* again.
*/
ssize_t
safe_read(int fd, char *buffer, size_t count)
{
ssize_t len;
do {
len = read(fd, buffer, count);
} while (len < 0 && errno == EINTR);
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;
if ((buf = safemalloc(size)) == NULL)
return -1;
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;
}
if (safe_write(fd, buf, n) < 0) {
DEBUG2("Error in write_message(): %d", fd);
safefree(buf);
return -1;
}
safefree(buf);
return 0;
}
/*
* 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;
}

13
src/sock.h
View File

@ -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. * See 'sock.c' for a detailed description.
* *
@ -19,8 +19,6 @@
#ifndef TINYPROXY_SOCK_H #ifndef TINYPROXY_SOCK_H
#define TINYPROXY_SOCK_H #define TINYPROXY_SOCK_H
#include "tinyproxy.h"
#define PEER_IP_LENGTH 16 #define PEER_IP_LENGTH 16
#define PEER_STRING_LENGTH 256 #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_nonblocking(int sock);
extern int socket_blocking(int sock); extern int socket_blocking(int sock);
extern char *getpeer_ip(int fd, char *ipaddr); extern int getpeer_information(int fd, char* ipaddr, char* string_addr);
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);
#endif #endif