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

Reformat code to GNU coding style

Browse Source 
This is a commit which simply ran all C source code files
through GNU indent. No other modifications were made.
This commit is contained in:
Mukund Sivaraman 2008-12-01 15:01:11 +00:00
parent 448c19077c
commit a257703e59
47 changed files with 4909 additions and 4566 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

447
src/acl.c
View File

@ -33,23 +33,27 @@
/* Define how long an IPv6 address is in bytes (128 bits, 16 bytes) */ /* Define how long an IPv6 address is in bytes (128 bits, 16 bytes) */
#define IPV6_LEN 16 #define IPV6_LEN 16
enum acl_type { ACL_STRING, ACL_NUMERIC }; enum acl_type
{ ACL_STRING, ACL_NUMERIC };
/* /*
* Hold the information about a particular access control. We store * Hold the information about a particular access control. We store
* whether it's an ALLOW or DENY entry, and also whether it's a string * whether it's an ALLOW or DENY entry, and also whether it's a string
* entry (like a domain name) or an IP entry. * entry (like a domain name) or an IP entry.
*/ */
struct acl_s { struct acl_s
acl_access_t access; {
enum acl_type type; acl_access_t access;
union { enum acl_type type;
char *string; union
struct { {
unsigned char octet[IPV6_LEN]; char *string;
unsigned char mask[IPV6_LEN]; struct
} ip; {
} address; unsigned char octet[IPV6_LEN];
unsigned char mask[IPV6_LEN];
} ip;
} address;
}; };
/* /*
@ -67,41 +71,45 @@ static vector_t access_list = NULL;
* *
*/ */
inline static int inline static int
fill_netmask_array(char *bitmask_string, unsigned char array[], unsigned int len) fill_netmask_array (char *bitmask_string, unsigned char array[],
unsigned int len)
{ {
unsigned int i; unsigned int i;
long int mask; long int mask;
char *endptr; char *endptr;
errno = 0; /* to distinguish success/failure after call */ errno = 0; /* to distinguish success/failure after call */
mask = strtol(bitmask_string, &endptr, 10); mask = strtol (bitmask_string, &endptr, 10);
/* check for various conversion errors */ /* check for various conversion errors */
if ((errno == ERANGE && (mask == LONG_MIN || mask == LONG_MAX)) if ((errno == ERANGE && (mask == LONG_MIN || mask == LONG_MAX))
|| (errno != 0 && mask == 0) || (errno != 0 && mask == 0) || (endptr == bitmask_string))
|| (endptr == bitmask_string)) return -1;
return -1;
/* valid range for a bit mask */ /* valid range for a bit mask */
if (mask < 0 || mask > (8 * len)) if (mask < 0 || mask > (8 * len))
return -1; return -1;
/* we have a valid range to fill in the array */ /* we have a valid range to fill in the array */
for (i = 0; i != len; ++i) { for (i = 0; i != len; ++i)
if (mask >= 8) { {
array[i] = 0xff; if (mask >= 8)
mask -= 8; {
} array[i] = 0xff;
else if (mask > 0) { mask -= 8;
array[i] = (unsigned char)(0xff << (8 - mask)); }
mask = 0; else if (mask > 0)
} {
else { array[i] = (unsigned char) (0xff << (8 - mask));
array[i] = 0; mask = 0;
} }
} else
{
array[i] = 0;
}
}
return 0; return 0;
} }
@ -115,74 +123,82 @@ fill_netmask_array(char *bitmask_string, unsigned char array[], unsigned int len
* 0 otherwise. * 0 otherwise.
*/ */
int int
insert_acl(char *location, acl_access_t access_type) insert_acl (char *location, acl_access_t access_type)
{ {
struct acl_s acl; struct acl_s acl;
int ret; int ret;
char *p, ip_dst[IPV6_LEN]; char *p, ip_dst[IPV6_LEN];
assert(location != NULL); assert (location != NULL);
/* /*
* If the access list has not been set up, create it. * If the access list has not been set up, create it.
*/ */
if (!access_list) { if (!access_list)
access_list = vector_create(); {
if (!access_list) { access_list = vector_create ();
log_message(LOG_ERR, if (!access_list)
"Unable to allocate memory for access list"); {
return -1; log_message (LOG_ERR, "Unable to allocate memory for access list");
} return -1;
} }
}
/* /*
* Start populating the access control structure. * Start populating the access control structure.
*/ */
memset(&acl, 0, sizeof(struct acl_s)); memset (&acl, 0, sizeof (struct acl_s));
acl.access = access_type; acl.access = access_type;
/* /*
* Check for a valid IP address (the simplest case) first. * Check for a valid IP address (the simplest case) first.
*/ */
if (full_inet_pton(location, ip_dst) > 0) { if (full_inet_pton (location, ip_dst) > 0)
acl.type = ACL_NUMERIC; {
memcpy(acl.address.ip.octet, ip_dst, IPV6_LEN); acl.type = ACL_NUMERIC;
memset(acl.address.ip.mask, 0xff, IPV6_LEN); memcpy (acl.address.ip.octet, ip_dst, IPV6_LEN);
} else { memset (acl.address.ip.mask, 0xff, IPV6_LEN);
/* }
* At this point we're either a hostname or an else
* IP address with a slash. {
*/ /*
p = strchr(location, '/'); * At this point we're either a hostname or an
if (p != NULL) { * IP address with a slash.
/* */
* We have a slash, so it's intended to be an p = strchr (location, '/');
* IP address with mask if (p != NULL)
*/ {
*p = '\0'; /*
if (full_inet_pton(location, ip_dst) <= 0) * We have a slash, so it's intended to be an
return -1; * IP address with mask
*/
*p = '\0';
if (full_inet_pton (location, ip_dst) <= 0)
return -1;
acl.type = ACL_NUMERIC; acl.type = ACL_NUMERIC;
memcpy(acl.address.ip.octet, ip_dst, IPV6_LEN); memcpy (acl.address.ip.octet, ip_dst, IPV6_LEN);
if (fill_netmask_array(p + 1, &(acl.address.ip.mask[0]), IPV6_LEN) < 0) if (fill_netmask_array (p + 1, &(acl.address.ip.mask[0]), IPV6_LEN)
return -1; < 0)
} else { return -1;
/* In all likelihood a string */ }
acl.type = ACL_STRING; else
acl.address.string = safestrdup(location); {
if (!acl.address.string) /* In all likelihood a string */
return -1; acl.type = ACL_STRING;
} acl.address.string = safestrdup (location);
} if (!acl.address.string)
return -1;
}
}
/* /*
* Add the entry and then clean up. * Add the entry and then clean up.
*/ */
ret = vector_append(access_list, &acl, sizeof(struct acl_s)); ret = vector_append (access_list, &acl, sizeof (struct acl_s));
safefree(acl.address.string); safefree (acl.address.string);
return ret; return ret;
} }
/* /*
@ -195,73 +211,79 @@ insert_acl(char *location, acl_access_t access_type)
* -1 if no tests match, so skip * -1 if no tests match, so skip
*/ */
static int static int
acl_string_processing(struct acl_s *acl, acl_string_processing (struct acl_s *acl,
const char *ip_address, const char *string_address) const char *ip_address, const char *string_address)
{ {
int match; int match;
struct addrinfo hints, *res, *ressave; struct addrinfo hints, *res, *ressave;
size_t test_length, match_length; size_t test_length, match_length;
char ipbuf[512]; char ipbuf[512];
assert(acl && acl->type == ACL_STRING); assert (acl && acl->type == ACL_STRING);
assert(ip_address && strlen(ip_address) > 0); assert (ip_address && strlen (ip_address) > 0);
assert(string_address && strlen(string_address) > 0); assert (string_address && strlen (string_address) > 0);
/* /*
* If the first character of the ACL string is a period, we need to * If the first character of the ACL string is a period, we need to
* do a string based test only; otherwise, we can do a reverse * do a string based test only; otherwise, we can do a reverse
* lookup test as well. * lookup test as well.
*/ */
if (acl->address.string[0] != '.') { if (acl->address.string[0] != '.')
memset(&hints, 0, sizeof(struct addrinfo)); {
hints.ai_family = AF_UNSPEC; memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_socktype = SOCK_STREAM; hints.ai_family = AF_UNSPEC;
if (getaddrinfo(acl->address.string, NULL, &hints, &res) != 0) hints.ai_socktype = SOCK_STREAM;
goto STRING_TEST; if (getaddrinfo (acl->address.string, NULL, &hints, &res) != 0)
goto STRING_TEST;
ressave = res; ressave = res;
match = FALSE; match = FALSE;
do { do
get_ip_string(res->ai_addr, ipbuf, sizeof(ipbuf)); {
if (strcmp(ip_address, ipbuf) == 0) { get_ip_string (res->ai_addr, ipbuf, sizeof (ipbuf));
match = TRUE; if (strcmp (ip_address, ipbuf) == 0)
break; {
} match = TRUE;
} while ((res = res->ai_next) != NULL); break;
}
}
while ((res = res->ai_next) != NULL);
freeaddrinfo(ressave); freeaddrinfo (ressave);
if (match) { if (match)
if (acl->access == ACL_DENY) {
return 0; if (acl->access == ACL_DENY)
else return 0;
return 1; else
} return 1;
} }
}
STRING_TEST: STRING_TEST:
test_length = strlen(string_address); test_length = strlen (string_address);
match_length = strlen(acl->address.string); match_length = strlen (acl->address.string);
/* /*
* If the string length is shorter than AC string, return a -1 so * If the string length is shorter than AC string, return a -1 so
* that the "driver" will skip onto the next control in the list. * that the "driver" will skip onto the next control in the list.
*/ */
if (test_length < match_length) if (test_length < match_length)
return -1; return -1;
if (strcasecmp if (strcasecmp
(string_address + (test_length - match_length), (string_address + (test_length - match_length),
acl->address.string) == 0) { acl->address.string) == 0)
if (acl->access == ACL_DENY) {
return 0; if (acl->access == ACL_DENY)
else return 0;
return 1; else
} return 1;
}
/* Indicate that no tests succeeded, so skip to next control. */ /* Indicate that no tests succeeded, so skip to next control. */
return -1; return -1;
} }
/* /*
@ -273,28 +295,29 @@ acl_string_processing(struct acl_s *acl,
* -1 neither allowed nor denied. * -1 neither allowed nor denied.
*/ */
static int static int
check_numeric_acl(const struct acl_s *acl, const char *ip) check_numeric_acl (const struct acl_s *acl, const char *ip)
{ {
uint8_t addr[IPV6_LEN], x, y; uint8_t addr[IPV6_LEN], x, y;
int i; int i;
assert(acl && acl->type == ACL_NUMERIC); assert (acl && acl->type == ACL_NUMERIC);
assert(ip && strlen(ip) > 0); assert (ip && strlen (ip) > 0);
if (full_inet_pton(ip, &addr) <= 0) if (full_inet_pton (ip, &addr) <= 0)
return -1; return -1;
for (i = 0; i != IPV6_LEN; ++i) { for (i = 0; i != IPV6_LEN; ++i)
x = addr[i] & acl->address.ip.mask[i]; {
y = acl->address.ip.octet[i] & acl->address.ip.mask[i]; x = addr[i] & acl->address.ip.mask[i];
y = acl->address.ip.octet[i] & acl->address.ip.mask[i];
/* If x and y don't match, the IP addresses don't match */ /* If x and y don't match, the IP addresses don't match */
if (x != y) if (x != y)
return 0; return 0;
} }
/* The addresses match, return the permission */ /* The addresses match, return the permission */
return (acl->access == ACL_ALLOW); return (acl->access == ACL_ALLOW);
} }
/* /*
@ -305,50 +328,52 @@ check_numeric_acl(const struct acl_s *acl, const char *ip)
* 0 if denied * 0 if denied
*/ */
int int
check_acl(int fd, const char *ip, const char *host) check_acl (int fd, const char *ip, const char *host)
{ {
struct acl_s *acl; struct acl_s *acl;
int perm; int perm;
size_t i; size_t i;
assert(fd >= 0); assert (fd >= 0);
assert(ip != NULL); assert (ip != NULL);
assert(host != NULL); assert (host != NULL);
/* /*
* If there is no access list allow everything. * If there is no access list allow everything.
*/ */
if (!access_list) if (!access_list)
return 1; return 1;
for (i = 0; i != vector_length(access_list); ++i) { for (i = 0; i != vector_length (access_list); ++i)
acl = vector_getentry(access_list, i, NULL); {
switch (acl->type) { acl = vector_getentry (access_list, i, NULL);
case ACL_STRING: switch (acl->type)
perm = acl_string_processing(acl, ip, host); {
break; case ACL_STRING:
perm = acl_string_processing (acl, ip, host);
break;
case ACL_NUMERIC: case ACL_NUMERIC:
if (ip[0] == '\0') if (ip[0] == '\0')
continue; continue;
perm = check_numeric_acl(acl, ip); perm = check_numeric_acl (acl, ip);
break; break;
} }
/* /*
* Check the return value too see if the IP address is * Check the return value too see if the IP address is
* allowed or denied. * allowed or denied.
*/ */
if (perm == 0) if (perm == 0)
break; break;
else if (perm == 1) else if (perm == 1)
return perm; return perm;
} }
/* /*
* Deny all connections by default. * Deny all connections by default.
*/ */
log_message(LOG_NOTICE, "Unauthorized connection from \"%s\" [%s].", log_message (LOG_NOTICE, "Unauthorized connection from \"%s\" [%s].",
host, ip); host, ip);
return 0; return 0;
} }

9
src/acl.h
View File

@ -21,10 +21,11 @@
#ifndef TINYPROXY_ACL_H #ifndef TINYPROXY_ACL_H
#define TINYPROXY_ACL_H #define TINYPROXY_ACL_H
typedef enum { ACL_ALLOW, ACL_DENY } acl_access_t; typedef enum
{ ACL_ALLOW, ACL_DENY } acl_access_t;
extern int insert_acl(char *location, acl_access_t access_type); extern int insert_acl (char *location, acl_access_t access_type);
extern int check_acl(int fd, const char *ip_address, extern int check_acl (int fd, const char *ip_address,
const char *string_address); const char *string_address);
#endif #endif

42
src/anonymous.c
View File

@ -30,9 +30,9 @@
static hashmap_t anonymous_map = NULL; static hashmap_t anonymous_map = NULL;
short int short int
is_anonymous_enabled(void) is_anonymous_enabled (void)
{ {
return (anonymous_map != NULL) ? 1 : 0; return (anonymous_map != NULL) ? 1 : 0;
} }
/* /*
@ -40,12 +40,12 @@ is_anonymous_enabled(void)
* zero if the string was found, zero if it wasn't and negative upon error. * zero if the string was found, zero if it wasn't and negative upon error.
*/ */
int int
anonymous_search(char *s) anonymous_search (char *s)
{ {
assert(s != NULL); assert (s != NULL);
assert(anonymous_map != NULL); assert (anonymous_map != NULL);
return hashmap_search(anonymous_map, s); return hashmap_search (anonymous_map, s);
} }
/* /*
@ -55,23 +55,25 @@ anonymous_search(char *s)
* successful. * successful.
*/ */
int int
anonymous_insert(char *s) anonymous_insert (char *s)
{ {
char data = 1; char data = 1;
assert(s != NULL); assert (s != NULL);
if (!anonymous_map) { if (!anonymous_map)
anonymous_map = hashmap_create(32); {
if (!anonymous_map) anonymous_map = hashmap_create (32);
return -1; if (!anonymous_map)
} return -1;
}
if (hashmap_search(anonymous_map, s) > 0) { if (hashmap_search (anonymous_map, s) > 0)
/* The key was already found, so return a positive number. */ {
return 0; /* The key was already found, so return a positive number. */
} return 0;
}
/* Insert the new key */ /* Insert the new key */
return hashmap_insert(anonymous_map, s, &data, sizeof(data)); return hashmap_insert (anonymous_map, s, &data, sizeof (data));
} }

6
src/anonymous.h
View File

@ -21,8 +21,8 @@
#ifndef _TINYPROXY_ANONYMOUS_H_ #ifndef _TINYPROXY_ANONYMOUS_H_
#define _TINYPROXY_ANONYMOUS_H_ #define _TINYPROXY_ANONYMOUS_H_
extern short int is_anonymous_enabled(void); extern short int is_anonymous_enabled (void);
extern int anonymous_search(char *s); extern int anonymous_search (char *s);
extern int anonymous_insert(char *s); extern int anonymous_insert (char *s);
#endif #endif

357
src/buffer.c
View File

@ -34,21 +34,23 @@
#define BUFFER_HEAD(x) (x)->head #define BUFFER_HEAD(x) (x)->head
#define BUFFER_TAIL(x) (x)->tail #define BUFFER_TAIL(x) (x)->tail
struct bufline_s { struct bufline_s
unsigned char *string; /* the actual string of data */ {
struct bufline_s *next; /* pointer to next in linked list */ unsigned char *string; /* the actual string of data */
size_t length; /* length of the string of data */ struct bufline_s *next; /* pointer to next in linked list */
size_t pos; /* start sending from this offset */ size_t length; /* length of the string of data */
size_t pos; /* start sending from this offset */
}; };
/* /*
* The buffer structure points to the beginning and end of the buffer list * The buffer structure points to the beginning and end of the buffer list
* (and includes the total size) * (and includes the total size)
*/ */
struct buffer_s { struct buffer_s
struct bufline_s *head; /* top of the buffer */ {
struct bufline_s *tail; /* bottom of the buffer */ struct bufline_s *head; /* top of the buffer */
size_t size; /* total size of the buffer */ struct bufline_s *tail; /* bottom of the buffer */
size_t size; /* total size of the buffer */
}; };
/* /*
@ -57,155 +59,158 @@ struct buffer_s {
* data buffer on the heap, delete it because you now have TWO copies. * data buffer on the heap, delete it because you now have TWO copies.
*/ */
static struct bufline_s * static struct bufline_s *
makenewline(unsigned char *data, size_t length) makenewline (unsigned char *data, size_t length)
{ {
struct bufline_s *newline; struct bufline_s *newline;
assert(data != NULL); assert (data != NULL);
assert(length > 0); assert (length > 0);
if (!(newline = safemalloc(sizeof(struct bufline_s)))) if (!(newline = safemalloc (sizeof (struct bufline_s))))
return NULL; return NULL;
if (!(newline->string = safemalloc(length))) { if (!(newline->string = safemalloc (length)))
safefree(newline); {
return NULL; safefree (newline);
} return NULL;
}
memcpy(newline->string, data, length); memcpy (newline->string, data, length);
newline->next = NULL; newline->next = NULL;
newline->length = length; newline->length = length;
/* Position our "read" pointer at the beginning of the data */ /* Position our "read" pointer at the beginning of the data */
newline->pos = 0; newline->pos = 0;
return newline; return newline;
} }
/* /*
* Free the allocated buffer line * Free the allocated buffer line
*/ */
static void static void
free_line(struct bufline_s *line) free_line (struct bufline_s *line)
{ {
assert(line != NULL); assert (line != NULL);
if (!line) if (!line)
return; return;
if (line->string) if (line->string)
safefree(line->string); safefree (line->string);
safefree(line); safefree (line);
} }
/* /*
* Create a new buffer * Create a new buffer
*/ */
struct buffer_s * struct buffer_s *
new_buffer(void) new_buffer (void)
{ {
struct buffer_s *buffptr; struct buffer_s *buffptr;
if (!(buffptr = safemalloc(sizeof(struct buffer_s)))) if (!(buffptr = safemalloc (sizeof (struct buffer_s))))
return NULL; return NULL;
/* /*
* Since the buffer is initially empty, set the HEAD and TAIL * Since the buffer is initially empty, set the HEAD and TAIL
* pointers to NULL since they can't possibly point anywhere at the * pointers to NULL since they can't possibly point anywhere at the
* moment. * moment.
*/ */
BUFFER_HEAD(buffptr) = BUFFER_TAIL(buffptr) = NULL; BUFFER_HEAD (buffptr) = BUFFER_TAIL (buffptr) = NULL;
buffptr->size = 0; buffptr->size = 0;
return buffptr; return buffptr;
} }
/* /*
* Delete all the lines in the buffer and the buffer itself * Delete all the lines in the buffer and the buffer itself
*/ */
void void
delete_buffer(struct buffer_s *buffptr) delete_buffer (struct buffer_s *buffptr)
{ {
struct bufline_s *next; struct bufline_s *next;
assert(buffptr != NULL); assert (buffptr != NULL);
while (BUFFER_HEAD(buffptr)) { while (BUFFER_HEAD (buffptr))
next = BUFFER_HEAD(buffptr)->next; {
free_line(BUFFER_HEAD(buffptr)); next = BUFFER_HEAD (buffptr)->next;
BUFFER_HEAD(buffptr) = next; free_line (BUFFER_HEAD (buffptr));
} BUFFER_HEAD (buffptr) = next;
}
safefree(buffptr); safefree (buffptr);
} }
/* /*
* Return the current size of the buffer. * Return the current size of the buffer.
*/ */
size_t size_t
buffer_size(struct buffer_s *buffptr) buffer_size (struct buffer_s *buffptr)
{ {
return buffptr->size; return buffptr->size;
} }
/* /*
* Push a new line on to the end of the buffer. * Push a new line on to the end of the buffer.
*/ */
int int
add_to_buffer(struct buffer_s *buffptr, unsigned char *data, size_t length) add_to_buffer (struct buffer_s *buffptr, unsigned char *data, size_t length)
{ {
struct bufline_s *newline; struct bufline_s *newline;
assert(buffptr != NULL); assert (buffptr != NULL);
assert(data != NULL); assert (data != NULL);
assert(length > 0); assert (length > 0);
/* /*
* Sanity check here. A buffer with a non-NULL head pointer must * Sanity check here. A buffer with a non-NULL head pointer must
* have a size greater than zero, and vice-versa. * have a size greater than zero, and vice-versa.
*/ */
if (BUFFER_HEAD(buffptr) == NULL) if (BUFFER_HEAD (buffptr) == NULL)
assert(buffptr->size == 0); assert (buffptr->size == 0);
else else
assert(buffptr->size > 0); assert (buffptr->size > 0);
/* /*
* Make a new line so we can add it to the buffer. * Make a new line so we can add it to the buffer.
*/ */
if (!(newline = makenewline(data, length))) if (!(newline = makenewline (data, length)))
return -1; return -1;
if (buffptr->size == 0) if (buffptr->size == 0)
BUFFER_HEAD(buffptr) = BUFFER_TAIL(buffptr) = newline; BUFFER_HEAD (buffptr) = BUFFER_TAIL (buffptr) = newline;
else { else
BUFFER_TAIL(buffptr)->next = newline; {
BUFFER_TAIL(buffptr) = newline; BUFFER_TAIL (buffptr)->next = newline;
} BUFFER_TAIL (buffptr) = newline;
}
buffptr->size += length; buffptr->size += length;
return 0; return 0;
} }
/* /*
* Remove the first line from the top of the buffer * Remove the first line from the top of the buffer
*/ */
static struct bufline_s * static struct bufline_s *
remove_from_buffer(struct buffer_s *buffptr) remove_from_buffer (struct buffer_s *buffptr)
{ {
struct bufline_s *line; struct bufline_s *line;
assert(buffptr != NULL); assert (buffptr != NULL);
assert(BUFFER_HEAD(buffptr) != NULL); assert (BUFFER_HEAD (buffptr) != NULL);
line = BUFFER_HEAD(buffptr); line = BUFFER_HEAD (buffptr);
BUFFER_HEAD(buffptr) = line->next; BUFFER_HEAD (buffptr) = line->next;
buffptr->size -= line->length; buffptr->size -= line->length;
return line; return line;
} }
/* /*
@ -214,61 +219,69 @@ remove_from_buffer(struct buffer_s *buffptr)
*/ */
#define READ_BUFFER_SIZE (1024 * 2) #define READ_BUFFER_SIZE (1024 * 2)
ssize_t ssize_t
read_buffer(int fd, struct buffer_s * buffptr) read_buffer (int fd, struct buffer_s * buffptr)
{ {
ssize_t bytesin; ssize_t bytesin;
unsigned char *buffer; unsigned char *buffer;
assert(fd >= 0); assert (fd >= 0);
assert(buffptr != NULL); assert (buffptr != NULL);
/* /*
* Don't allow the buffer to grow larger than MAXBUFFSIZE * Don't allow the buffer to grow larger than MAXBUFFSIZE
*/ */
if (buffptr->size >= MAXBUFFSIZE) if (buffptr->size >= MAXBUFFSIZE)
return 0; return 0;
buffer = safemalloc(READ_BUFFER_SIZE); buffer = safemalloc (READ_BUFFER_SIZE);
if (!buffer) { if (!buffer)
return -ENOMEM; {
} return -ENOMEM;
}
bytesin = read(fd, buffer, READ_BUFFER_SIZE); bytesin = read (fd, buffer, READ_BUFFER_SIZE);
if (bytesin > 0) { if (bytesin > 0)
if (add_to_buffer(buffptr, buffer, bytesin) < 0) { {
log_message(LOG_ERR, if (add_to_buffer (buffptr, buffer, bytesin) < 0)
"readbuff: add_to_buffer() error."); {
bytesin = -1; log_message (LOG_ERR, "readbuff: add_to_buffer() error.");
} bytesin = -1;
} else { }
if (bytesin == 0) { }
/* connection was closed by client */ else
bytesin = -1; {
} else { if (bytesin == 0)
switch (errno) { {
/* connection was closed by client */
bytesin = -1;
}
else
{
switch (errno)
{
#ifdef EWOULDBLOCK #ifdef EWOULDBLOCK
case EWOULDBLOCK: case EWOULDBLOCK:
#else #else
# ifdef EAGAIN # ifdef EAGAIN
case EAGAIN: case EAGAIN:
# endif # endif
#endif #endif
case EINTR: case EINTR:
bytesin = 0; bytesin = 0;
break; break;
default: default:
log_message(LOG_ERR, log_message (LOG_ERR,
"readbuff: recv() error \"%s\" on file descriptor %d", "readbuff: recv() error \"%s\" on file descriptor %d",
strerror(errno), fd); strerror (errno), fd);
bytesin = -1; bytesin = -1;
break; break;
} }
} }
} }
safefree(buffer); safefree (buffer);
return bytesin; return bytesin;
} }
/* /*
@ -276,53 +289,57 @@ read_buffer(int fd, struct buffer_s * buffptr)
* Takes a connection and returns the number of bytes written. * Takes a connection and returns the number of bytes written.
*/ */
ssize_t ssize_t
write_buffer(int fd, struct buffer_s * buffptr) write_buffer (int fd, struct buffer_s * buffptr)
{ {
ssize_t bytessent; ssize_t bytessent;
struct bufline_s *line; struct bufline_s *line;
assert(fd >= 0); assert (fd >= 0);
assert(buffptr != NULL); assert (buffptr != NULL);
if (buffptr->size == 0) if (buffptr->size == 0)
return 0; return 0;
/* Sanity check. It would be bad to be using a NULL pointer! */ /* Sanity check. It would be bad to be using a NULL pointer! */
assert(BUFFER_HEAD(buffptr) != NULL); assert (BUFFER_HEAD (buffptr) != NULL);
line = BUFFER_HEAD(buffptr); line = BUFFER_HEAD (buffptr);
bytessent = bytessent =
send(fd, line->string + line->pos, line->length - line->pos, send (fd, line->string + line->pos, line->length - line->pos,
MSG_NOSIGNAL); MSG_NOSIGNAL);
if (bytessent >= 0) { if (bytessent >= 0)
/* bytes sent, adjust buffer */ {
line->pos += bytessent; /* bytes sent, adjust buffer */
if (line->pos == line->length) line->pos += bytessent;
free_line(remove_from_buffer(buffptr)); if (line->pos == line->length)
return bytessent; free_line (remove_from_buffer (buffptr));
} else { return bytessent;
switch (errno) { }
else
{
switch (errno)
{
#ifdef EWOULDBLOCK #ifdef EWOULDBLOCK
case EWOULDBLOCK: case EWOULDBLOCK:
#else #else
# ifdef EAGAIN # ifdef EAGAIN
case EAGAIN: case EAGAIN:
# endif # endif
#endif #endif
case EINTR: case EINTR:
return 0; return 0;
case ENOBUFS: case ENOBUFS:
case ENOMEM: case ENOMEM:
log_message(LOG_ERR, log_message (LOG_ERR,
"writebuff: write() error [NOBUFS/NOMEM] \"%s\" on file descriptor %d", "writebuff: write() error [NOBUFS/NOMEM] \"%s\" on file descriptor %d",
strerror(errno), fd); strerror (errno), fd);
return 0; return 0;
default: default:
log_message(LOG_ERR, log_message (LOG_ERR,
"writebuff: write() error \"%s\" on file descriptor %d", "writebuff: write() error \"%s\" on file descriptor %d",
strerror(errno), fd); strerror (errno), fd);
return -1; return -1;
} }
} }
} }

16
src/buffer.h
View File

@ -24,17 +24,17 @@
/* Forward declaration */ /* Forward declaration */
struct buffer_s; struct buffer_s;
extern struct buffer_s *new_buffer(void); extern struct buffer_s *new_buffer (void);
extern void delete_buffer(struct buffer_s *buffptr); extern void delete_buffer (struct buffer_s *buffptr);
extern size_t buffer_size(struct buffer_s *buffptr); extern size_t buffer_size (struct buffer_s *buffptr);
/* /*
* Add a new line to the given buffer. The data IS copied into the structure. * Add a new line to the given buffer. The data IS copied into the structure.
*/ */
extern int add_to_buffer(struct buffer_s *buffptr, unsigned char *data, extern int add_to_buffer (struct buffer_s *buffptr, unsigned char *data,
size_t length); size_t length);
extern ssize_t read_buffer(int fd, struct buffer_s *buffptr); extern ssize_t read_buffer (int fd, struct buffer_s *buffptr);
extern ssize_t write_buffer(int fd, struct buffer_s *buffptr); extern ssize_t write_buffer (int fd, struct buffer_s *buffptr);
#endif /* __BUFFER_H_ */ #endif /* __BUFFER_H_ */

545
src/child.c
View File

@ -37,11 +37,13 @@ static socklen_t addrlen;
/* /*
* Stores the internal data needed for each child (connection) * Stores the internal data needed for each child (connection)
*/ */
enum child_status_t { T_EMPTY, T_WAITING, T_CONNECTED }; enum child_status_t
struct child_s { { T_EMPTY, T_WAITING, T_CONNECTED };
pid_t tid; struct child_s
unsigned int connects; {
enum child_status_t status; pid_t tid;
unsigned int connects;
enum child_status_t status;
}; };
/* /*
@ -50,12 +52,13 @@ struct child_s {
*/ */
static struct child_s *child_ptr; static struct child_s *child_ptr;
static struct child_config_s { static struct child_config_s
int maxclients, maxrequestsperchild; {
int maxspareservers, minspareservers, startservers; int maxclients, maxrequestsperchild;
int maxspareservers, minspareservers, startservers;
} child_config; } child_config;
static unsigned int *servers_waiting; /* servers waiting for a connection */ static unsigned int *servers_waiting; /* servers waiting for a connection */
/* /*
* Lock/Unlock the "servers_waiting" variable so that two children cannot * Lock/Unlock the "servers_waiting" variable so that two children cannot
@ -74,47 +77,48 @@ static struct flock lock_it, unlock_it;
static int lock_fd = -1; static int lock_fd = -1;
static void static void
_child_lock_init(void) _child_lock_init (void)
{ {
char lock_file[] = "/tmp/tinyproxy.servers.lock.XXXXXX"; char lock_file[] = "/tmp/tinyproxy.servers.lock.XXXXXX";
/* Only allow u+rw bits. This may be required for some versions /* Only allow u+rw bits. This may be required for some versions
* of glibc so that mkstemp() doesn't make us vulnerable. * of glibc so that mkstemp() doesn't make us vulnerable.
*/ */
umask(0177); umask (0177);
lock_fd = mkstemp(lock_file); lock_fd = mkstemp (lock_file);
unlink(lock_file); unlink (lock_file);
lock_it.l_type = F_WRLCK; lock_it.l_type = F_WRLCK;
lock_it.l_whence = SEEK_SET; lock_it.l_whence = SEEK_SET;
lock_it.l_start = 0; lock_it.l_start = 0;
lock_it.l_len = 0; lock_it.l_len = 0;
unlock_it.l_type = F_UNLCK; unlock_it.l_type = F_UNLCK;
unlock_it.l_whence = SEEK_SET; unlock_it.l_whence = SEEK_SET;
unlock_it.l_start = 0; unlock_it.l_start = 0;
unlock_it.l_len = 0; unlock_it.l_len = 0;
} }
static void static void
_child_lock_wait(void) _child_lock_wait (void)
{ {
int rc; int rc;
while ((rc = fcntl(lock_fd, F_SETLKW, &lock_it)) < 0) { while ((rc = fcntl (lock_fd, F_SETLKW, &lock_it)) < 0)
if (errno == EINTR) {
continue; if (errno == EINTR)
else continue;
return; else
} return;
}
} }
static void static void
_child_lock_release(void) _child_lock_release (void)
{ {
if (fcntl(lock_fd, F_SETLKW, &unlock_it) < 0) if (fcntl (lock_fd, F_SETLKW, &unlock_it) < 0)
return; return;
} }
/* END OF LOCKING SECTION */ /* END OF LOCKING SECTION */
@ -138,126 +142,133 @@ _child_lock_release(void)
* Set the configuration values for the various child related settings. * Set the configuration values for the various child related settings.
*/ */
short int short int
child_configure(child_config_t type, int val) child_configure (child_config_t type, int val)
{ {
switch (type) { switch (type)
case CHILD_MAXCLIENTS: {
child_config.maxclients = val; case CHILD_MAXCLIENTS:
break; child_config.maxclients = val;
case CHILD_MAXSPARESERVERS: break;
child_config.maxspareservers = val; case CHILD_MAXSPARESERVERS:
break; child_config.maxspareservers = val;
case CHILD_MINSPARESERVERS: break;
child_config.minspareservers = val; case CHILD_MINSPARESERVERS:
break; child_config.minspareservers = val;
case CHILD_STARTSERVERS: break;
child_config.startservers = val; case CHILD_STARTSERVERS:
break; child_config.startservers = val;
case CHILD_MAXREQUESTSPERCHILD: break;
child_config.maxrequestsperchild = val; case CHILD_MAXREQUESTSPERCHILD:
break; child_config.maxrequestsperchild = val;
default: break;
DEBUG2("Invalid type (%d)", type); default:
return -1; DEBUG2 ("Invalid type (%d)", type);
} return -1;
}
return 0; return 0;
} }
/* /*
* This is the main (per child) loop. * This is the main (per child) loop.
*/ */
static void static void
child_main(struct child_s *ptr) child_main (struct child_s *ptr)
{ {
int connfd; int connfd;
struct sockaddr *cliaddr; struct sockaddr *cliaddr;
socklen_t clilen; socklen_t clilen;
cliaddr = safemalloc(addrlen); cliaddr = safemalloc (addrlen);
if (!cliaddr) { if (!cliaddr)
log_message(LOG_CRIT, {
"Could not allocate memory for child address."); log_message (LOG_CRIT, "Could not allocate memory for child address.");
exit(0); exit (0);
} }
ptr->connects = 0; ptr->connects = 0;
while (!config.quit) { while (!config.quit)
ptr->status = T_WAITING; {
ptr->status = T_WAITING;
clilen = addrlen; clilen = addrlen;
connfd = accept(listenfd, cliaddr, &clilen); connfd = accept (listenfd, cliaddr, &clilen);
#ifndef NDEBUG #ifndef NDEBUG
/* /*
* Enable the TINYPROXY_DEBUG environment variable if you * Enable the TINYPROXY_DEBUG environment variable if you
* want to use the GDB debugger. * want to use the GDB debugger.
*/ */
if (getenv("TINYPROXY_DEBUG")) { if (getenv ("TINYPROXY_DEBUG"))
/* Pause for 10 seconds to allow us to connect debugger */ {
fprintf(stderr, /* Pause for 10 seconds to allow us to connect debugger */
"Process has accepted connection: %ld\n", fprintf (stderr,
(long int)ptr->tid); "Process has accepted connection: %ld\n",
sleep(10); (long int) ptr->tid);
fprintf(stderr, "Continuing process: %ld\n", sleep (10);
(long int)ptr->tid); fprintf (stderr, "Continuing process: %ld\n", (long int) ptr->tid);
} }
#endif #endif
/* /*
* Make sure no error occurred... * Make sure no error occurred...
*/ */
if (connfd < 0) { if (connfd < 0)
log_message(LOG_ERR, {
"Accept returned an error (%s) ... retrying.", log_message (LOG_ERR,
strerror(errno)); "Accept returned an error (%s) ... retrying.",
continue; strerror (errno));
} continue;
}
ptr->status = T_CONNECTED; ptr->status = T_CONNECTED;
SERVER_DEC(); SERVER_DEC ();
handle_connection(connfd); handle_connection (connfd);
ptr->connects++; ptr->connects++;
if (child_config.maxrequestsperchild != 0) { if (child_config.maxrequestsperchild != 0)
DEBUG2("%u connections so far...", ptr->connects); {
DEBUG2 ("%u connections so far...", ptr->connects);
if (ptr->connects == child_config.maxrequestsperchild) { if (ptr->connects == child_config.maxrequestsperchild)
log_message(LOG_NOTICE, {
"Child has reached MaxRequestsPerChild (%u). Killing child.", log_message (LOG_NOTICE,
ptr->connects); "Child has reached MaxRequestsPerChild (%u). Killing child.",
break; ptr->connects);
} break;
} }
}
SERVER_COUNT_LOCK(); SERVER_COUNT_LOCK ();
if (*servers_waiting > child_config.maxspareservers) { if (*servers_waiting > child_config.maxspareservers)
/* {
* There are too many spare children, kill ourself /*
* off. * There are too many spare children, kill ourself
*/ * off.
log_message(LOG_NOTICE, */
"Waiting servers (%d) exceeds MaxSpareServers (%d). Killing child.", log_message (LOG_NOTICE,
*servers_waiting, "Waiting servers (%d) exceeds MaxSpareServers (%d). Killing child.",
child_config.maxspareservers); *servers_waiting, child_config.maxspareservers);
SERVER_COUNT_UNLOCK(); SERVER_COUNT_UNLOCK ();
break; break;
} else { }
SERVER_COUNT_UNLOCK(); else
} {
SERVER_COUNT_UNLOCK ();
}
SERVER_INC(); SERVER_INC ();
} }
ptr->status = T_EMPTY; ptr->status = T_EMPTY;
safefree(cliaddr); safefree (cliaddr);
exit(0); exit (0);
} }
/* /*
@ -265,104 +276,113 @@ child_main(struct child_s *ptr)
* child_main() function. * child_main() function.
*/ */
static pid_t static pid_t
child_make(struct child_s *ptr) child_make (struct child_s *ptr)
{ {
pid_t pid; pid_t pid;
if ((pid = fork()) > 0) if ((pid = fork ()) > 0)
return pid; /* parent */ return pid; /* parent */
/* /*
* Reset the SIGNALS so that the child can be reaped. * Reset the SIGNALS so that the child can be reaped.
*/ */
set_signal_handler(SIGCHLD, SIG_DFL); set_signal_handler (SIGCHLD, SIG_DFL);
set_signal_handler(SIGTERM, SIG_DFL); set_signal_handler (SIGTERM, SIG_DFL);
set_signal_handler(SIGHUP, SIG_DFL); set_signal_handler (SIGHUP, SIG_DFL);
child_main(ptr); /* never returns */ child_main (ptr); /* never returns */
return -1; return -1;
} }
/* /*
* Create a pool of children to handle incoming connections * Create a pool of children to handle incoming connections
*/ */
short int short int
child_pool_create(void) child_pool_create (void)
{ {
unsigned int i; unsigned int i;
/* /*
* Make sure the number of MaxClients is not zero, since this * Make sure the number of MaxClients is not zero, since this
* variable determines the size of the array created for children * variable determines the size of the array created for children
* later on. * later on.
*/ */
if (child_config.maxclients == 0) { if (child_config.maxclients == 0)
log_message(LOG_ERR, {
"child_pool_create: \"MaxClients\" must be greater than zero."); log_message (LOG_ERR,
return -1; "child_pool_create: \"MaxClients\" must be greater than zero.");
} return -1;
if (child_config.startservers == 0) { }
log_message(LOG_ERR, if (child_config.startservers == 0)
"child_pool_create: \"StartServers\" must be greater than zero."); {
return -1; log_message (LOG_ERR,
} "child_pool_create: \"StartServers\" must be greater than zero.");
return -1;
}
child_ptr = calloc_shared_memory(child_config.maxclients, child_ptr = calloc_shared_memory (child_config.maxclients,
sizeof(struct child_s)); sizeof (struct child_s));
if (!child_ptr) { if (!child_ptr)
log_message(LOG_ERR, "Could not allocate memory for children."); {
return -1; log_message (LOG_ERR, "Could not allocate memory for children.");
} return -1;
}
servers_waiting = malloc_shared_memory(sizeof(unsigned int)); servers_waiting = malloc_shared_memory (sizeof (unsigned int));
if (servers_waiting == MAP_FAILED) { if (servers_waiting == MAP_FAILED)
log_message(LOG_ERR, {
"Could not allocate memory for child counting."); log_message (LOG_ERR, "Could not allocate memory for child counting.");
return -1; return -1;
} }
*servers_waiting = 0; *servers_waiting = 0;
/* /*
* Create a "locking" file for use around the servers_waiting * Create a "locking" file for use around the servers_waiting
* variable. * variable.
*/ */
_child_lock_init(); _child_lock_init ();
if (child_config.startservers > child_config.maxclients) { if (child_config.startservers > child_config.maxclients)
log_message(LOG_WARNING, {
"Can not start more than \"MaxClients\" servers. Starting %u servers instead.", log_message (LOG_WARNING,
child_config.maxclients); "Can not start more than \"MaxClients\" servers. Starting %u servers instead.",
child_config.startservers = child_config.maxclients; child_config.maxclients);
} child_config.startservers = child_config.maxclients;
}
for (i = 0; i != child_config.maxclients; i++) { for (i = 0; i != child_config.maxclients; i++)
child_ptr[i].status = T_EMPTY; {
child_ptr[i].connects = 0; child_ptr[i].status = T_EMPTY;
} child_ptr[i].connects = 0;
}
for (i = 0; i != child_config.startservers; i++) { for (i = 0; i != child_config.startservers; i++)
DEBUG2("Trying to create child %d of %d", i + 1, {
child_config.startservers); DEBUG2 ("Trying to create child %d of %d", i + 1,
child_ptr[i].status = T_WAITING; child_config.startservers);
child_ptr[i].tid = child_make(&child_ptr[i]); child_ptr[i].status = T_WAITING;
child_ptr[i].tid = child_make (&child_ptr[i]);
if (child_ptr[i].tid < 0) { if (child_ptr[i].tid < 0)
log_message(LOG_WARNING, {
"Could not create child number %d of %d", log_message (LOG_WARNING,
i, child_config.startservers); "Could not create child number %d of %d",
return -1; i, child_config.startservers);
} else { return -1;
log_message(LOG_INFO, }
"Creating child number %d of %d ...", else
i + 1, child_config.startservers); {
log_message (LOG_INFO,
"Creating child number %d of %d ...",
i + 1, child_config.startservers);
SERVER_INC(); SERVER_INC ();
} }
} }
log_message(LOG_INFO, "Finished creating all children."); log_message (LOG_INFO, "Finished creating all children.");
return 0; return 0;
} }
/* /*
@ -370,88 +390,95 @@ child_pool_create(void)
* servers. It monitors this at least once a second. * servers. It monitors this at least once a second.
*/ */
void void
child_main_loop(void) child_main_loop (void)
{ {
unsigned int i; unsigned int i;
while (1) { while (1)
if (config.quit) {
return; if (config.quit)
return;
/* If there are not enough spare servers, create more */ /* If there are not enough spare servers, create more */
SERVER_COUNT_LOCK(); SERVER_COUNT_LOCK ();
if (*servers_waiting < child_config.minspareservers) { if (*servers_waiting < child_config.minspareservers)
log_message(LOG_NOTICE, {
"Waiting servers (%d) is less than MinSpareServers (%d). Creating new child.", log_message (LOG_NOTICE,
*servers_waiting, "Waiting servers (%d) is less than MinSpareServers (%d). Creating new child.",
child_config.minspareservers); *servers_waiting, child_config.minspareservers);
SERVER_COUNT_UNLOCK(); SERVER_COUNT_UNLOCK ();
for (i = 0; i != child_config.maxclients; i++) { for (i = 0; i != child_config.maxclients; i++)
if (child_ptr[i].status == T_EMPTY) { {
child_ptr[i].status = T_WAITING; if (child_ptr[i].status == T_EMPTY)
child_ptr[i].tid = {
child_make(&child_ptr[i]); child_ptr[i].status = T_WAITING;
if (child_ptr[i].tid < 0) { child_ptr[i].tid = child_make (&child_ptr[i]);
log_message(LOG_NOTICE, if (child_ptr[i].tid < 0)
"Could not create child"); {
log_message (LOG_NOTICE, "Could not create child");
child_ptr[i].status = T_EMPTY; child_ptr[i].status = T_EMPTY;
break; break;
} }
SERVER_INC(); SERVER_INC ();
break; break;
} }
} }
} else { }
SERVER_COUNT_UNLOCK(); else
} {
SERVER_COUNT_UNLOCK ();
}
sleep(5); sleep (5);
/* Handle log rotation if it was requested */ /* Handle log rotation if it was requested */
if (received_sighup) { if (received_sighup)
truncate_log_file(); {
truncate_log_file ();
#ifdef FILTER_ENABLE #ifdef FILTER_ENABLE
if (config.filter) { if (config.filter)
filter_destroy(); {
filter_init(); filter_destroy ();
} filter_init ();
log_message(LOG_NOTICE, "Re-reading filter file."); }
#endif /* FILTER_ENABLE */ log_message (LOG_NOTICE, "Re-reading filter file.");
#endif /* FILTER_ENABLE */
received_sighup = FALSE; received_sighup = FALSE;
} }
} }
} }
/* /*
* Go through all the non-empty children and cancel them. * Go through all the non-empty children and cancel them.
*/ */
void void
child_kill_children(void) child_kill_children (void)
{ {
unsigned int i; unsigned int i;
for (i = 0; i != child_config.maxclients; i++) { for (i = 0; i != child_config.maxclients; i++)
if (child_ptr[i].status != T_EMPTY) {
kill(child_ptr[i].tid, SIGTERM); if (child_ptr[i].status != T_EMPTY)
} kill (child_ptr[i].tid, SIGTERM);
}
} }
int int
child_listening_sock(uint16_t port) child_listening_sock (uint16_t port)
{ {
listenfd = listen_sock(port, &addrlen); listenfd = listen_sock (port, &addrlen);
return listenfd; return listenfd;
} }
void void
child_close_sock(void) child_close_sock (void)
{ {
close(listenfd); close (listenfd);
} }

25
src/child.h
View File

@ -21,20 +21,21 @@
#ifndef TINYPROXY_CHILD_H #ifndef TINYPROXY_CHILD_H
#define TINYPROXY_CHILD_H #define TINYPROXY_CHILD_H
typedef enum { typedef enum
CHILD_MAXCLIENTS, {
CHILD_MAXSPARESERVERS, CHILD_MAXCLIENTS,
CHILD_MINSPARESERVERS, CHILD_MAXSPARESERVERS,
CHILD_STARTSERVERS, CHILD_MINSPARESERVERS,
CHILD_MAXREQUESTSPERCHILD CHILD_STARTSERVERS,
CHILD_MAXREQUESTSPERCHILD
} child_config_t; } child_config_t;
extern short int child_pool_create(void); extern short int child_pool_create (void);
extern int child_listening_sock(uint16_t port); extern int child_listening_sock (uint16_t port);
extern void child_close_sock(void); extern void child_close_sock (void);
extern void child_main_loop(void); extern void child_main_loop (void);
extern void child_kill_children(void); extern void child_kill_children (void);
extern short int child_configure(child_config_t type, int val); extern short int child_configure (child_config_t type, int val);
#endif #endif

10
src/common.h
View File

@ -173,13 +173,13 @@
# define MSG_NOSIGNAL (0) # define MSG_NOSIGNAL (0)
#endif #endif
#ifndef SHUT_RD /* these three Posix.1g names are quite new */ #ifndef SHUT_RD /* these three Posix.1g names are quite new */
# define SHUT_RD 0 /* shutdown for reading */ # define SHUT_RD 0 /* shutdown for reading */
# define SHUT_WR 1 /* shutdown for writing */ # define SHUT_WR 1 /* shutdown for writing */
# define SHUT_RDWR 2 /* shutdown for reading and writing */ # define SHUT_RDWR 2 /* shutdown for reading and writing */
#endif #endif
#define MAXLISTEN 1024 /* Max number of connections */ #define MAXLISTEN 1024 /* Max number of connections */
/* /*
* SunOS doesn't have INADDR_NONE defined. * SunOS doesn't have INADDR_NONE defined.

792
src/conffile.c
View File

File diff suppressed because it is too large Load Diff

4
src/conffile.h
View File

@ -21,7 +21,7 @@
#ifndef TINYPROXY_CONFFILE_H #ifndef TINYPROXY_CONFFILE_H
#define TINYPROXY_CONFFILE_H #define TINYPROXY_CONFFILE_H
extern int config_compile(void); extern int config_compile (void);
extern int config_parse(struct config_s *conf, FILE * f); extern int config_parse (struct config_s *conf, FILE * f);
#endif #endif

156
src/conns.c
View File

@ -31,118 +31,118 @@
#include "stats.h" #include "stats.h"
struct conn_s * struct conn_s *
initialize_conn(int client_fd, const char *ipaddr, const char *string_addr, initialize_conn (int client_fd, const char *ipaddr, const char *string_addr,
const char *sock_ipaddr) const char *sock_ipaddr)
{ {
struct conn_s *connptr; struct conn_s *connptr;
struct buffer_s *cbuffer, *sbuffer; struct buffer_s *cbuffer, *sbuffer;
assert(client_fd >= 0); assert (client_fd >= 0);
/* /*
* Allocate the memory for all the internal components * Allocate the memory for all the internal components
*/ */
cbuffer = new_buffer(); cbuffer = new_buffer ();
sbuffer = new_buffer(); sbuffer = new_buffer ();
if (!cbuffer || !sbuffer) if (!cbuffer || !sbuffer)
goto error_exit; goto error_exit;
/* /*
* Allocate the space for the conn_s structure itself. * Allocate the space for the conn_s structure itself.
*/ */
connptr = safemalloc(sizeof(struct conn_s)); connptr = safemalloc (sizeof (struct conn_s));
if (!connptr) if (!connptr)
goto error_exit; goto error_exit;
connptr->client_fd = client_fd; connptr->client_fd = client_fd;
connptr->server_fd = -1; connptr->server_fd = -1;
connptr->cbuffer = cbuffer; connptr->cbuffer = cbuffer;
connptr->sbuffer = sbuffer; connptr->sbuffer = sbuffer;
connptr->request_line = NULL; connptr->request_line = NULL;
/* These store any error strings */ /* These store any error strings */
connptr->error_variables = NULL; connptr->error_variables = NULL;
connptr->error_string = NULL; connptr->error_string = NULL;
connptr->error_number = -1; connptr->error_number = -1;
connptr->connect_method = FALSE; connptr->connect_method = FALSE;
connptr->show_stats = FALSE; connptr->show_stats = FALSE;
connptr->protocol.major = connptr->protocol.minor = 0; connptr->protocol.major = connptr->protocol.minor = 0;
/* There is _no_ content length initially */ /* There is _no_ content length initially */
connptr->content_length.server = connptr->content_length.client = -1; connptr->content_length.server = connptr->content_length.client = -1;
connptr->server_ip_addr = sock_ipaddr ? safestrdup(sock_ipaddr) : 0; connptr->server_ip_addr = sock_ipaddr ? safestrdup (sock_ipaddr) : 0;
connptr->client_ip_addr = safestrdup(ipaddr); connptr->client_ip_addr = safestrdup (ipaddr);
connptr->client_string_addr = safestrdup(string_addr); connptr->client_string_addr = safestrdup (string_addr);
connptr->upstream_proxy = NULL; connptr->upstream_proxy = NULL;
update_stats(STAT_OPEN); update_stats (STAT_OPEN);
#ifdef REVERSE_SUPPORT #ifdef REVERSE_SUPPORT
connptr->reversepath = NULL; connptr->reversepath = NULL;
#endif #endif
return connptr; return connptr;
error_exit: error_exit:
/* /*
* If we got here, there was a problem allocating memory * If we got here, there was a problem allocating memory
*/ */
if (cbuffer) if (cbuffer)
delete_buffer(cbuffer); delete_buffer (cbuffer);
if (sbuffer) if (sbuffer)
delete_buffer(sbuffer); delete_buffer (sbuffer);
return NULL; return NULL;
} }
void void
destroy_conn(struct conn_s *connptr) destroy_conn (struct conn_s *connptr)
{ {
assert(connptr != NULL); assert (connptr != NULL);
if (connptr->client_fd != -1) if (connptr->client_fd != -1)
if (close(connptr->client_fd) < 0) if (close (connptr->client_fd) < 0)
log_message(LOG_INFO, "Client (%d) close message: %s", log_message (LOG_INFO, "Client (%d) close message: %s",
connptr->client_fd, strerror(errno)); connptr->client_fd, strerror (errno));
if (connptr->server_fd != -1) if (connptr->server_fd != -1)
if (close(connptr->server_fd) < 0) if (close (connptr->server_fd) < 0)
log_message(LOG_INFO, "Server (%d) close message: %s", log_message (LOG_INFO, "Server (%d) close message: %s",
connptr->server_fd, strerror(errno)); connptr->server_fd, strerror (errno));
if (connptr->cbuffer) if (connptr->cbuffer)
delete_buffer(connptr->cbuffer); delete_buffer (connptr->cbuffer);
if (connptr->sbuffer) if (connptr->sbuffer)
delete_buffer(connptr->sbuffer); delete_buffer (connptr->sbuffer);
if (connptr->request_line) if (connptr->request_line)
safefree(connptr->request_line); safefree (connptr->request_line);
if (connptr->error_variables) if (connptr->error_variables)
hashmap_delete(connptr->error_variables); hashmap_delete (connptr->error_variables);
if (connptr->error_string) if (connptr->error_string)
safefree(connptr->error_string); safefree (connptr->error_string);
if (connptr->server_ip_addr) if (connptr->server_ip_addr)
safefree(connptr->server_ip_addr); safefree (connptr->server_ip_addr);
if (connptr->client_ip_addr) if (connptr->client_ip_addr)
safefree(connptr->client_ip_addr); safefree (connptr->client_ip_addr);
if (connptr->client_string_addr) if (connptr->client_string_addr)
safefree(connptr->client_string_addr); safefree (connptr->client_string_addr);
#ifdef REVERSE_SUPPORT #ifdef REVERSE_SUPPORT
if (connptr->reversepath) if (connptr->reversepath)
safefree(connptr->reversepath); safefree (connptr->reversepath);
#endif #endif
safefree(connptr); safefree (connptr);
update_stats(STAT_CLOSE); update_stats (STAT_CLOSE);
} }

103
src/conns.h
View File

@ -27,73 +27,76 @@
/* /*
* Connection Definition * Connection Definition
*/ */
struct conn_s { struct conn_s
int client_fd; {
int server_fd; int client_fd;
int server_fd;
struct buffer_s *cbuffer; struct buffer_s *cbuffer;
struct buffer_s *sbuffer; struct buffer_s *sbuffer;
/* The request line (first line) from the client */ /* The request line (first line) from the client */
char *request_line; char *request_line;
/* Booleans */ /* Booleans */
unsigned int connect_method; unsigned int connect_method;
unsigned int show_stats; unsigned int show_stats;
/* /*
* This structure stores key -> value mappings for substitution * This structure stores key -> value mappings for substitution
* in the error HTML files. * in the error HTML files.
*/ */
hashmap_t error_variables; hashmap_t error_variables;
int error_number; int error_number;
char *error_string; char *error_string;
/* A Content-Length value from the remote server */ /* A Content-Length value from the remote server */
struct { struct
long int server; {
long int client; long int server;
} content_length; long int client;
} content_length;
/* /*
* Store the server's IP (for BindSame) * Store the server's IP (for BindSame)
*/ */
char *server_ip_addr; char *server_ip_addr;
/* /*
* Store the client's IP and hostname information * Store the client's IP and hostname information
*/ */
char *client_ip_addr; char *client_ip_addr;
char *client_string_addr; char *client_string_addr;
/* /*
* Store the incoming request's HTTP protocol. * Store the incoming request's HTTP protocol.
*/ */
struct { struct
unsigned int major; {
unsigned int minor; unsigned int major;
} protocol; unsigned int minor;
} protocol;
#ifdef REVERSE_SUPPORT #ifdef REVERSE_SUPPORT
/* /*
* Place to store the current per-connection reverse proxy path * Place to store the current per-connection reverse proxy path
*/ */
char *reversepath; char *reversepath;
#endif #endif
/* /*
* Pointer to upstream proxy. * Pointer to upstream proxy.
*/ */
struct upstream *upstream_proxy; struct upstream *upstream_proxy;
}; };
/* /*
* Functions for the creation and destruction of a connection structure. * Functions for the creation and destruction of a connection structure.
*/ */
extern struct conn_s *initialize_conn(int client_fd, const char *ipaddr, extern struct conn_s *initialize_conn (int client_fd, const char *ipaddr,
const char *string_addr, const char *string_addr,
const char *sock_ipaddr); const char *sock_ipaddr);
extern void destroy_conn(struct conn_s *connptr); extern void destroy_conn (struct conn_s *connptr);
#endif #endif

61
src/daemon.c
View File

@ -30,28 +30,28 @@
* program a daemon process. * program a daemon process.
*/ */
void void
makedaemon(void) makedaemon (void)
{ {
if (fork() != 0) if (fork () != 0)
exit(0); exit (0);
setsid(); setsid ();
set_signal_handler(SIGHUP, SIG_IGN); set_signal_handler (SIGHUP, SIG_IGN);
if (fork() != 0) if (fork () != 0)
exit(0); exit (0);
chdir("/"); chdir ("/");
umask(0177); umask (0177);
#if NDEBUG #if NDEBUG
/* /*
* When not in debugging mode, close the standard file * When not in debugging mode, close the standard file
* descriptors. * descriptors.
*/ */
close(0); close (0);
close(1); close (1);
close(2); close (2);
#endif #endif
} }
@ -60,25 +60,28 @@ makedaemon(void)
* to handle signals sent to the process. * to handle signals sent to the process.
*/ */
signal_func * signal_func *
set_signal_handler(int signo, signal_func *func) set_signal_handler (int signo, signal_func * func)
{ {
struct sigaction act, oact; struct sigaction act, oact;
act.sa_handler = func; act.sa_handler = func;
sigemptyset(&act.sa_mask); sigemptyset (&act.sa_mask);
act.sa_flags = 0; act.sa_flags = 0;
if (signo == SIGALRM) { if (signo == SIGALRM)
{
#ifdef SA_INTERRUPT #ifdef SA_INTERRUPT
act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */ act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */
#endif #endif
} else { }
else
{
#ifdef SA_RESTART #ifdef SA_RESTART
act.sa_flags |= SA_RESTART; /* SVR4, 4.4BSD */ act.sa_flags |= SA_RESTART; /* SVR4, 4.4BSD */
#endif #endif
} }
if (sigaction(signo, &act, &oact) < 0) if (sigaction (signo, &act, &oact) < 0)
return SIG_ERR; return SIG_ERR;
return oact.sa_handler; return oact.sa_handler;
} }

4
src/daemon.h
View File

@ -26,11 +26,11 @@ typedef void signal_func (int);
/* /*
* Pass a singal integer and a function to handle the signal. * Pass a singal integer and a function to handle the signal.
*/ */
extern signal_func *set_signal_handler(int signo, signal_func *func); extern signal_func *set_signal_handler (int signo, signal_func * func);
/* /*
* Make a program a daemon process * Make a program a daemon process
*/ */
extern void makedaemon(void); extern void makedaemon (void);
#endif #endif

268
src/filter.c
View File

@ -33,10 +33,11 @@
static int err; static int err;
struct filter_list { struct filter_list
struct filter_list *next; {
char *pat; struct filter_list *next;
regex_t *cpat; char *pat;
regex_t *cpat;
}; };
static struct filter_list *fl = NULL; static struct filter_list *fl = NULL;
@ -47,171 +48,176 @@ static filter_policy_t default_policy = FILTER_DEFAULT_ALLOW;
* Initializes a linked list of strings containing hosts/urls to be filtered * Initializes a linked list of strings containing hosts/urls to be filtered
*/ */
void void
filter_init(void) filter_init (void)
{ {
FILE *fd; FILE *fd;
struct filter_list *p; struct filter_list *p;
char buf[FILTER_BUFFER_LEN]; char buf[FILTER_BUFFER_LEN];
char *s; char *s;
int cflags; int cflags;
if (!fl && !already_init) { if (!fl && !already_init)
fd = fopen(config.filter, "r"); {
if (fd) { fd = fopen (config.filter, "r");
p = NULL; if (fd)
{
p = NULL;
cflags = REG_NEWLINE | REG_NOSUB; cflags = REG_NEWLINE | REG_NOSUB;
if (config.filter_extended) if (config.filter_extended)
cflags |= REG_EXTENDED; cflags |= REG_EXTENDED;
if (!config.filter_casesensitive) if (!config.filter_casesensitive)
cflags |= REG_ICASE; cflags |= REG_ICASE;
while (fgets(buf, FILTER_BUFFER_LEN, fd)) { while (fgets (buf, FILTER_BUFFER_LEN, fd))
/* {
* Remove any trailing white space and /*
* comments. * Remove any trailing white space and
*/ * comments.
s = buf; */
while (*s) { s = buf;
if (isspace((unsigned char)*s)) while (*s)
break; {
if (*s == '#') { if (isspace ((unsigned char) *s))
/* break;
* If the '#' char is preceeded by if (*s == '#')
* an escape, it's not a comment {
* string. /*
*/ * If the '#' char is preceeded by
if (s == buf * an escape, it's not a comment
|| *(s - 1) != '\\') * string.
break; */
} if (s == buf || *(s - 1) != '\\')
++s; break;
} }
*s = '\0'; ++s;
}
*s = '\0';
/* skip leading whitespace */ /* skip leading whitespace */
s = buf; s = buf;
while (*s && isspace((unsigned char)*s)) while (*s && isspace ((unsigned char) *s))
s++; s++;
/* skip blank lines and comments */ /* skip blank lines and comments */
if (*s == '\0') if (*s == '\0')
continue; continue;
if (!p) /* head of list */ if (!p) /* head of list */
fl = p = fl = p = safecalloc (1, sizeof (struct filter_list));
safecalloc(1, else
sizeof(struct { /* next entry */
filter_list)); p->next = safecalloc (1, sizeof (struct filter_list));
else { /* next entry */ p = p->next;
p->next = }
safecalloc(1,
sizeof(struct
filter_list));
p = p->next;
}
p->pat = safestrdup(s); p->pat = safestrdup (s);
p->cpat = safemalloc(sizeof(regex_t)); p->cpat = safemalloc (sizeof (regex_t));
if ((err = if ((err = regcomp (p->cpat, p->pat, cflags)) != 0)
regcomp(p->cpat, p->pat, cflags)) != 0) { {
fprintf(stderr, "Bad regex in %s: %s\n", fprintf (stderr, "Bad regex in %s: %s\n",
config.filter, p->pat); config.filter, p->pat);
exit(EX_DATAERR); exit (EX_DATAERR);
} }
} }
if (ferror(fd)) { if (ferror (fd))
perror("fgets"); {
exit(EX_DATAERR); perror ("fgets");
} exit (EX_DATAERR);
fclose(fd); }
fclose (fd);
already_init = 1; already_init = 1;
} }
} }
} }
/* unlink the list */ /* unlink the list */
void void
filter_destroy(void) filter_destroy (void)
{ {
struct filter_list *p, *q; struct filter_list *p, *q;
if (already_init) { if (already_init)
for (p = q = fl; p; p = q) { {
regfree(p->cpat); for (p = q = fl; p; p = q)
safefree(p->cpat); {
safefree(p->pat); regfree (p->cpat);
q = p->next; safefree (p->cpat);
safefree(p); safefree (p->pat);
} q = p->next;
fl = NULL; safefree (p);
already_init = 0; }
} fl = NULL;
already_init = 0;
}
} }
/* Return 0 to allow, non-zero to block */ /* Return 0 to allow, non-zero to block */
int int
filter_domain(const char *host) filter_domain (const char *host)
{ {
struct filter_list *p; struct filter_list *p;
int result; int result;
if (!fl || !already_init) if (!fl || !already_init)
goto COMMON_EXIT; goto COMMON_EXIT;
for (p = fl; p; p = p->next) { for (p = fl; p; p = p->next)
result = {
regexec(p->cpat, host, (size_t) 0, (regmatch_t *) 0, 0); result = regexec (p->cpat, host, (size_t) 0, (regmatch_t *) 0, 0);
if (result == 0) { if (result == 0)
if (default_policy == FILTER_DEFAULT_ALLOW) {
return 1; if (default_policy == FILTER_DEFAULT_ALLOW)
else return 1;
return 0; else
} return 0;
} }
}
COMMON_EXIT: COMMON_EXIT:
if (default_policy == FILTER_DEFAULT_ALLOW) if (default_policy == FILTER_DEFAULT_ALLOW)
return 0; return 0;
else else
return 1; return 1;
} }
/* returns 0 to allow, non-zero to block */ /* returns 0 to allow, non-zero to block */
int int
filter_url(const char *url) filter_url (const char *url)
{ {
struct filter_list *p; struct filter_list *p;
int result; int result;
if (!fl || !already_init) if (!fl || !already_init)
goto COMMON_EXIT; goto COMMON_EXIT;
for (p = fl; p; p = p->next) { for (p = fl; p; p = p->next)
result = regexec(p->cpat, url, (size_t) 0, (regmatch_t *) 0, 0); {
result = regexec (p->cpat, url, (size_t) 0, (regmatch_t *) 0, 0);
if (result == 0) { if (result == 0)
if (default_policy == FILTER_DEFAULT_ALLOW) {
return 1; if (default_policy == FILTER_DEFAULT_ALLOW)
else return 1;
return 0; else
} return 0;
} }
}
COMMON_EXIT: COMMON_EXIT:
if (default_policy == FILTER_DEFAULT_ALLOW) if (default_policy == FILTER_DEFAULT_ALLOW)
return 0; return 0;
else else
return 1; return 1;
} }
/* /*
* Set the default filtering policy * Set the default filtering policy
*/ */
void void
filter_set_default_policy(filter_policy_t policy) filter_set_default_policy (filter_policy_t policy)
{ {
default_policy = policy; default_policy = policy;
} }

17
src/filter.h
View File

@ -21,16 +21,17 @@
#ifndef _TINYPROXY_FILTER_H_ #ifndef _TINYPROXY_FILTER_H_
#define _TINYPROXY_FILTER_H_ #define _TINYPROXY_FILTER_H_
typedef enum { typedef enum
FILTER_DEFAULT_ALLOW, {
FILTER_DEFAULT_DENY, FILTER_DEFAULT_ALLOW,
FILTER_DEFAULT_DENY,
} filter_policy_t; } filter_policy_t;
extern void filter_init(void); extern void filter_init (void);
extern void filter_destroy(void); extern void filter_destroy (void);
extern int filter_domain(const char *host); extern int filter_domain (const char *host);
extern int filter_url(const char *url); extern int filter_url (const char *url);
extern void filter_set_default_policy(filter_policy_t policy); extern void filter_set_default_policy (filter_policy_t policy);
#endif #endif

532
src/hashmap.c
View File

@ -37,23 +37,26 @@
* internal use. It stores the number of buckets the hashmap was created * internal use. It stores the number of buckets the hashmap was created
* with. * with.
*/ */
struct hashentry_s { struct hashentry_s
char *key; {
void *data; char *key;
size_t len; void *data;
size_t len;
struct hashentry_s *prev, *next; struct hashentry_s *prev, *next;
}; };
struct hashbucket_s { struct hashbucket_s
struct hashentry_s *head, *tail; {
struct hashentry_s *head, *tail;
}; };
struct hashmap_s { struct hashmap_s
unsigned int size; {
hashmap_iter end_iterator; unsigned int size;
hashmap_iter end_iterator;
struct hashbucket_s *buckets; struct hashbucket_s *buckets;
}; };
/* /*
@ -66,25 +69,26 @@ struct hashmap_s {
* If any of the arguments are invalid a negative number is returned. * If any of the arguments are invalid a negative number is returned.
*/ */
static int static int
hashfunc(const char *key, unsigned int size) hashfunc (const char *key, unsigned int size)
{ {
uint32_t hash; uint32_t hash;
if (key == NULL) if (key == NULL)
return -EINVAL; return -EINVAL;
if (size == 0) if (size == 0)
return -ERANGE; return -ERANGE;
for (hash = tolower(*key++); *key != '\0'; key++) { for (hash = tolower (*key++); *key != '\0'; key++)
uint32_t bit = (hash & 1) ? (1 << (sizeof(uint32_t) - 1)) : 0; {
uint32_t bit = (hash & 1) ? (1 << (sizeof (uint32_t) - 1)) : 0;
hash >>= 1; hash >>= 1;
hash += tolower(*key) + bit; hash += tolower (*key) + bit;
} }
/* Keep the hash within the table limits */ /* Keep the hash within the table limits */
return hash % size; return hash % size;
} }
/* /*
@ -95,28 +99,29 @@ hashfunc(const char *key, unsigned int size)
* NULLs are also returned if memory could not be allocated for hashmap. * NULLs are also returned if memory could not be allocated for hashmap.
*/ */
hashmap_t hashmap_t
hashmap_create(unsigned int nbuckets) hashmap_create (unsigned int nbuckets)
{ {
struct hashmap_s *ptr; struct hashmap_s *ptr;
if (nbuckets == 0) if (nbuckets == 0)
return NULL; return NULL;
ptr = safecalloc(1, sizeof(struct hashmap_s)); ptr = safecalloc (1, sizeof (struct hashmap_s));
if (!ptr) if (!ptr)
return NULL; return NULL;
ptr->size = nbuckets; ptr->size = nbuckets;
ptr->buckets = safecalloc(nbuckets, sizeof(struct hashbucket_s)); ptr->buckets = safecalloc (nbuckets, sizeof (struct hashbucket_s));
if (!ptr->buckets) { if (!ptr->buckets)
safefree(ptr); {
return NULL; safefree (ptr);
} return NULL;
}
/* This points to "one" past the end of the hashmap. */ /* This points to "one" past the end of the hashmap. */
ptr->end_iterator = 0; ptr->end_iterator = 0;
return ptr; return ptr;
} }
/* /*
@ -127,26 +132,27 @@ hashmap_create(unsigned int nbuckets)
* negative number is returned if "entry" was NULL * negative number is returned if "entry" was NULL
*/ */
static inline int static inline int
delete_hashbucket(struct hashbucket_s *bucket) delete_hashbucket (struct hashbucket_s *bucket)
{ {
struct hashentry_s *nextptr; struct hashentry_s *nextptr;
struct hashentry_s *ptr; struct hashentry_s *ptr;
if (bucket == NULL || bucket->head == NULL) if (bucket == NULL || bucket->head == NULL)
return -EINVAL; return -EINVAL;
ptr = bucket->head; ptr = bucket->head;
while (ptr) { while (ptr)
nextptr = ptr->next; {
nextptr = ptr->next;
safefree(ptr->key); safefree (ptr->key);
safefree(ptr->data); safefree (ptr->data);
safefree(ptr); safefree (ptr);
ptr = nextptr; ptr = nextptr;
} }
return 0; return 0;
} }
/* /*
@ -156,23 +162,25 @@ delete_hashbucket(struct hashbucket_s *bucket)
* negative if a NULL "map" was supplied * negative if a NULL "map" was supplied
*/ */
int int
hashmap_delete(hashmap_t map) hashmap_delete (hashmap_t map)
{ {
unsigned int i; unsigned int i;
if (map == NULL) if (map == NULL)
return -EINVAL; return -EINVAL;
for (i = 0; i != map->size; i++) { for (i = 0; i != map->size; i++)
if (map->buckets[i].head != NULL) { {
delete_hashbucket(&map->buckets[i]); if (map->buckets[i].head != NULL)
} {
} delete_hashbucket (&map->buckets[i]);
}
}
safefree(map->buckets); safefree (map->buckets);
safefree(map); safefree (map);
return 0; return 0;
} }
/* /*
@ -186,67 +194,69 @@ hashmap_delete(hashmap_t map)
* negative number if there are errors * negative number if there are errors
*/ */
int int
hashmap_insert(hashmap_t map, const char *key, const void *data, size_t len) hashmap_insert (hashmap_t map, const char *key, const void *data, size_t len)
{ {
struct hashentry_s *ptr; struct hashentry_s *ptr;
int hash; int hash;
char *key_copy; char *key_copy;
void *data_copy; void *data_copy;
assert(map != NULL); assert (map != NULL);
assert(key != NULL); assert (key != NULL);
assert(data != NULL); assert (data != NULL);
assert(len > 0); assert (len > 0);
if (map == NULL || key == NULL) if (map == NULL || key == NULL)
return -EINVAL; return -EINVAL;
if (!data || len < 1) if (!data || len < 1)
return -ERANGE; return -ERANGE;
hash = hashfunc(key, map->size); hash = hashfunc (key, map->size);
if (hash < 0) if (hash < 0)
return hash; return hash;
/* /*
* First make copies of the key and data in case there is a memory * First make copies of the key and data in case there is a memory
* problem later. * problem later.
*/ */
key_copy = safestrdup(key); key_copy = safestrdup (key);
if (!key_copy) if (!key_copy)
return -ENOMEM; return -ENOMEM;
data_copy = safemalloc(len); data_copy = safemalloc (len);
if (!data_copy) { if (!data_copy)
safefree(key_copy); {
return -ENOMEM; safefree (key_copy);
} return -ENOMEM;
memcpy(data_copy, data, len); }
memcpy (data_copy, data, len);
ptr = safemalloc(sizeof(struct hashentry_s)); ptr = safemalloc (sizeof (struct hashentry_s));
if (!ptr) { if (!ptr)
safefree(key_copy); {
safefree(data_copy); safefree (key_copy);
return -ENOMEM; safefree (data_copy);
} return -ENOMEM;
}
ptr->key = key_copy; ptr->key = key_copy;
ptr->data = data_copy; ptr->data = data_copy;
ptr->len = len; ptr->len = len;
/* /*
* Now add the entry to the end of the bucket chain. * Now add the entry to the end of the bucket chain.
*/ */
ptr->next = NULL; ptr->next = NULL;
ptr->prev = map->buckets[hash].tail; ptr->prev = map->buckets[hash].tail;
if (map->buckets[hash].tail) if (map->buckets[hash].tail)
map->buckets[hash].tail->next = ptr; map->buckets[hash].tail->next = ptr;
map->buckets[hash].tail = ptr; map->buckets[hash].tail = ptr;
if (!map->buckets[hash].head) if (!map->buckets[hash].head)
map->buckets[hash].head = ptr; map->buckets[hash].head = ptr;
map->end_iterator++; map->end_iterator++;
return 0; return 0;
} }
/* /*
@ -255,17 +265,17 @@ hashmap_insert(hashmap_t map, const char *key, const void *data, size_t len)
* Returns: an negative value upon error. * Returns: an negative value upon error.
*/ */
hashmap_iter hashmap_iter
hashmap_first(hashmap_t map) hashmap_first (hashmap_t map)
{ {
assert(map != NULL); assert (map != NULL);
if (!map) if (!map)
return -EINVAL; return -EINVAL;
if (map->end_iterator == 0) if (map->end_iterator == 0)
return -1; return -1;
else else
return 0; return 0;
} }
/* /*
@ -275,18 +285,18 @@ hashmap_first(hashmap_t map)
* 0 otherwise * 0 otherwise
*/ */
int int
hashmap_is_end(hashmap_t map, hashmap_iter iter) hashmap_is_end (hashmap_t map, hashmap_iter iter)
{ {
assert(map != NULL); assert (map != NULL);
assert(iter >= 0); assert (iter >= 0);
if (!map || iter < 0) if (!map || iter < 0)
return -EINVAL; return -EINVAL;
if (iter == map->end_iterator) if (iter == map->end_iterator)
return 1; return 1;
else else
return 0; return 0;
} }
/* /*
@ -298,37 +308,40 @@ hashmap_is_end(hashmap_t map, hashmap_iter iter)
* an "end-iterator" if the key wasn't found * an "end-iterator" if the key wasn't found
*/ */
hashmap_iter hashmap_iter
hashmap_find(hashmap_t map, const char *key) hashmap_find (hashmap_t map, const char *key)
{ {
unsigned int i; unsigned int i;
hashmap_iter iter = 0; hashmap_iter iter = 0;
struct hashentry_s *ptr; struct hashentry_s *ptr;
assert(map != NULL); assert (map != NULL);
assert(key != NULL); assert (key != NULL);
if (!map || !key) if (!map || !key)
return -EINVAL; return -EINVAL;
/* /*
* Loop through all the keys and look for the first occurrence * Loop through all the keys and look for the first occurrence
* of a particular key. * of a particular key.
*/ */
for (i = 0; i != map->size; i++) { for (i = 0; i != map->size; i++)
ptr = map->buckets[i].head; {
ptr = map->buckets[i].head;
while (ptr) { while (ptr)
if (strcasecmp(ptr->key, key) == 0) { {
/* Found it, so return the current count */ if (strcasecmp (ptr->key, key) == 0)
return iter; {
} /* Found it, so return the current count */
return iter;
}
iter++; iter++;
ptr = ptr->next; ptr = ptr->next;
} }
} }
return iter; return iter;
} }
/* /*
@ -338,37 +351,41 @@ hashmap_find(hashmap_t map, const char *key)
* negative upon error * negative upon error
*/ */
ssize_t ssize_t
hashmap_return_entry(hashmap_t map, hashmap_iter iter, char **key, void **data) hashmap_return_entry (hashmap_t map, hashmap_iter iter, char **key,
void **data)
{ {
unsigned int i; unsigned int i;
struct hashentry_s *ptr; struct hashentry_s *ptr;
hashmap_iter count = 0; hashmap_iter count = 0;
assert(map != NULL); assert (map != NULL);
assert(iter >= 0); assert (iter >= 0);
assert(iter != map->end_iterator); assert (iter != map->end_iterator);
assert(key != NULL); assert (key != NULL);
assert(data != NULL); assert (data != NULL);
if (!map || iter < 0 || !key || !data) if (!map || iter < 0 || !key || !data)
return -EINVAL; return -EINVAL;
for (i = 0; i != map->size; i++) { for (i = 0; i != map->size; i++)
ptr = map->buckets[i].head; {
while (ptr) { ptr = map->buckets[i].head;
if (count == iter) { while (ptr)
/* This is the data so return it */ {
*key = ptr->key; if (count == iter)
*data = ptr->data; {
return ptr->len; /* This is the data so return it */
} *key = ptr->key;
*data = ptr->data;
return ptr->len;
}
ptr = ptr->next; ptr = ptr->next;
count++; count++;
} }
} }
return -EFAULT; return -EFAULT;
} }
/* /*
@ -379,31 +396,32 @@ hashmap_return_entry(hashmap_t map, hashmap_iter iter, char **key, void **data)
* count found * count found
*/ */
ssize_t ssize_t
hashmap_search(hashmap_t map, const char *key) hashmap_search (hashmap_t map, const char *key)
{ {
int hash; int hash;
struct hashentry_s *ptr; struct hashentry_s *ptr;
ssize_t count = 0; ssize_t count = 0;
if (map == NULL || key == NULL) if (map == NULL || key == NULL)
return -EINVAL; return -EINVAL;
hash = hashfunc(key, map->size); hash = hashfunc (key, map->size);
if (hash < 0) if (hash < 0)
return hash; return hash;
ptr = map->buckets[hash].head; ptr = map->buckets[hash].head;
/* All right, there is an entry here, now see if it's the one we want */ /* All right, there is an entry here, now see if it's the one we want */
while (ptr) { while (ptr)
if (strcasecmp(ptr->key, key) == 0) {
++count; if (strcasecmp (ptr->key, key) == 0)
++count;
/* This entry didn't contain the key; move to the next one */ /* This entry didn't contain the key; move to the next one */
ptr = ptr->next; ptr = ptr->next;
} }
return count; return count;
} }
/* /*
@ -415,30 +433,32 @@ hashmap_search(hashmap_t map, const char *key)
* length of data for the entry * length of data for the entry
*/ */
ssize_t ssize_t
hashmap_entry_by_key(hashmap_t map, const char *key, void **data) hashmap_entry_by_key (hashmap_t map, const char *key, void **data)
{ {
int hash; int hash;
struct hashentry_s *ptr; struct hashentry_s *ptr;
if (!map || !key || !data) if (!map || !key || !data)
return -EINVAL; return -EINVAL;
hash = hashfunc(key, map->size); hash = hashfunc (key, map->size);
if (hash < 0) if (hash < 0)
return hash; return hash;
ptr = map->buckets[hash].head; ptr = map->buckets[hash].head;
while (ptr) { while (ptr)
if (strcasecmp(ptr->key, key) == 0) { {
*data = ptr->data; if (strcasecmp (ptr->key, key) == 0)
return ptr->len; {
} *data = ptr->data;
return ptr->len;
}
ptr = ptr->next; ptr = ptr->next;
} }
return 0; return 0;
} }
/* /*
@ -450,53 +470,55 @@ hashmap_entry_by_key(hashmap_t map, const char *key, void **data)
* positive count of entries deleted * positive count of entries deleted
*/ */
ssize_t ssize_t
hashmap_remove(hashmap_t map, const char *key) hashmap_remove (hashmap_t map, const char *key)
{ {
int hash; int hash;
struct hashentry_s *ptr, *next; struct hashentry_s *ptr, *next;
short int deleted = 0; short int deleted = 0;
if (map == NULL || key == NULL) if (map == NULL || key == NULL)
return -EINVAL; return -EINVAL;
hash = hashfunc(key, map->size); hash = hashfunc (key, map->size);
if (hash < 0) if (hash < 0)
return hash; return hash;
ptr = map->buckets[hash].head; ptr = map->buckets[hash].head;
while (ptr) { while (ptr)
if (strcasecmp(ptr->key, key) == 0) { {
/* if (strcasecmp (ptr->key, key) == 0)
* Found the data, now need to remove everything {
* and update the hashmap. /*
*/ * Found the data, now need to remove everything
next = ptr->next; * and update the hashmap.
*/
next = ptr->next;
if (ptr->prev) if (ptr->prev)
ptr->prev->next = ptr->next; ptr->prev->next = ptr->next;
if (ptr->next) if (ptr->next)
ptr->next->prev = ptr->prev; ptr->next->prev = ptr->prev;
if (map->buckets[hash].head == ptr) if (map->buckets[hash].head == ptr)
map->buckets[hash].head = ptr->next; map->buckets[hash].head = ptr->next;
if (map->buckets[hash].tail == ptr) if (map->buckets[hash].tail == ptr)
map->buckets[hash].tail = ptr->prev; map->buckets[hash].tail = ptr->prev;
safefree(ptr->key); safefree (ptr->key);
safefree(ptr->data); safefree (ptr->data);
safefree(ptr); safefree (ptr);
++deleted; ++deleted;
--map->end_iterator; --map->end_iterator;
ptr = next; ptr = next;
continue; continue;
} }
/* This entry didn't contain the key; move to the next one */ /* This entry didn't contain the key; move to the next one */
ptr = ptr->next; ptr = ptr->next;
} }
/* The key was not found, so return 0 */ /* The key was not found, so return 0 */
return deleted; return deleted;
} }

37
src/hashmap.h
View File

@ -23,7 +23,8 @@
/* Allow the use in C++ code. */ /* Allow the use in C++ code. */
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
/* /*
@ -31,15 +32,15 @@ extern "C" {
* hash map. Sure, it's a pointer, but the struct is hidden in the C file. * hash map. Sure, it's a pointer, but the struct is hidden in the C file.
* So, just use the hashmap_t like it's a cookie. :) * So, just use the hashmap_t like it's a cookie. :)
*/ */
typedef struct hashmap_s *hashmap_t; typedef struct hashmap_s *hashmap_t;
typedef int hashmap_iter; typedef int hashmap_iter;
/* /*
* hashmap_create() takes one argument, which is the number of buckets to * hashmap_create() takes one argument, which is the number of buckets to
* use internally. hashmap_delete() is self explanatory. * use internally. hashmap_delete() is self explanatory.
*/ */
extern hashmap_t hashmap_create(unsigned int nbuckets); extern hashmap_t hashmap_create (unsigned int nbuckets);
extern int hashmap_delete(hashmap_t map); extern int hashmap_delete (hashmap_t map);
/* /*
* When the you insert a key/data pair into the hashmap it will the key * When the you insert a key/data pair into the hashmap it will the key
@ -50,15 +51,15 @@ extern "C" {
* Returns: negative on error * Returns: negative on error
* 0 upon successful insert * 0 upon successful insert
*/ */
extern int hashmap_insert(hashmap_t map, const char *key, extern int hashmap_insert (hashmap_t map, const char *key,
const void *data, size_t len); const void *data, size_t len);
/* /*
* Get an iterator to the first entry. * Get an iterator to the first entry.
* *
* Returns: an negative value upon error. * Returns: an negative value upon error.
*/ */
extern hashmap_iter hashmap_first(hashmap_t map); extern hashmap_iter hashmap_first (hashmap_t map);
/* /*
* Checks to see if the iterator is pointing at the "end" of the entries. * Checks to see if the iterator is pointing at the "end" of the entries.
@ -66,7 +67,7 @@ extern "C" {
* Returns: 1 if it is the end * Returns: 1 if it is the end
* 0 otherwise * 0 otherwise
*/ */
extern int hashmap_is_end(hashmap_t map, hashmap_iter iter); extern int hashmap_is_end (hashmap_t map, hashmap_iter iter);
/* /*
* Return a "pointer" to the first instance of the particular key. It can * Return a "pointer" to the first instance of the particular key. It can
@ -76,7 +77,7 @@ extern "C" {
* an "iterator" pointing at the first key * an "iterator" pointing at the first key
* an "end-iterator" if the key wasn't found * an "end-iterator" if the key wasn't found
*/ */
extern hashmap_iter hashmap_find(hashmap_t map, const char *key); extern hashmap_iter hashmap_find (hashmap_t map, const char *key);
/* /*
* Retrieve the key/data associated with a particular iterator. * Retrieve the key/data associated with a particular iterator.
@ -86,8 +87,8 @@ extern "C" {
* Returns: the length of the data block upon success * Returns: the length of the data block upon success
* negative upon error * negative upon error
*/ */
extern ssize_t hashmap_return_entry(hashmap_t map, hashmap_iter iter, extern ssize_t hashmap_return_entry (hashmap_t map, hashmap_iter iter,
char **key, void **data); char **key, void **data);
/* /*
* Get the first entry (assuming there is more than one) for a particular * Get the first entry (assuming there is more than one) for a particular
@ -97,8 +98,8 @@ extern "C" {
* zero if no entry is found * zero if no entry is found
* length of data for the entry * length of data for the entry
*/ */
extern ssize_t hashmap_entry_by_key(hashmap_t map, const char *key, extern ssize_t hashmap_entry_by_key (hashmap_t map, const char *key,
void **data); void **data);
/* /*
* Searches for _any_ occurrances of "key" within the hashmap and returns the * Searches for _any_ occurrances of "key" within the hashmap and returns the
@ -108,7 +109,7 @@ extern "C" {
* zero if no key is found * zero if no key is found
* count found (positive value) * count found (positive value)
*/ */
extern ssize_t hashmap_search(hashmap_t map, const char *key); extern ssize_t hashmap_search (hashmap_t map, const char *key);
/* /*
* Go through the hashmap and remove the particular key. * Go through the hashmap and remove the particular key.
@ -118,9 +119,9 @@ extern "C" {
* 0 if the key was not found * 0 if the key was not found
* positive count of entries deleted * positive count of entries deleted
*/ */
extern ssize_t hashmap_remove(hashmap_t map, const char *key); extern ssize_t hashmap_remove (hashmap_t map, const char *key);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif /* C++ */ #endif /* C++ */
#endif /* _HASHMAP_H */ #endif /* _HASHMAP_H */

135
src/heap.c
View File

@ -28,71 +28,72 @@
#include "text.h" #include "text.h"
void * void *
debugging_calloc(size_t nmemb, size_t size, const char *file, debugging_calloc (size_t nmemb, size_t size, const char *file,
unsigned long line) unsigned long line)
{ {
void *ptr; void *ptr;
assert(nmemb > 0); assert (nmemb > 0);
assert(size > 0); assert (size > 0);
ptr = calloc(nmemb, size); ptr = calloc (nmemb, size);
fprintf(stderr, "{calloc: %p:%zu x %zu} %s:%lu\n", ptr, nmemb, size, file, fprintf (stderr, "{calloc: %p:%zu x %zu} %s:%lu\n", ptr, nmemb, size, file,
line); line);
return ptr; return ptr;
} }
void * void *
debugging_malloc(size_t size, const char *file, unsigned long line) debugging_malloc (size_t size, const char *file, unsigned long line)
{ {
void *ptr; void *ptr;
assert(size > 0); assert (size > 0);
ptr = malloc(size); ptr = malloc (size);
fprintf(stderr, "{malloc: %p:%zu} %s:%lu\n", ptr, size, file, line); fprintf (stderr, "{malloc: %p:%zu} %s:%lu\n", ptr, size, file, line);
return ptr; return ptr;
} }
void * void *
debugging_realloc(void *ptr, size_t size, const char *file, unsigned long line) debugging_realloc (void *ptr, size_t size, const char *file,
unsigned long line)
{ {
void *newptr; void *newptr;
assert(size > 0); assert (size > 0);
newptr = realloc(ptr, size); newptr = realloc (ptr, size);
fprintf(stderr, "{realloc: %p -> %p:%zu} %s:%lu\n", ptr, newptr, size, fprintf (stderr, "{realloc: %p -> %p:%zu} %s:%lu\n", ptr, newptr, size,
file, line); file, line);
return newptr; return newptr;
} }
void void
debugging_free(void *ptr, const char *file, unsigned long line) debugging_free (void *ptr, const char *file, unsigned long line)
{ {
fprintf(stderr, "{free: %p} %s:%lu\n", ptr, file, line); fprintf (stderr, "{free: %p} %s:%lu\n", ptr, file, line);
if (ptr != NULL) if (ptr != NULL)
free(ptr); free (ptr);
return; return;
} }
char * char *
debugging_strdup(const char *s, const char *file, unsigned long line) debugging_strdup (const char *s, const char *file, unsigned long line)
{ {
char *ptr; char *ptr;
size_t len; size_t len;
assert(s != NULL); assert (s != NULL);
len = strlen(s) + 1; len = strlen (s) + 1;
ptr = malloc(len); ptr = malloc (len);
if (!ptr) if (!ptr)
return NULL; return NULL;
memcpy(ptr, s, len); memcpy (ptr, s, len);
fprintf(stderr, "{strdup: %p:%zu} %s:%lu\n", ptr, len, file, line); fprintf (stderr, "{strdup: %p:%zu} %s:%lu\n", ptr, len, file, line);
return ptr; return ptr;
} }
/* /*
@ -104,32 +105,32 @@ debugging_strdup(const char *s, const char *file, unsigned long line)
* solution. * solution.
*/ */
void * void *
malloc_shared_memory(size_t size) malloc_shared_memory (size_t size)
{ {
int fd; int fd;
void *ptr; void *ptr;
char buffer[32]; char buffer[32];
static char *shared_file = "/tmp/tinyproxy.shared.XXXXXX"; static char *shared_file = "/tmp/tinyproxy.shared.XXXXXX";
assert(size > 0); assert (size > 0);
strlcpy(buffer, shared_file, sizeof(buffer)); strlcpy (buffer, shared_file, sizeof (buffer));
/* Only allow u+rw bits. This may be required for some versions /* Only allow u+rw bits. This may be required for some versions
* of glibc so that mkstemp() doesn't make us vulnerable. * of glibc so that mkstemp() doesn't make us vulnerable.
*/ */
umask(0177); umask (0177);
if ((fd = mkstemp(buffer)) == -1) if ((fd = mkstemp (buffer)) == -1)
return MAP_FAILED; return MAP_FAILED;
unlink(buffer); unlink (buffer);
if (ftruncate(fd, size) == -1) if (ftruncate (fd, size) == -1)
return MAP_FAILED; return MAP_FAILED;
ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); ptr = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
return ptr; return ptr;
} }
/* /*
@ -137,21 +138,21 @@ malloc_shared_memory(size_t size)
* zero. * zero.
*/ */
void * void *
calloc_shared_memory(size_t nmemb, size_t size) calloc_shared_memory (size_t nmemb, size_t size)
{ {
void *ptr; void *ptr;
long length; long length;
assert(nmemb > 0); assert (nmemb > 0);
assert(size > 0); assert (size > 0);
length = nmemb * size; length = nmemb * size;
ptr = malloc_shared_memory(length); ptr = malloc_shared_memory (length);
if (ptr == MAP_FAILED) if (ptr == MAP_FAILED)
return ptr; return ptr;
memset(ptr, 0, length); memset (ptr, 0, length);
return ptr; return ptr;
} }

22
src/heap.h
View File

@ -26,15 +26,15 @@
*/ */
#ifndef NDEBUG #ifndef NDEBUG
extern void *debugging_calloc(size_t nmemb, size_t size, const char *file, extern void *debugging_calloc (size_t nmemb, size_t size, const char *file,
unsigned long line); unsigned long line);
extern void *debugging_malloc(size_t size, const char *file, extern void *debugging_malloc (size_t size, const char *file,
unsigned long line); unsigned long line);
extern void debugging_free(void *ptr, const char *file, unsigned long line); extern void debugging_free (void *ptr, const char *file, unsigned long line);
extern void *debugging_realloc(void *ptr, size_t size, const char *file, extern void *debugging_realloc (void *ptr, size_t size, const char *file,
unsigned long line); unsigned long line);
extern char *debugging_strdup(const char *s, const char *file, extern char *debugging_strdup (const char *s, const char *file,
unsigned long line); unsigned long line);
# define safecalloc(x, y) debugging_calloc(x, y, __FILE__, __LINE__) # define safecalloc(x, y) debugging_calloc(x, y, __FILE__, __LINE__)
# define safemalloc(x) debugging_malloc(x, __FILE__, __LINE__) # define safemalloc(x) debugging_malloc(x, __FILE__, __LINE__)
@ -60,7 +60,7 @@ free(*__safefree_tmp); \
/* /*
* Allocate memory from the "shared" region of memory. * Allocate memory from the "shared" region of memory.
*/ */
extern void *malloc_shared_memory(size_t size); extern void *malloc_shared_memory (size_t size);
extern void *calloc_shared_memory(size_t nmemb, size_t size); extern void *calloc_shared_memory (size_t nmemb, size_t size);
#endif #endif

347
src/html-error.c
View File

@ -33,77 +33,77 @@
/* /*
* Add an error number -> filename mapping to the errorpages list. * Add an error number -> filename mapping to the errorpages list.
*/ */
#define ERRORNUM_BUFSIZE 8 /* this is more than required */ #define ERRORNUM_BUFSIZE 8 /* this is more than required */
#define ERRPAGES_BUCKETCOUNT 16 #define ERRPAGES_BUCKETCOUNT 16
int int
add_new_errorpage(char *filepath, unsigned int errornum) add_new_errorpage (char *filepath, unsigned int errornum)
{ {
char errornbuf[ERRORNUM_BUFSIZE]; char errornbuf[ERRORNUM_BUFSIZE];
config.errorpages = hashmap_create(ERRPAGES_BUCKETCOUNT); config.errorpages = hashmap_create (ERRPAGES_BUCKETCOUNT);
if (!config.errorpages) if (!config.errorpages)
return (-1); return (-1);
snprintf(errornbuf, ERRORNUM_BUFSIZE, "%u", errornum); snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
if (hashmap_insert(config.errorpages, errornbuf, if (hashmap_insert (config.errorpages, errornbuf,
filepath, strlen(filepath) + 1) < 0) filepath, strlen (filepath) + 1) < 0)
return (-1); return (-1);
return (0); return (0);
} }
/* /*
* Get the file appropriate for a given error. * Get the file appropriate for a given error.
*/ */
static char * static char *
get_html_file(unsigned int errornum) get_html_file (unsigned int errornum)
{ {
hashmap_iter result_iter; hashmap_iter result_iter;
char errornbuf[ERRORNUM_BUFSIZE]; char errornbuf[ERRORNUM_BUFSIZE];
char *key; char *key;
static char *val; static char *val;
assert(errornum >= 100 && errornum < 1000); assert (errornum >= 100 && errornum < 1000);
if (!config.errorpages) if (!config.errorpages)
return (config.errorpage_undef); return (config.errorpage_undef);
snprintf(errornbuf, ERRORNUM_BUFSIZE, "%u", errornum); snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
result_iter = hashmap_find(config.errorpages, errornbuf); result_iter = hashmap_find (config.errorpages, errornbuf);
if (hashmap_is_end(config.errorpages, result_iter)) if (hashmap_is_end (config.errorpages, result_iter))
return (config.errorpage_undef); return (config.errorpage_undef);
if (hashmap_return_entry(config.errorpages, result_iter, if (hashmap_return_entry (config.errorpages, result_iter,
&key, (void **)&val) < 0) &key, (void **) &val) < 0)
return (config.errorpage_undef); return (config.errorpage_undef);
return (val); return (val);
} }
/* /*
* Look up the value for a variable. * Look up the value for a variable.
*/ */
static char * static char *
lookup_variable(struct conn_s *connptr, char *varname) lookup_variable (struct conn_s *connptr, char *varname)
{ {
hashmap_iter result_iter; hashmap_iter result_iter;
char *key; char *key;
static char *data; static char *data;
result_iter = hashmap_find(connptr->error_variables, varname); result_iter = hashmap_find (connptr->error_variables, varname);
if (hashmap_is_end(connptr->error_variables, result_iter)) if (hashmap_is_end (connptr->error_variables, result_iter))
return (NULL); return (NULL);
if (hashmap_return_entry(connptr->error_variables, result_iter, if (hashmap_return_entry (connptr->error_variables, result_iter,
&key, (void **)&data) < 0) &key, (void **) &data) < 0)
return (NULL); return (NULL);
return (data); return (data);
} }
#define HTML_BUFSIZE 4096 #define HTML_BUFSIZE 4096
@ -112,116 +112,113 @@ lookup_variable(struct conn_s *connptr, char *varname)
* Send an already-opened file to the client with variable substitution. * Send an already-opened file to the client with variable substitution.
*/ */
int int
send_html_file(FILE * infile, struct conn_s *connptr) send_html_file (FILE * infile, struct conn_s *connptr)
{ {
char inbuf[HTML_BUFSIZE], *varstart = NULL, *p; char inbuf[HTML_BUFSIZE], *varstart = NULL, *p;
char *varval; char *varval;
int in_variable = 0, writeret; int in_variable = 0, writeret;
while (fgets(inbuf, HTML_BUFSIZE, infile) != NULL) { while (fgets (inbuf, HTML_BUFSIZE, infile) != NULL)
for (p = inbuf; *p; p++) { {
switch (*p) { for (p = inbuf; *p; p++)
case '}': {
if (in_variable) { switch (*p)
*p = '\0'; {
if (! case '}':
(varval = if (in_variable)
lookup_variable(connptr, {
varstart))) *p = '\0';
varval = "(unknown)"; if (!(varval = lookup_variable (connptr, varstart)))
writeret = varval = "(unknown)";
write_message(connptr->client_fd, writeret = write_message (connptr->client_fd, "%s", varval);
"%s", varval); if (writeret)
if (writeret) return (writeret);
return (writeret); in_variable = 0;
in_variable = 0; }
} else { else
writeret = {
write_message(connptr->client_fd, writeret = write_message (connptr->client_fd, "%c", *p);
"%c", *p); if (writeret)
if (writeret) return (writeret);
return (writeret); }
} break;
break; case '{':
case '{': /* a {{ will print a single {. If we are NOT
/* a {{ will print a single {. If we are NOT * already in a { variable, then proceed with
* already in a { variable, then proceed with * setup. If we ARE already in a { variable,
* setup. If we ARE already in a { variable, * this code will fallthrough to the code that
* this code will fallthrough to the code that * just dumps a character to the client fd.
* just dumps a character to the client fd. */
*/ if (!in_variable)
if (!in_variable) { {
varstart = p + 1; varstart = p + 1;
in_variable++; in_variable++;
} else }
in_variable = 0; else
default: in_variable = 0;
if (!in_variable) { default:
writeret = if (!in_variable)
write_message(connptr->client_fd, {
"%c", *p); writeret = write_message (connptr->client_fd, "%c", *p);
if (writeret) if (writeret)
return (writeret); return (writeret);
} }
} }
} }
in_variable = 0; in_variable = 0;
} }
return (0); return (0);
} }
int int
send_http_headers(struct conn_s *connptr, int code, char *message) send_http_headers (struct conn_s *connptr, int code, char *message)
{ {
char *headers = char *headers =
"HTTP/1.0 %d %s\r\n" "HTTP/1.0 %d %s\r\n"
"Server: %s/%s\r\n" "Server: %s/%s\r\n"
"Content-Type: text/html\r\n" "Connection: close\r\n" "\r\n"; "Content-Type: text/html\r\n" "Connection: close\r\n" "\r\n";
return (write_message(connptr->client_fd, headers, return (write_message (connptr->client_fd, headers,
code, message, PACKAGE, VERSION)); code, message, PACKAGE, VERSION));
} }
/* /*
* Display an error to the client. * Display an error to the client.
*/ */
int int
send_http_error_message(struct conn_s *connptr) send_http_error_message (struct conn_s *connptr)
{ {
char *error_file; char *error_file;
FILE *infile; FILE *infile;
int ret; int ret;
char *fallback_error = char *fallback_error =
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n" "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n"
"<html>\n" "<html>\n"
"<head><title>%d %s</title></head>\n" "<head><title>%d %s</title></head>\n"
"<body>\n" "<body>\n"
"<h1>%s</h1>\n" "<h1>%s</h1>\n"
"<p>%s</p>\n" "<p>%s</p>\n"
"<hr />\n" "<hr />\n"
"<p><em>Generated by %s version %s.</em></p>\n" "<p><em>Generated by %s version %s.</em></p>\n" "</body>\n" "</html>\n";
"</body>\n"
"</html>\n";
send_http_headers(connptr, connptr->error_number, send_http_headers (connptr, connptr->error_number, connptr->error_string);
connptr->error_string);
error_file = get_html_file(connptr->error_number); error_file = get_html_file (connptr->error_number);
if (!(infile = fopen(error_file, "r"))) { if (!(infile = fopen (error_file, "r")))
char *detail = lookup_variable(connptr, "detail"); {
return (write_message(connptr->client_fd, fallback_error, char *detail = lookup_variable (connptr, "detail");
connptr->error_number, return (write_message (connptr->client_fd, fallback_error,
connptr->error_string, connptr->error_number,
connptr->error_string, connptr->error_string,
detail, connptr->error_string,
PACKAGE, VERSION)); detail, PACKAGE, VERSION));
} }
ret = send_html_file(infile, connptr); ret = send_html_file (infile, connptr);
fclose(infile); fclose (infile);
return (ret); return (ret);
} }
/* /*
@ -231,16 +228,14 @@ send_http_error_message(struct conn_s *connptr)
#define ERRVAR_BUCKETCOUNT 16 #define ERRVAR_BUCKETCOUNT 16
int int
add_error_variable(struct conn_s *connptr, char *key, char *val) add_error_variable (struct conn_s *connptr, char *key, char *val)
{ {
if (!connptr->error_variables) if (!connptr->error_variables)
if (! if (!(connptr->error_variables = hashmap_create (ERRVAR_BUCKETCOUNT)))
(connptr->error_variables = return (-1);
hashmap_create(ERRVAR_BUCKETCOUNT)))
return (-1);
return hashmap_insert(connptr->error_variables, key, val, return hashmap_insert (connptr->error_variables, key, val,
strlen(val) + 1); strlen (val) + 1);
} }
#define ADD_VAR_RET(x, y) \ #define ADD_VAR_RET(x, y) \
@ -255,61 +250,63 @@ add_error_variable(struct conn_s *connptr, char *key, char *val)
* Set some standard variables used by all HTML pages * Set some standard variables used by all HTML pages
*/ */
int int
add_standard_vars(struct conn_s *connptr) add_standard_vars (struct conn_s *connptr)
{ {
char errnobuf[16]; char errnobuf[16];
char timebuf[30]; char timebuf[30];
time_t global_time; time_t global_time;
snprintf(errnobuf, sizeof errnobuf, "%d", connptr->error_number); snprintf (errnobuf, sizeof errnobuf, "%d", connptr->error_number);
ADD_VAR_RET("errno", errnobuf); ADD_VAR_RET ("errno", errnobuf);
ADD_VAR_RET("cause", connptr->error_string); ADD_VAR_RET ("cause", connptr->error_string);
ADD_VAR_RET("request", connptr->request_line); ADD_VAR_RET ("request", connptr->request_line);
ADD_VAR_RET("clientip", connptr->client_ip_addr); ADD_VAR_RET ("clientip", connptr->client_ip_addr);
ADD_VAR_RET("clienthost", connptr->client_string_addr); ADD_VAR_RET ("clienthost", connptr->client_string_addr);
/* The following value parts are all non-NULL and will /* The following value parts are all non-NULL and will
* trigger warnings in ADD_VAR_RET(), so we use * trigger warnings in ADD_VAR_RET(), so we use
* add_error_variable() directly. * add_error_variable() directly.
*/ */
global_time = time(NULL); global_time = time (NULL);
strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", strftime (timebuf, sizeof (timebuf), "%a, %d %b %Y %H:%M:%S GMT",
gmtime(&global_time)); gmtime (&global_time));
add_error_variable(connptr, "date", timebuf); add_error_variable (connptr, "date", timebuf);
add_error_variable(connptr, "website", "http://tinyproxy.banu.com/"); add_error_variable (connptr, "website", "http://tinyproxy.banu.com/");
add_error_variable(connptr, "version", VERSION); add_error_variable (connptr, "version", VERSION);
add_error_variable(connptr, "package", PACKAGE); add_error_variable (connptr, "package", PACKAGE);
return (0); return (0);
} }
/* /*
* Add the error information to the conn structure. * Add the error information to the conn structure.
*/ */
int int
indicate_http_error(struct conn_s *connptr, int number, char *message, ...) indicate_http_error (struct conn_s *connptr, int number, char *message, ...)
{ {
va_list ap; va_list ap;
char *key, *val; char *key, *val;
va_start(ap, message); va_start (ap, message);
while ((key = va_arg(ap, char *))) { while ((key = va_arg (ap, char *)))
val = va_arg(ap, char *); {
val = va_arg (ap, char *);
if (add_error_variable(connptr, key, val) == -1) { if (add_error_variable (connptr, key, val) == -1)
va_end(ap); {
return (-1); va_end (ap);
} return (-1);
} }
}
connptr->error_number = number; connptr->error_number = number;
connptr->error_string = safestrdup(message); connptr->error_string = safestrdup (message);
va_end(ap); va_end (ap);
return (add_standard_vars(connptr)); return (add_standard_vars (connptr));
} }

19
src/html-error.h
View File

@ -24,13 +24,14 @@
/* Forward declaration */ /* Forward declaration */
struct conn_s; struct conn_s;
extern int add_new_errorpage(char *filepath, unsigned int errornum); extern int add_new_errorpage (char *filepath, unsigned int errornum);
extern int send_http_error_message(struct conn_s *connptr); extern int send_http_error_message (struct conn_s *connptr);
extern int indicate_http_error(struct conn_s *connptr, int number, extern int indicate_http_error (struct conn_s *connptr, int number,
char *message, ...); char *message, ...);
extern int add_error_variable(struct conn_s *connptr, char *key, char *val); extern int add_error_variable (struct conn_s *connptr, char *key, char *val);
extern int send_html_file(FILE * infile, struct conn_s *connptr); extern int send_html_file (FILE * infile, struct conn_s *connptr);
extern int send_http_headers(struct conn_s *connptr, int code, char *message); extern int send_http_headers (struct conn_s *connptr, int code,
extern int add_standard_vars(struct conn_s *connptr); char *message);
extern int add_standard_vars (struct conn_s *connptr);
#endif /* !TINYPROXY_HTML_ERROR_H */ #endif /* !TINYPROXY_HTML_ERROR_H */

308
src/http-message.c
View File

@ -30,29 +30,33 @@
* Also, the caller MUST NOT free the memory while the structure is * Also, the caller MUST NOT free the memory while the structure is
* still in use---bad things would happen. * still in use---bad things would happen.
*/ */
struct http_message_s { struct http_message_s
/* Response string and code supplied on the HTTP status line */ {
struct { /* Response string and code supplied on the HTTP status line */
const char *string; struct
int code; {
} response; const char *string;
int code;
} response;
/* /*
* A group of headers to be sent with this message. Right now * A group of headers to be sent with this message. Right now
* the strings are referenced through pointers in an array. * the strings are referenced through pointers in an array.
* I might change this to a vector in the future. * I might change this to a vector in the future.
*/ */
struct { struct
char **strings; {
unsigned int total; char **strings;
unsigned int used; unsigned int total;
} headers; unsigned int used;
} headers;
/* Body of the message (most likely an HTML message) */ /* Body of the message (most likely an HTML message) */
struct { struct
const char *text; {
size_t length; const char *text;
} body; size_t length;
} body;
}; };
/* /*
@ -61,18 +65,18 @@ struct http_message_s {
* number is returned. Useful for if() tests and assert() tests. * number is returned. Useful for if() tests and assert() tests.
*/ */
static int static int
is_http_message_valid(http_message_t msg) is_http_message_valid (http_message_t msg)
{ {
if (msg == NULL) if (msg == NULL)
return 0; return 0;
if (msg->headers.strings == NULL) if (msg->headers.strings == NULL)
return 0; return 0;
if (msg->response.string == NULL) if (msg->response.string == NULL)
return 0; return 0;
if (msg->response.code < 1 || msg->response.code > 999) if (msg->response.code < 1 || msg->response.code > 999)
return 0; return 0;
return 1; return 1;
} }
/* Initially allocate space for 128 headers */ /* Initially allocate space for 128 headers */
@ -83,32 +87,34 @@ is_http_message_valid(http_message_t msg)
* If memory could not be allocated, return a NULL. * If memory could not be allocated, return a NULL.
*/ */
http_message_t http_message_t
http_message_create(int response_code, const char *response_string) http_message_create (int response_code, const char *response_string)
{ {
http_message_t msg; http_message_t msg;
int ret; int ret;
msg = safecalloc(1, sizeof(struct http_message_s)); msg = safecalloc (1, sizeof (struct http_message_s));
if (msg == NULL) if (msg == NULL)
return NULL; return NULL;
msg->headers.strings = safecalloc(NUMBER_OF_HEADERS, sizeof(char *)); msg->headers.strings = safecalloc (NUMBER_OF_HEADERS, sizeof (char *));
if (msg->headers.strings == NULL) { if (msg->headers.strings == NULL)
safefree(msg); {
return NULL; safefree (msg);
} return NULL;
}
msg->headers.total = NUMBER_OF_HEADERS; msg->headers.total = NUMBER_OF_HEADERS;
/* Store the HTTP response information in the structure */ /* Store the HTTP response information in the structure */
ret = http_message_set_response(msg, response_code, response_string); ret = http_message_set_response (msg, response_code, response_string);
if (IS_HTTP_MSG_ERROR(ret)) { if (IS_HTTP_MSG_ERROR (ret))
safefree(msg->headers.strings); {
safefree(msg); safefree (msg->headers.strings);
return NULL; safefree (msg);
} return NULL;
}
return msg; return msg;
} }
/* /*
@ -117,19 +123,19 @@ http_message_create(int response_code, const char *response_string)
* is the responsibility of the caller. * is the responsibility of the caller.
*/ */
int int
http_message_destroy(http_message_t msg) http_message_destroy (http_message_t msg)
{ {
assert(msg != NULL); assert (msg != NULL);
assert(msg->headers.strings != NULL); assert (msg->headers.strings != NULL);
/* Check for valid arguments */ /* Check for valid arguments */
if (msg == NULL) if (msg == NULL)
return -EFAULT; return -EFAULT;
if (msg->headers.strings != NULL) if (msg->headers.strings != NULL)
safefree(msg->headers.strings); safefree (msg->headers.strings);
safefree(msg); safefree (msg);
return 0; return 0;
} }
/* /*
@ -137,135 +143,135 @@ http_message_destroy(http_message_t msg)
* must be a NUL ('\0') terminated C string. * must be a NUL ('\0') terminated C string.
*/ */
int int
http_message_set_response(http_message_t msg, http_message_set_response (http_message_t msg,
int response_code, const char *response_string) int response_code, const char *response_string)
{ {
/* Check for valid arguments */ /* Check for valid arguments */
if (msg == NULL) if (msg == NULL)
return -EFAULT; return -EFAULT;
if (response_code < 1 || response_code > 999) if (response_code < 1 || response_code > 999)
return -EINVAL; return -EINVAL;
if (response_string == NULL) if (response_string == NULL)
return -EINVAL; return -EINVAL;
if (strlen(response_string) == 0) if (strlen (response_string) == 0)
return -EINVAL; return -EINVAL;
msg->response.code = response_code; msg->response.code = response_code;
msg->response.string = response_string; msg->response.string = response_string;
return 0; return 0;
} }
/* /*
* Set the HTTP message body. * Set the HTTP message body.
*/ */
int int
http_message_set_body(http_message_t msg, const char *body, size_t len) http_message_set_body (http_message_t msg, const char *body, size_t len)
{ {
/* Check for valid arguments */ /* Check for valid arguments */
if (msg == NULL) if (msg == NULL)
return -EFAULT; return -EFAULT;
if (body == NULL) if (body == NULL)
return -EINVAL; return -EINVAL;
if (len == 0) if (len == 0)
return -EINVAL; return -EINVAL;
msg->body.text = body; msg->body.text = body;
msg->body.length = len; msg->body.length = len;
return 0; return 0;
} }
/* /*
* Add headers to the structure. * Add headers to the structure.
*/ */
int int
http_message_add_headers(http_message_t msg, char **headers, int num_headers) http_message_add_headers (http_message_t msg, char **headers, int num_headers)
{ {
char **new_headers; char **new_headers;
int i; int i;
/* Check for valid arguments */ /* Check for valid arguments */
if (msg == NULL) if (msg == NULL)
return -EFAULT; return -EFAULT;
if (headers == NULL) if (headers == NULL)
return -EINVAL; return -EINVAL;
if (num_headers < 1) if (num_headers < 1)
return -EINVAL; return -EINVAL;
/* /*
* If the number of headers to add is greater than the space * If the number of headers to add is greater than the space
* available, reallocate the memory. * available, reallocate the memory.
*/ */
if (msg->headers.used + num_headers > msg->headers.total) { if (msg->headers.used + num_headers > msg->headers.total)
new_headers = safecalloc(msg->headers.total * 2, {
sizeof(char *)); new_headers = safecalloc (msg->headers.total * 2, sizeof (char *));
if (new_headers == NULL) if (new_headers == NULL)
return -ENOMEM; return -ENOMEM;
/* Copy the array */ /* Copy the array */
for (i = 0; i != msg->headers.used; ++i) for (i = 0; i != msg->headers.used; ++i)
new_headers[i] = msg->headers.strings[i]; new_headers[i] = msg->headers.strings[i];
/* Remove the old array and replace it with the new array */ /* Remove the old array and replace it with the new array */
safefree(msg->headers.strings); safefree (msg->headers.strings);
msg->headers.strings = new_headers; msg->headers.strings = new_headers;
msg->headers.total *= 2; msg->headers.total *= 2;
} }
/* /*
* Add the new headers to the structure * Add the new headers to the structure
*/ */
for (i = 0; i != num_headers; ++i) for (i = 0; i != num_headers; ++i)
msg->headers.strings[i + msg->headers.used] = headers[i]; msg->headers.strings[i + msg->headers.used] = headers[i];
msg->headers.used += num_headers; msg->headers.used += num_headers;
return 0; return 0;
} }
/* /*
* Send the completed HTTP message via the supplied file descriptor. * Send the completed HTTP message via the supplied file descriptor.
*/ */
int int
http_message_send(http_message_t msg, int fd) http_message_send (http_message_t msg, int fd)
{ {
char timebuf[30]; char timebuf[30];
time_t global_time; time_t global_time;
unsigned int i; unsigned int i;
assert(is_http_message_valid(msg)); assert (is_http_message_valid (msg));
/* Check for valid arguments */ /* Check for valid arguments */
if (msg == NULL) if (msg == NULL)
return -EFAULT; return -EFAULT;
if (fd < 1) if (fd < 1)
return -EBADF; return -EBADF;
if (!is_http_message_valid(msg)) if (!is_http_message_valid (msg))
return -EINVAL; return -EINVAL;
/* Write the response line */ /* Write the response line */
write_message(fd, "HTTP/1.0 %d %s\r\n", write_message (fd, "HTTP/1.0 %d %s\r\n",
msg->response.code, msg->response.string); msg->response.code, msg->response.string);
/* Go through all the headers */ /* Go through all the headers */
for (i = 0; i != msg->headers.used; ++i) for (i = 0; i != msg->headers.used; ++i)
write_message(fd, "%s\r\n", msg->headers.strings[i]); write_message (fd, "%s\r\n", msg->headers.strings[i]);
/* Output the date */ /* Output the date */
global_time = time(NULL); global_time = time (NULL);
strftime(timebuf, sizeof(timebuf), "%a, %d %b %Y %H:%M:%S GMT", strftime (timebuf, sizeof (timebuf), "%a, %d %b %Y %H:%M:%S GMT",
gmtime(&global_time)); gmtime (&global_time));
write_message(fd, "Date: %s\r\n", timebuf); write_message (fd, "Date: %s\r\n", timebuf);
/* Output the content-length */ /* Output the content-length */
write_message(fd, "Content-length: %u\r\n", msg->body.length); write_message (fd, "Content-length: %u\r\n", msg->body.length);
/* Write the separator between the headers and body */ /* Write the separator between the headers and body */
safe_write(fd, "\r\n", 2); safe_write (fd, "\r\n", 2);
/* If there's a body, send it! */ /* If there's a body, send it! */
if (msg->body.length > 0) if (msg->body.length > 0)
safe_write(fd, msg->body.text, msg->body.length); safe_write (fd, msg->body.text, msg->body.length);
return 0; return 0;
} }

24
src/http-message.h
View File

@ -58,28 +58,28 @@ typedef struct http_message_s *http_message_t;
#define IS_HTTP_MSG_ERROR(x) (x < 0) #define IS_HTTP_MSG_ERROR(x) (x < 0)
/* Initialize the internal structure of the HTTP message */ /* Initialize the internal structure of the HTTP message */
extern http_message_t http_message_create(int response_code, extern http_message_t http_message_create (int response_code,
const char *response_string); const char *response_string);
/* Free up an _internal_ resources */ /* Free up an _internal_ resources */
extern int http_message_destroy(http_message_t msg); extern int http_message_destroy (http_message_t msg);
/* /*
* Send an HTTP message via the supplied file descriptor. This function * Send an HTTP message via the supplied file descriptor. This function
* will add the "Date" header before it's sent. * will add the "Date" header before it's sent.
*/ */
extern int http_message_send(http_message_t msg, int fd); extern int http_message_send (http_message_t msg, int fd);
/* /*
* Change the internal state of the HTTP message. Either set the * Change the internal state of the HTTP message. Either set the
* body of the message, update the response information, or * body of the message, update the response information, or
* add a new set of headers. * add a new set of headers.
*/ */
extern int http_message_set_body(http_message_t msg, extern int http_message_set_body (http_message_t msg,
const char *body, size_t len); const char *body, size_t len);
extern int http_message_set_response(http_message_t msg, extern int http_message_set_response (http_message_t msg,
int response_code, int response_code,
const char *response_string); const char *response_string);
/* /*
* Set the headers for this HTTP message. Each string must be NUL ('\0') * Set the headers for this HTTP message. Each string must be NUL ('\0')
@ -87,7 +87,7 @@ extern int http_message_set_response(http_message_t msg,
* line-feeds (LF) since they will be included when the http_message is * line-feeds (LF) since they will be included when the http_message is
* sent. * sent.
*/ */
extern int http_message_add_headers(http_message_t msg, extern int http_message_add_headers (http_message_t msg,
char **headers, int num_headers); char **headers, int num_headers);
#endif /* _TINYPROXY_HTTP_MESSAGE_H_ */ #endif /* _TINYPROXY_HTTP_MESSAGE_H_ */

210
src/log.c
View File

@ -29,15 +29,15 @@
#include "vector.h" #include "vector.h"
static char *syslog_level[] = { static char *syslog_level[] = {
NULL, NULL,
NULL, NULL,
"CRITICAL", "CRITICAL",
"ERROR", "ERROR",
"WARNING", "WARNING",
"NOTICE", "NOTICE",
"INFO", "INFO",
"DEBUG", "DEBUG",
"CONNECT" "CONNECT"
}; };
#define TIME_LENGTH 16 #define TIME_LENGTH 16
@ -65,165 +65,177 @@ static vector_t log_message_storage;
* Open the log file and store the file descriptor in a global location. * Open the log file and store the file descriptor in a global location.
*/ */
int int
open_log_file(const char *log_file_name) open_log_file (const char *log_file_name)
{ {
log_file_fd = create_file_safely(log_file_name, FALSE); log_file_fd = create_file_safely (log_file_name, FALSE);
return log_file_fd; return log_file_fd;
} }
/* /*
* Close the log file * Close the log file
*/ */
void void
close_log_file(void) close_log_file (void)
{ {
close(log_file_fd); close (log_file_fd);
} }
/* /*
* Truncate log file to a zero length. * Truncate log file to a zero length.
*/ */
void void
truncate_log_file(void) truncate_log_file (void)
{ {
lseek(log_file_fd, 0, SEEK_SET); lseek (log_file_fd, 0, SEEK_SET);
ftruncate(log_file_fd, 0); ftruncate (log_file_fd, 0);
} }
/* /*
* Set the log level for writing to the log file. * Set the log level for writing to the log file.
*/ */
void void
set_log_level(int level) set_log_level (int level)
{ {
log_level = level; log_level = level;
} }
/* /*
* This routine logs messages to either the log file or the syslog function. * This routine logs messages to either the log file or the syslog function.
*/ */
void void
log_message(int level, char *fmt, ...) log_message (int level, char *fmt, ...)
{ {
va_list args; va_list args;
time_t nowtime; time_t nowtime;
char time_string[TIME_LENGTH]; char time_string[TIME_LENGTH];
char str[STRING_LENGTH]; char str[STRING_LENGTH];
#ifdef NDEBUG #ifdef NDEBUG
/* /*
* Figure out if we should write the message or not. * Figure out if we should write the message or not.
*/ */
if (log_level == LOG_CONN) { if (log_level == LOG_CONN)
if (level == LOG_INFO) {
return; if (level == LOG_INFO)
} else if (log_level == LOG_INFO) { return;
if (level > LOG_INFO && level != LOG_CONN) }
return; else if (log_level == LOG_INFO)
} else if (level > log_level) {
return; if (level > LOG_INFO && level != LOG_CONN)
return;
}
else if (level > log_level)
return;
#endif #endif
#ifdef HAVE_SYSLOG_H #ifdef HAVE_SYSLOG_H
if (config.syslog && level == LOG_CONN) if (config.syslog && level == LOG_CONN)
level = LOG_INFO; level = LOG_INFO;
#endif #endif
va_start(args, fmt); va_start (args, fmt);
/* /*
* If the config file hasn't been processed, then we need to store * If the config file hasn't been processed, then we need to store
* the messages for later processing. * the messages for later processing.
*/ */
if (!processed_config_file) { if (!processed_config_file)
char *entry_buffer; {
char *entry_buffer;
if (!log_message_storage) { if (!log_message_storage)
log_message_storage = vector_create(); {
if (!log_message_storage) log_message_storage = vector_create ();
goto out; if (!log_message_storage)
} goto out;
}
vsnprintf(str, STRING_LENGTH, fmt, args); vsnprintf (str, STRING_LENGTH, fmt, args);
entry_buffer = safemalloc(strlen(str) + 6); entry_buffer = safemalloc (strlen (str) + 6);
if (!entry_buffer) if (!entry_buffer)
goto out; goto out;
sprintf(entry_buffer, "%d %s", level, str); sprintf (entry_buffer, "%d %s", level, str);
vector_append(log_message_storage, entry_buffer, vector_append (log_message_storage, entry_buffer,
strlen(entry_buffer) + 1); strlen (entry_buffer) + 1);
safefree(entry_buffer); safefree (entry_buffer);
goto out; goto out;
} }
#ifdef HAVE_SYSLOG_H #ifdef HAVE_SYSLOG_H
if (config.syslog) { if (config.syslog)
{
# ifdef HAVE_VSYSLOG_H # ifdef HAVE_VSYSLOG_H
vsyslog(level, fmt, args); vsyslog (level, fmt, args);
# else # else
vsnprintf(str, STRING_LENGTH, fmt, args); vsnprintf (str, STRING_LENGTH, fmt, args);
syslog(level, "%s", str); syslog (level, "%s", str);
# endif # endif
} else { }
else
{
#endif #endif
nowtime = time(NULL); nowtime = time (NULL);
/* Format is month day hour:minute:second (24 time) */ /* Format is month day hour:minute:second (24 time) */
strftime(time_string, TIME_LENGTH, "%b %d %H:%M:%S", strftime (time_string, TIME_LENGTH, "%b %d %H:%M:%S",
localtime(&nowtime)); localtime (&nowtime));
snprintf(str, STRING_LENGTH, "%-9s %s [%ld]: ", snprintf (str, STRING_LENGTH, "%-9s %s [%ld]: ",
syslog_level[level], time_string, (long int)getpid()); syslog_level[level], time_string, (long int) getpid ());
assert(log_file_fd >= 0); assert (log_file_fd >= 0);
write(log_file_fd, str, strlen(str)); write (log_file_fd, str, strlen (str));
vsnprintf(str, STRING_LENGTH, fmt, args); vsnprintf (str, STRING_LENGTH, fmt, args);
write(log_file_fd, str, strlen(str)); write (log_file_fd, str, strlen (str));
write(log_file_fd, "\n", 1); write (log_file_fd, "\n", 1);
fsync(log_file_fd); fsync (log_file_fd);
#ifdef HAVE_SYSLOG_H #ifdef HAVE_SYSLOG_H
} }
#endif #endif
out: out:
va_end(args); va_end (args);
} }
/* /*
* This needs to send any stored log messages. * This needs to send any stored log messages.
*/ */
void void
send_stored_logs(void) send_stored_logs (void)
{ {
char *string; char *string;
char *ptr; char *ptr;
int level; int level;
size_t i; size_t i;
for (i = 0; i != vector_length(log_message_storage); ++i) { for (i = 0; i != vector_length (log_message_storage); ++i)
string = vector_getentry(log_message_storage, i, NULL); {
string = vector_getentry (log_message_storage, i, NULL);
ptr = strchr(string, ' ') + 1; ptr = strchr (string, ' ') + 1;
level = atoi(string); level = atoi (string);
#ifdef NDEBUG #ifdef NDEBUG
if (log_level == LOG_CONN && level == LOG_INFO) if (log_level == LOG_CONN && level == LOG_INFO)
continue; continue;
else if (log_level == LOG_INFO) { else if (log_level == LOG_INFO)
if (level > LOG_INFO && level != LOG_CONN) {
continue; if (level > LOG_INFO && level != LOG_CONN)
} else if (level > log_level) continue;
continue; }
else if (level > log_level)
continue;
#endif #endif
log_message(level, ptr); log_message (level, ptr);
} }
vector_delete(log_message_storage); vector_delete (log_message_storage);
log_message_storage = NULL; log_message_storage = NULL;
} }

14
src/log.h
View File

@ -87,7 +87,7 @@
# define LOG_DEBUG 7 # define LOG_DEBUG 7
#endif #endif
#define LOG_CONN 8 /* extra to log connections without the INFO stuff */ #define LOG_CONN 8 /* extra to log connections without the INFO stuff */
/* /*
* Use this for debugging. The format is specific: * Use this for debugging. The format is specific:
@ -102,12 +102,12 @@
# define DEBUG2(x, y...) do { } while(0) # define DEBUG2(x, y...) do { } while(0)
#endif #endif
extern int open_log_file(const char *file); extern int open_log_file (const char *file);
extern void close_log_file(void); extern void close_log_file (void);
extern void truncate_log_file(void); extern void truncate_log_file (void);
extern void log_message(int level, char *fmt, ...); extern void log_message (int level, char *fmt, ...);
extern void set_log_level(int level); extern void set_log_level (int level);
extern void send_stored_logs(void); extern void send_stored_logs (void);
#endif #endif

404
src/network.c
View File

@ -33,35 +33,37 @@
* again. Keep sending until the buffer has been sent. * again. Keep sending until the buffer has been sent.
*/ */
ssize_t ssize_t
safe_write(int fd, const char *buffer, size_t count) safe_write (int fd, const char *buffer, size_t count)
{ {
ssize_t len; ssize_t len;
size_t bytestosend; size_t bytestosend;
assert(fd >= 0); assert (fd >= 0);
assert(buffer != NULL); assert (buffer != NULL);
assert(count > 0); assert (count > 0);
bytestosend = count; bytestosend = count;
while (1) { while (1)
len = send(fd, buffer, bytestosend, MSG_NOSIGNAL); {
len = send (fd, buffer, bytestosend, MSG_NOSIGNAL);
if (len < 0) { if (len < 0)
if (errno == EINTR) {
continue; if (errno == EINTR)
else continue;
return -errno; else
} return -errno;
}
if (len == bytestosend) if (len == bytestosend)
break; break;
buffer += len; buffer += len;
bytestosend -= len; bytestosend -= len;
} }
return count; return count;
} }
/* /*
@ -69,15 +71,17 @@ safe_write(int fd, const char *buffer, size_t count)
* again. * again.
*/ */
ssize_t ssize_t
safe_read(int fd, char *buffer, size_t count) safe_read (int fd, char *buffer, size_t count)
{ {
ssize_t len; ssize_t len;
do { do
len = read(fd, buffer, count); {
} while (len < 0 && errno == EINTR); len = read (fd, buffer, count);
}
while (len < 0 && errno == EINTR);
return len; return len;
} }
/* /*
@ -87,47 +91,51 @@ safe_read(int fd, char *buffer, size_t count)
* (although I did fix a memory leak. :) * (although I did fix a memory leak. :)
*/ */
int int
write_message(int fd, const char *fmt, ...) write_message (int fd, const char *fmt, ...)
{ {
ssize_t n; ssize_t n;
size_t size = (1024 * 8); /* start with 8 KB and go from there */ size_t size = (1024 * 8); /* start with 8 KB and go from there */
char *buf, *tmpbuf; char *buf, *tmpbuf;
va_list ap; va_list ap;
if ((buf = safemalloc(size)) == NULL) if ((buf = safemalloc (size)) == NULL)
return -1; return -1;
while (1) { while (1)
va_start(ap, fmt); {
n = vsnprintf(buf, size, fmt, ap); va_start (ap, fmt);
va_end(ap); n = vsnprintf (buf, size, fmt, ap);
va_end (ap);
/* If that worked, break out so we can send the buffer */ /* If that worked, break out so we can send the buffer */
if (n > -1 && n < size) if (n > -1 && n < size)
break; break;
/* Else, try again with more space */ /* Else, try again with more space */
if (n > -1) if (n > -1)
/* precisely what is needed (glibc2.1) */ /* precisely what is needed (glibc2.1) */
size = n + 1; size = n + 1;
else else
/* twice the old size (glibc2.0) */ /* twice the old size (glibc2.0) */
size *= 2; size *= 2;
if ((tmpbuf = saferealloc(buf, size)) == NULL) { if ((tmpbuf = saferealloc (buf, size)) == NULL)
safefree(buf); {
return -1; safefree (buf);
} else return -1;
buf = tmpbuf; }
} else
buf = tmpbuf;
}
if (safe_write(fd, buf, n) < 0) { if (safe_write (fd, buf, n) < 0)
safefree(buf); {
return -1; safefree (buf);
} return -1;
}
safefree(buf); safefree (buf);
return 0; return 0;
} }
/* /*
@ -142,103 +150,113 @@ write_message(int fd, const char *fmt, ...)
#define SEGMENT_LEN (512) #define SEGMENT_LEN (512)
#define MAXIMUM_BUFFER_LENGTH (128 * 1024) #define MAXIMUM_BUFFER_LENGTH (128 * 1024)
ssize_t ssize_t
readline(int fd, char **whole_buffer) readline (int fd, char **whole_buffer)
{ {
ssize_t whole_buffer_len; ssize_t whole_buffer_len;
char buffer[SEGMENT_LEN]; char buffer[SEGMENT_LEN];
char *ptr; char *ptr;
ssize_t ret; ssize_t ret;
ssize_t diff; ssize_t diff;
struct read_lines_s { struct read_lines_s
char *data; {
size_t len; char *data;
struct read_lines_s *next; size_t len;
}; struct read_lines_s *next;
struct read_lines_s *first_line, *line_ptr; };
struct read_lines_s *first_line, *line_ptr;
first_line = safecalloc(sizeof(struct read_lines_s), 1); first_line = safecalloc (sizeof (struct read_lines_s), 1);
if (!first_line) if (!first_line)
return -ENOMEM; return -ENOMEM;
line_ptr = first_line; line_ptr = first_line;
whole_buffer_len = 0; whole_buffer_len = 0;
for (;;) { for (;;)
ret = recv(fd, buffer, SEGMENT_LEN, MSG_PEEK); {
if (ret <= 0) ret = recv (fd, buffer, SEGMENT_LEN, MSG_PEEK);
goto CLEANUP; if (ret <= 0)
goto CLEANUP;
ptr = memchr(buffer, '\n', ret); ptr = memchr (buffer, '\n', ret);
if (ptr) if (ptr)
diff = ptr - buffer + 1; diff = ptr - buffer + 1;
else else
diff = ret; diff = ret;
whole_buffer_len += diff; whole_buffer_len += diff;
/* /*
* Don't allow the buffer to grow without bound. If we * Don't allow the buffer to grow without bound. If we
* get to more than MAXIMUM_BUFFER_LENGTH close. * get to more than MAXIMUM_BUFFER_LENGTH close.
*/ */
if (whole_buffer_len > MAXIMUM_BUFFER_LENGTH) { if (whole_buffer_len > MAXIMUM_BUFFER_LENGTH)
ret = -ERANGE; {
goto CLEANUP; ret = -ERANGE;
} goto CLEANUP;
}
line_ptr->data = safemalloc(diff); line_ptr->data = safemalloc (diff);
if (!line_ptr->data) { if (!line_ptr->data)
ret = -ENOMEM; {
goto CLEANUP; ret = -ENOMEM;
} goto CLEANUP;
}
recv(fd, line_ptr->data, diff, 0); recv (fd, line_ptr->data, diff, 0);
line_ptr->len = diff; line_ptr->len = diff;
if (ptr) { if (ptr)
line_ptr->next = NULL; {
break; line_ptr->next = NULL;
} break;
}
line_ptr->next = safecalloc(sizeof(struct read_lines_s), 1); line_ptr->next = safecalloc (sizeof (struct read_lines_s), 1);
if (!line_ptr->next) { if (!line_ptr->next)
ret = -ENOMEM; {
goto CLEANUP; ret = -ENOMEM;
} goto CLEANUP;
line_ptr = line_ptr->next; }
} line_ptr = line_ptr->next;
}
*whole_buffer = safemalloc(whole_buffer_len + 1); *whole_buffer = safemalloc (whole_buffer_len + 1);
if (!*whole_buffer) { if (!*whole_buffer)
ret = -ENOMEM; {
goto CLEANUP; ret = -ENOMEM;
} goto CLEANUP;
}
*(*whole_buffer + whole_buffer_len) = '\0'; *(*whole_buffer + whole_buffer_len) = '\0';
whole_buffer_len = 0; whole_buffer_len = 0;
line_ptr = first_line; line_ptr = first_line;
while (line_ptr) { while (line_ptr)
memcpy(*whole_buffer + whole_buffer_len, line_ptr->data, {
line_ptr->len); memcpy (*whole_buffer + whole_buffer_len, line_ptr->data,
whole_buffer_len += line_ptr->len; line_ptr->len);
whole_buffer_len += line_ptr->len;
line_ptr = line_ptr->next; line_ptr = line_ptr->next;
} }
ret = whole_buffer_len; ret = whole_buffer_len;
CLEANUP: CLEANUP:
do { do
line_ptr = first_line->next; {
if (first_line->data) line_ptr = first_line->next;
safefree(first_line->data); if (first_line->data)
safefree(first_line); safefree (first_line->data);
first_line = line_ptr; safefree (first_line);
} while (first_line); first_line = line_ptr;
}
while (first_line);
return ret; return ret;
} }
/* /*
@ -246,32 +264,35 @@ readline(int fd, char **whole_buffer)
* hex string. * hex string.
*/ */
char * char *
get_ip_string(struct sockaddr *sa, char *buf, size_t buflen) get_ip_string (struct sockaddr *sa, char *buf, size_t buflen)
{ {
assert(sa != NULL); assert (sa != NULL);
assert(buf != NULL); assert (buf != NULL);
assert(buflen != 0); assert (buflen != 0);
buf[0] = '\0'; /* start with an empty string */ buf[0] = '\0'; /* start with an empty string */
switch (sa->sa_family) { switch (sa->sa_family)
case AF_INET:{ {
struct sockaddr_in *sa_in = (struct sockaddr_in *)sa; case AF_INET:
{
struct sockaddr_in *sa_in = (struct sockaddr_in *) sa;
inet_ntop(AF_INET, &sa_in->sin_addr, buf, buflen); inet_ntop (AF_INET, &sa_in->sin_addr, buf, buflen);
break; break;
} }
case AF_INET6:{ case AF_INET6:
struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)sa; {
struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *) sa;
inet_ntop(AF_INET6, &sa_in6->sin6_addr, buf, buflen); inet_ntop (AF_INET6, &sa_in6->sin6_addr, buf, buflen);
break; break;
} }
default: default:
/* no valid family */ /* no valid family */
return NULL; return NULL;
} }
return buf; return buf;
} }
/* /*
@ -282,41 +303,42 @@ get_ip_string(struct sockaddr *sa, char *buf, size_t buflen)
* Returns the same as inet_pton(). * Returns the same as inet_pton().
*/ */
int int
full_inet_pton(const char *ip, void *dst) full_inet_pton (const char *ip, void *dst)
{ {
char buf[24], tmp[24]; /* IPv4->IPv6 = ::FFFF:xxx.xxx.xxx.xxx\0 */ char buf[24], tmp[24]; /* IPv4->IPv6 = ::FFFF:xxx.xxx.xxx.xxx\0 */
int n; int n;
assert(ip != NULL && strlen(ip) != 0); assert (ip != NULL && strlen (ip) != 0);
assert(dst != NULL); assert (dst != NULL);
/* /*
* Check if the string is an IPv4 numeric address. We use the * Check if the string is an IPv4 numeric address. We use the
* older inet_aton() call since it handles more IPv4 numeric * older inet_aton() call since it handles more IPv4 numeric
* address formats. * address formats.
*/ */
n = inet_aton(ip, (struct in_addr *)dst); n = inet_aton (ip, (struct in_addr *) dst);
if (n == 0) { if (n == 0)
/* {
* Simple case: "ip" wasn't an IPv4 numeric address, so /*
* try doing the conversion as an IPv6 address. This * Simple case: "ip" wasn't an IPv4 numeric address, so
* will either succeed or fail, but we can't do any * try doing the conversion as an IPv6 address. This
* more processing anyway. * will either succeed or fail, but we can't do any
*/ * more processing anyway.
return inet_pton(AF_INET6, ip, dst); */
} return inet_pton (AF_INET6, ip, dst);
}
/* /*
* "ip" was an IPv4 address, so we need to convert it to * "ip" was an IPv4 address, so we need to convert it to
* an IPv4-mapped IPv6 address and do the conversion * an IPv4-mapped IPv6 address and do the conversion
* again to get the IPv6 network structure. * again to get the IPv6 network structure.
* *
* We convert the IPv4 binary address back into the * We convert the IPv4 binary address back into the
* standard dotted-decimal format using inet_ntop() * standard dotted-decimal format using inet_ntop()
* so we can be sure that inet_pton will accept the * so we can be sure that inet_pton will accept the
* full string. * full string.
*/ */
snprintf(buf, sizeof(buf), "::ffff:%s", snprintf (buf, sizeof (buf), "::ffff:%s",
inet_ntop(AF_INET, dst, tmp, sizeof(tmp))); inet_ntop (AF_INET, dst, tmp, sizeof (tmp)));
return inet_pton(AF_INET6, buf, dst); return inet_pton (AF_INET6, buf, dst);
} }

12
src/network.h
View File

@ -21,13 +21,13 @@
#ifndef TINYPROXY_NETWORK_H #ifndef TINYPROXY_NETWORK_H
#define TINYPROXY_NETWORK_H #define TINYPROXY_NETWORK_H
extern ssize_t safe_write(int fd, const char *buffer, size_t count); 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 ssize_t safe_read (int fd, char *buffer, size_t count);
extern int write_message(int fd, const char *fmt, ...); extern int write_message (int fd, const char *fmt, ...);
extern ssize_t readline(int fd, char **whole_buffer); extern ssize_t readline (int fd, char **whole_buffer);
extern char *get_ip_string(struct sockaddr *sa, char *buf, size_t len); extern char *get_ip_string (struct sockaddr *sa, char *buf, size_t len);
extern int full_inet_pton(const char *ip, void *dst); extern int full_inet_pton (const char *ip, void *dst);
#endif #endif

2383
src/reqs.c
View File

File diff suppressed because it is too large Load Diff

19
src/reqs.h
View File

@ -34,18 +34,19 @@
/* /*
* This structure holds the information pulled from a URL request. * This structure holds the information pulled from a URL request.
*/ */
struct request_s { struct request_s
char *method; {
char *protocol; char *method;
char *protocol;
char *host; char *host;
uint16_t port; uint16_t port;
char *path; char *path;
}; };
extern void handle_connection(int fd); extern void handle_connection (int fd);
extern void add_connect_port_allowed(int port); extern void add_connect_port_allowed (int port);
extern void upstream_add(const char *host, int port, const char *domain); extern void upstream_add (const char *host, int port, const char *domain);
#endif #endif

184
src/reverse-proxy.c
View File

@ -30,128 +30,132 @@
* Add entry to the reversepath list * Add entry to the reversepath list
*/ */
void void
reversepath_add(const char *path, const char *url) reversepath_add (const char *path, const char *url)
{ {
struct reversepath *reverse; struct reversepath *reverse;
if (url == NULL) { if (url == NULL)
log_message(LOG_WARNING, {
"Illegal reverse proxy rule: missing url"); log_message (LOG_WARNING, "Illegal reverse proxy rule: missing url");
return; return;
} }
if (!strstr(url, "://")) { if (!strstr (url, "://"))
log_message(LOG_WARNING, {
"Skipping reverse proxy rule: '%s' is not a valid url", log_message (LOG_WARNING,
url); "Skipping reverse proxy rule: '%s' is not a valid url",
return; url);
} return;
}
if (path && *path != '/') { if (path && *path != '/')
log_message(LOG_WARNING, {
"Skipping reverse proxy rule: path '%s' doesn't start with a /", log_message (LOG_WARNING,
path); "Skipping reverse proxy rule: path '%s' doesn't start with a /",
return; path);
} return;
}
if (!(reverse = safemalloc(sizeof(struct reversepath)))) { if (!(reverse = safemalloc (sizeof (struct reversepath))))
log_message(LOG_ERR, {
"Unable to allocate memory in reversepath_add()"); log_message (LOG_ERR, "Unable to allocate memory in reversepath_add()");
return; return;
} }
if (!path) if (!path)
reverse->path = safestrdup("/"); reverse->path = safestrdup ("/");
else else
reverse->path = safestrdup(path); reverse->path = safestrdup (path);
reverse->url = safestrdup(url); reverse->url = safestrdup (url);
reverse->next = config.reversepath_list; reverse->next = config.reversepath_list;
config.reversepath_list = reverse; config.reversepath_list = reverse;
log_message(LOG_INFO, log_message (LOG_INFO,
"Added reverse proxy rule: %s -> %s", reverse->path, "Added reverse proxy rule: %s -> %s", reverse->path,
reverse->url); reverse->url);
} }
/* /*
* Check if a request url is in the reversepath list * Check if a request url is in the reversepath list
*/ */
struct reversepath * struct reversepath *
reversepath_get(char *url) reversepath_get (char *url)
{ {
struct reversepath *reverse = config.reversepath_list; struct reversepath *reverse = config.reversepath_list;
while (reverse) { while (reverse)
if (strstr(url, reverse->path) == url) {
return reverse; if (strstr (url, reverse->path) == url)
return reverse;
reverse = reverse->next; reverse = reverse->next;
} }
return NULL; return NULL;
} }
/* /*
* Rewrite the URL for reverse proxying. * Rewrite the URL for reverse proxying.
*/ */
char * char *
reverse_rewrite_url(struct conn_s *connptr, hashmap_t hashofheaders, char *url) reverse_rewrite_url (struct conn_s *connptr, hashmap_t hashofheaders,
char *url)
{ {
char *rewrite_url = NULL; char *rewrite_url = NULL;
char *cookie = NULL; char *cookie = NULL;
char *cookieval; char *cookieval;
struct reversepath *reverse; struct reversepath *reverse;
/* Reverse requests always start with a slash */ /* Reverse requests always start with a slash */
if (*url == '/') { if (*url == '/')
/* First try locating the reverse mapping by request url */ {
reverse = reversepath_get(url); /* First try locating the reverse mapping by request url */
if (reverse) { reverse = reversepath_get (url);
rewrite_url = safemalloc(strlen(url) + if (reverse)
strlen(reverse->url) + 1); {
strcpy(rewrite_url, reverse->url); rewrite_url = safemalloc (strlen (url) + strlen (reverse->url) + 1);
strcat(rewrite_url, url + strlen(reverse->path)); strcpy (rewrite_url, reverse->url);
} else if (config.reversemagic strcat (rewrite_url, url + strlen (reverse->path));
&& hashmap_entry_by_key(hashofheaders, }
"cookie", else if (config.reversemagic
(void **)&cookie) > 0) { && hashmap_entry_by_key (hashofheaders,
"cookie", (void **) &cookie) > 0)
{
/* No match - try the magical tracking cookie next */ /* No match - try the magical tracking cookie next */
if ((cookieval = strstr(cookie, REVERSE_COOKIE "=")) if ((cookieval = strstr (cookie, REVERSE_COOKIE "="))
&& (reverse = && (reverse =
reversepath_get(cookieval + reversepath_get (cookieval + strlen (REVERSE_COOKIE) + 1)))
strlen(REVERSE_COOKIE) + 1))) { {
rewrite_url = safemalloc(strlen(url) + rewrite_url = safemalloc (strlen (url) +
strlen strlen (reverse->url) + 1);
(reverse->url) + 1); strcpy (rewrite_url, reverse->url);
strcpy(rewrite_url, reverse->url); strcat (rewrite_url, url + 1);
strcat(rewrite_url, url + 1);
log_message(LOG_INFO, log_message (LOG_INFO,
"Magical tracking cookie says: %s", "Magical tracking cookie says: %s", reverse->path);
reverse->path); }
} }
} }
}
/* Forward proxy support off and no reverse path match found */ /* Forward proxy support off and no reverse path match found */
if (config.reverseonly && !rewrite_url) { if (config.reverseonly && !rewrite_url)
log_message(LOG_ERR, "Bad request"); {
indicate_http_error(connptr, 400, "Bad Request", log_message (LOG_ERR, "Bad request");
"detail", indicate_http_error (connptr, 400, "Bad Request",
"Request has an invalid URL", "url", "detail",
url, NULL); "Request has an invalid URL", "url", url, NULL);
return NULL; return NULL;
} }
log_message(LOG_CONN, "Rewriting URL: %s -> %s", url, rewrite_url); log_message (LOG_CONN, "Rewriting URL: %s -> %s", url, rewrite_url);
/* Store reverse path so that the magical tracking cookie can be set */ /* Store reverse path so that the magical tracking cookie can be set */
if (config.reversemagic) if (config.reversemagic)
connptr->reversepath = safestrdup(reverse->path); connptr->reversepath = safestrdup (reverse->path);
return rewrite_url; return rewrite_url;
} }

17
src/reverse-proxy.h
View File

@ -23,17 +23,18 @@
#include "conns.h" #include "conns.h"
struct reversepath { struct reversepath
struct reversepath *next; {
char *path; struct reversepath *next;
char *url; char *path;
char *url;
}; };
#define REVERSE_COOKIE "yummy_magical_cookie" #define REVERSE_COOKIE "yummy_magical_cookie"
extern void reversepath_add(const char *path, const char *url); extern void reversepath_add (const char *path, const char *url);
extern struct reversepath *reversepath_get(char *url); extern struct reversepath *reversepath_get (char *url);
extern char *reverse_rewrite_url(struct conn_s *connptr, extern char *reverse_rewrite_url (struct conn_s *connptr,
hashmap_t hashofheaders, char *url); hashmap_t hashofheaders, char *url);
#endif #endif

284
src/sock.c
View File

@ -39,34 +39,36 @@
* to indicate an error. * to indicate an error.
*/ */
static int static int
bind_socket(int sockfd, const char *addr) bind_socket (int sockfd, const char *addr)
{ {
struct addrinfo hints, *res, *ressave; struct addrinfo hints, *res, *ressave;
assert(sockfd >= 0); assert (sockfd >= 0);
assert(addr != NULL && strlen(addr) != 0); assert (addr != NULL && strlen (addr) != 0);
memset(&hints, 0, sizeof(struct addrinfo)); memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM; hints.ai_socktype = SOCK_STREAM;
/* The local port it not important */ /* The local port it not important */
if (getaddrinfo(addr, NULL, &hints, &res) != 0) if (getaddrinfo (addr, NULL, &hints, &res) != 0)
return -1; return -1;
ressave = res; ressave = res;
/* Loop through the addresses and try to bind to each */ /* Loop through the addresses and try to bind to each */
do { do
if (bind(sockfd, res->ai_addr, res->ai_addrlen) == 0) {
break; /* success */ if (bind (sockfd, res->ai_addr, res->ai_addrlen) == 0)
} while ((res = res->ai_next) != NULL); break; /* success */
}
while ((res = res->ai_next) != NULL);
freeaddrinfo(ressave); freeaddrinfo (ressave);
if (res == NULL) /* was not able to bind to any address */ if (res == NULL) /* was not able to bind to any address */
return -1; return -1;
return sockfd; return sockfd;
} }
/* /*
@ -75,91 +77,97 @@ bind_socket(int sockfd, const char *addr)
* independent implementation (mostly for IPv4 and IPv6 addresses.) * independent implementation (mostly for IPv4 and IPv6 addresses.)
*/ */
int int
opensock(const char *host, int port, const char *bind_to) opensock (const char *host, int port, const char *bind_to)
{ {
int sockfd, n; int sockfd, n;
struct addrinfo hints, *res, *ressave; struct addrinfo hints, *res, *ressave;
char portstr[6]; char portstr[6];
assert(host != NULL); assert (host != NULL);
assert(port > 0); assert (port > 0);
memset(&hints, 0, sizeof(struct addrinfo)); memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM; hints.ai_socktype = SOCK_STREAM;
snprintf(portstr, sizeof(portstr), "%d", port); snprintf (portstr, sizeof (portstr), "%d", port);
n = getaddrinfo(host, portstr, &hints, &res); n = getaddrinfo (host, portstr, &hints, &res);
if (n != 0) { if (n != 0)
log_message(LOG_ERR, "opensock: Could not retrieve info for %s", {
host); log_message (LOG_ERR, "opensock: Could not retrieve info for %s", host);
return -1; return -1;
} }
ressave = res; ressave = res;
do { do
sockfd = {
socket(res->ai_family, res->ai_socktype, res->ai_protocol); sockfd = socket (res->ai_family, res->ai_socktype, res->ai_protocol);
if (sockfd < 0) if (sockfd < 0)
continue; /* ignore this one */ continue; /* ignore this one */
/* Bind to the specified address */ /* Bind to the specified address */
if (bind_to) { if (bind_to)
if (bind_socket(sockfd, bind_to) < 0) { {
close(sockfd); if (bind_socket (sockfd, bind_to) < 0)
continue; /* can't bind, so try again */ {
} close (sockfd);
} else if (config.bind_address) { continue; /* can't bind, so try again */
if (bind_socket(sockfd, config.bind_address) < 0) { }
close(sockfd); }
continue; /* can't bind, so try again */ else if (config.bind_address)
} {
} if (bind_socket (sockfd, config.bind_address) < 0)
{
close (sockfd);
continue; /* can't bind, so try again */
}
}
if (connect(sockfd, res->ai_addr, res->ai_addrlen) == 0) if (connect (sockfd, res->ai_addr, res->ai_addrlen) == 0)
break; /* success */ break; /* success */
close(sockfd); close (sockfd);
} while ((res = res->ai_next) != NULL); }
while ((res = res->ai_next) != NULL);
freeaddrinfo(ressave); freeaddrinfo (ressave);
if (res == NULL) { if (res == NULL)
log_message(LOG_ERR, {
"opensock: Could not establish a connection to %s", log_message (LOG_ERR,
host); "opensock: Could not establish a connection to %s", host);
return -1; return -1;
} }
return sockfd; return sockfd;
} }
/* /*
* Set the socket to non blocking -rjkaes * Set the socket to non blocking -rjkaes
*/ */
int int
socket_nonblocking(int sock) socket_nonblocking (int sock)
{ {
int flags; int flags;
assert(sock >= 0); assert (sock >= 0);
flags = fcntl(sock, F_GETFL, 0); flags = fcntl (sock, F_GETFL, 0);
return fcntl(sock, F_SETFL, flags | O_NONBLOCK); return fcntl (sock, F_SETFL, flags | O_NONBLOCK);
} }
/* /*
* Set the socket to blocking -rjkaes * Set the socket to blocking -rjkaes
*/ */
int int
socket_blocking(int sock) socket_blocking (int sock)
{ {
int flags; int flags;
assert(sock >= 0); assert (sock >= 0);
flags = fcntl(sock, F_GETFL, 0); flags = fcntl (sock, F_GETFL, 0);
return fcntl(sock, F_SETFL, flags & ~O_NONBLOCK); return fcntl (sock, F_SETFL, flags & ~O_NONBLOCK);
} }
/* /*
@ -169,95 +177,101 @@ socket_blocking(int sock)
* - rjkaes * - rjkaes
*/ */
int int
listen_sock(uint16_t port, socklen_t * addrlen) listen_sock (uint16_t port, socklen_t * addrlen)
{ {
int listenfd; int listenfd;
const int on = 1; const int on = 1;
struct sockaddr_in addr; struct sockaddr_in addr;
assert(port > 0); assert (port > 0);
assert(addrlen != NULL); assert (addrlen != NULL);
listenfd = socket(AF_INET, SOCK_STREAM, 0); listenfd = socket (AF_INET, SOCK_STREAM, 0);
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); setsockopt (listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on));
memset(&addr, 0, sizeof(addr)); memset (&addr, 0, sizeof (addr));
addr.sin_family = AF_INET; addr.sin_family = AF_INET;
addr.sin_port = htons(port); addr.sin_port = htons (port);
if (config.ipAddr) { if (config.ipAddr)
addr.sin_addr.s_addr = inet_addr(config.ipAddr); {
} else { addr.sin_addr.s_addr = inet_addr (config.ipAddr);
addr.sin_addr.s_addr = inet_addr("0.0.0.0"); }
} else
{
addr.sin_addr.s_addr = inet_addr ("0.0.0.0");
}
if (bind(listenfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) { if (bind (listenfd, (struct sockaddr *) &addr, sizeof (addr)) < 0)
log_message(LOG_ERR, {
"Unable to bind listening socket because of %s", log_message (LOG_ERR,
strerror(errno)); "Unable to bind listening socket because of %s",
return -1; strerror (errno));
} return -1;
}
if (listen(listenfd, MAXLISTEN) < 0) { if (listen (listenfd, MAXLISTEN) < 0)
log_message(LOG_ERR, {
"Unable to start listening socket because of %s", log_message (LOG_ERR,
strerror(errno)); "Unable to start listening socket because of %s",
return -1; strerror (errno));
} return -1;
}
*addrlen = sizeof(addr); *addrlen = sizeof (addr);
return listenfd; return listenfd;
} }
/* /*
* Takes a socket descriptor and returns the socket's IP address. * Takes a socket descriptor and returns the socket's IP address.
*/ */
int int
getsock_ip(int fd, char *ipaddr) getsock_ip (int fd, char *ipaddr)
{ {
struct sockaddr_storage name; struct sockaddr_storage name;
socklen_t namelen = sizeof(name); socklen_t namelen = sizeof (name);
assert(fd >= 0); assert (fd >= 0);
if (getsockname(fd, (struct sockaddr *)&name, &namelen) != 0) { if (getsockname (fd, (struct sockaddr *) &name, &namelen) != 0)
log_message(LOG_ERR, "getsock_ip: getsockname() error: %s", {
strerror(errno)); log_message (LOG_ERR, "getsock_ip: getsockname() error: %s",
return -1; strerror (errno));
} return -1;
}
if (get_ip_string((struct sockaddr *)&name, ipaddr, IP_LENGTH) == NULL) if (get_ip_string ((struct sockaddr *) &name, ipaddr, IP_LENGTH) == NULL)
return -1; return -1;
return 0; return 0;
} }
/* /*
* Return the peer's socket information. * Return the peer's socket information.
*/ */
int int
getpeer_information(int fd, char *ipaddr, char *string_addr) getpeer_information (int fd, char *ipaddr, char *string_addr)
{ {
struct sockaddr_storage sa; struct sockaddr_storage sa;
socklen_t salen = sizeof sa; socklen_t salen = sizeof sa;
assert(fd >= 0); assert (fd >= 0);
assert(ipaddr != NULL); assert (ipaddr != NULL);
assert(string_addr != NULL); assert (string_addr != NULL);
/* Set the strings to default values */ /* Set the strings to default values */
ipaddr[0] = '\0'; ipaddr[0] = '\0';
strlcpy(string_addr, "[unknown]", HOSTNAME_LENGTH); strlcpy (string_addr, "[unknown]", HOSTNAME_LENGTH);
/* Look up the IP address */ /* Look up the IP address */
if (getpeername(fd, (struct sockaddr *) &sa, &salen) != 0) if (getpeername (fd, (struct sockaddr *) &sa, &salen) != 0)
return -1; return -1;
if (get_ip_string((struct sockaddr *)&sa, ipaddr, IP_LENGTH) == NULL) if (get_ip_string ((struct sockaddr *) &sa, ipaddr, IP_LENGTH) == NULL)
return -1; return -1;
/* Get the full host name */ /* Get the full host name */
return getnameinfo((struct sockaddr *)&sa, salen, return getnameinfo ((struct sockaddr *) &sa, salen,
string_addr, HOSTNAME_LENGTH, NULL, 0, 0); string_addr, HOSTNAME_LENGTH, NULL, 0, 0);
} }

12
src/sock.h
View File

@ -28,13 +28,13 @@
#define MAXLINE (1024 * 4) #define MAXLINE (1024 * 4)
extern int opensock(const char *host, int port, const char *bind_to); extern int opensock (const char *host, int port, const char *bind_to);
extern int listen_sock(uint16_t port, socklen_t * addrlen); 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 int getsock_ip(int fd, char *ipaddr); extern int getsock_ip (int fd, char *ipaddr);
extern int getpeer_information(int fd, char *ipaddr, char *string_addr); extern int getpeer_information (int fd, char *ipaddr, char *string_addr);
#endif #endif

177
src/stats.c
View File

@ -33,12 +33,13 @@
#include "stats.h" #include "stats.h"
#include "utils.h" #include "utils.h"
struct stat_s { struct stat_s
unsigned long int num_reqs; {
unsigned long int num_badcons; unsigned long int num_reqs;
unsigned long int num_open; unsigned long int num_badcons;
unsigned long int num_refused; unsigned long int num_open;
unsigned long int num_denied; unsigned long int num_refused;
unsigned long int num_denied;
}; };
static struct stat_s *stats; static struct stat_s *stats;
@ -47,83 +48,82 @@ static struct stat_s *stats;
* Initialize the statistics information to zero. * Initialize the statistics information to zero.
*/ */
void void
init_stats(void) init_stats (void)
{ {
stats = malloc_shared_memory(sizeof(struct stat_s)); stats = malloc_shared_memory (sizeof (struct stat_s));
if (stats == MAP_FAILED) if (stats == MAP_FAILED)
return; return;
memset(stats, 0, sizeof(struct stat_s)); memset (stats, 0, sizeof (struct stat_s));
} }
/* /*
* Display the statics of the tinyproxy server. * Display the statics of the tinyproxy server.
*/ */
int int
showstats(struct conn_s *connptr) showstats (struct conn_s *connptr)
{ {
static char *msg = static char *msg =
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n" "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n"
"<html>\n" "<html>\n"
"<head><title>%s version %s run-time statistics</title></head>\n" "<head><title>%s version %s run-time statistics</title></head>\n"
"<body>\n" "<body>\n"
"<h1>%s version %s run-time statistics</h1>\n" "<h1>%s version %s run-time statistics</h1>\n"
"<p>\n" "<p>\n"
"Number of open connections: %lu<br />\n" "Number of open connections: %lu<br />\n"
"Number of requests: %lu<br />\n" "Number of requests: %lu<br />\n"
"Number of bad connections: %lu<br />\n" "Number of bad connections: %lu<br />\n"
"Number of denied connections: %lu<br />\n" "Number of denied connections: %lu<br />\n"
"Number of refused connections due to high load: %lu\n" "Number of refused connections due to high load: %lu\n"
"</p>\n" "</p>\n"
"<hr />\n" "<hr />\n"
"<p><em>Generated by %s version %s.</em></p>\n" "<p><em>Generated by %s version %s.</em></p>\n" "</body>\n" "</html>\n";
"</body>\n"
"</html>\n";
char *message_buffer; char *message_buffer;
char opens[16], reqs[16], badconns[16], denied[16], refused[16]; char opens[16], reqs[16], badconns[16], denied[16], refused[16];
FILE *statfile; FILE *statfile;
snprintf(opens, sizeof(opens), "%lu", stats->num_open); snprintf (opens, sizeof (opens), "%lu", stats->num_open);
snprintf(reqs, sizeof(reqs), "%lu", stats->num_reqs); snprintf (reqs, sizeof (reqs), "%lu", stats->num_reqs);
snprintf(badconns, sizeof(badconns), "%lu", stats->num_badcons); snprintf (badconns, sizeof (badconns), "%lu", stats->num_badcons);
snprintf(denied, sizeof(denied), "%lu", stats->num_denied); snprintf (denied, sizeof (denied), "%lu", stats->num_denied);
snprintf(refused, sizeof(refused), "%lu", stats->num_refused); snprintf (refused, sizeof (refused), "%lu", stats->num_refused);
if (!config.statpage || (!(statfile = fopen(config.statpage, "r")))) { if (!config.statpage || (!(statfile = fopen (config.statpage, "r"))))
message_buffer = safemalloc(MAXBUFFSIZE); {
if (!message_buffer) message_buffer = safemalloc (MAXBUFFSIZE);
return -1; if (!message_buffer)
return -1;
snprintf(message_buffer, MAXBUFFSIZE, msg, snprintf (message_buffer, MAXBUFFSIZE, msg,
PACKAGE, VERSION, PACKAGE, VERSION, PACKAGE, VERSION, PACKAGE, VERSION,
stats->num_open, stats->num_open,
stats->num_reqs, stats->num_reqs,
stats->num_badcons, stats->num_denied, stats->num_badcons, stats->num_denied,
stats->num_refused, stats->num_refused, PACKAGE, VERSION);
PACKAGE, VERSION);
if (send_http_message(connptr, 200, "OK", message_buffer) < 0) { if (send_http_message (connptr, 200, "OK", message_buffer) < 0)
safefree(message_buffer); {
return -1; safefree (message_buffer);
} return -1;
}
safefree(message_buffer); safefree (message_buffer);
return 0; return 0;
} }
add_error_variable(connptr, "opens", opens); add_error_variable (connptr, "opens", opens);
add_error_variable(connptr, "reqs", reqs); add_error_variable (connptr, "reqs", reqs);
add_error_variable(connptr, "badconns", badconns); add_error_variable (connptr, "badconns", badconns);
add_error_variable(connptr, "deniedconns", denied); add_error_variable (connptr, "deniedconns", denied);
add_error_variable(connptr, "refusedconns", refused); add_error_variable (connptr, "refusedconns", refused);
add_standard_vars(connptr); add_standard_vars (connptr);
send_http_headers(connptr, 200, "Statistic requested"); send_http_headers (connptr, 200, "Statistic requested");
send_html_file(statfile, connptr); send_html_file (statfile, connptr);
fclose(statfile); fclose (statfile);
return 0; return 0;
} }
/* /*
@ -131,28 +131,29 @@ showstats(struct conn_s *connptr)
* stats.h * stats.h
*/ */
int int
update_stats(status_t update_level) update_stats (status_t update_level)
{ {
switch (update_level) { switch (update_level)
case STAT_BADCONN: {
++stats->num_badcons; case STAT_BADCONN:
break; ++stats->num_badcons;
case STAT_OPEN: break;
++stats->num_open; case STAT_OPEN:
++stats->num_reqs; ++stats->num_open;
break; ++stats->num_reqs;
case STAT_CLOSE: break;
--stats->num_open; case STAT_CLOSE:
break; --stats->num_open;
case STAT_REFUSE: break;
++stats->num_refused; case STAT_REFUSE:
break; ++stats->num_refused;
case STAT_DENIED: break;
++stats->num_denied; case STAT_DENIED:
break; ++stats->num_denied;
default: break;
return -1; default:
} return -1;
}
return 0; return 0;
} }

19
src/stats.h
View File

@ -26,19 +26,20 @@
/* /*
* Various logable statistics * Various logable statistics
*/ */
typedef enum { typedef enum
STAT_BADCONN, /* bad connection, for unknown reason */ {
STAT_OPEN, /* connection opened */ STAT_BADCONN, /* bad connection, for unknown reason */
STAT_CLOSE, /* connection closed */ STAT_OPEN, /* connection opened */
STAT_REFUSE, /* connection refused (to outside world) */ STAT_CLOSE, /* connection closed */
STAT_DENIED /* connection denied to tinyproxy itself */ STAT_REFUSE, /* connection refused (to outside world) */
STAT_DENIED /* connection denied to tinyproxy itself */
} status_t; } status_t;
/* /*
* Public API to the statistics for tinyproxy * Public API to the statistics for tinyproxy
*/ */
extern void init_stats(void); extern void init_stats (void);
extern int showstats(struct conn_s *connptr); extern int showstats (struct conn_s *connptr);
extern int update_stats(status_t update_level); extern int update_stats (status_t update_level);
#endif #endif

78
src/text.c
View File

@ -33,18 +33,18 @@
* destination buffer. * destination buffer.
*/ */
size_t size_t
strlcpy(char *dst, const char *src, size_t size) strlcpy (char *dst, const char *src, size_t size)
{ {
size_t len = strlen(src); size_t len = strlen (src);
size_t ret = len; size_t ret = len;
if (len >= size) if (len >= size)
len = size - 1; len = size - 1;
memcpy(dst, src, len); memcpy (dst, src, len);
dst[len] = '\0'; dst[len] = '\0';
return ret; return ret;
} }
#endif #endif
@ -56,20 +56,21 @@ strlcpy(char *dst, const char *src, size_t size)
* length. * length.
*/ */
size_t size_t
strlcat(char *dst, const char *src, size_t size) strlcat (char *dst, const char *src, size_t size)
{ {
size_t len1 = strlen(dst); size_t len1 = strlen (dst);
size_t len2 = strlen(src); size_t len2 = strlen (src);
size_t ret = len1 + len2; size_t ret = len1 + len2;
if (len1 + len2 >= size) if (len1 + len2 >= size)
len2 = size - len1 - 1; len2 = size - len1 - 1;
if (len2 > 0) { if (len2 > 0)
memcpy(dst + len1, src, len2); {
dst[len1 + len2] = '\0'; memcpy (dst + len1, src, len2);
} dst[len1 + len2] = '\0';
}
return ret; return ret;
} }
#endif #endif
@ -83,30 +84,31 @@ strlcat(char *dst, const char *src, size_t size)
* negative return value indicates an error. * negative return value indicates an error.
*/ */
ssize_t ssize_t
chomp(char *buffer, size_t length) chomp (char *buffer, size_t length)
{ {
size_t chars; size_t chars;
assert(buffer != NULL); assert (buffer != NULL);
assert(length > 0); assert (length > 0);
/* Make sure the arguments are valid */ /* Make sure the arguments are valid */
if (buffer == NULL) if (buffer == NULL)
return -EFAULT; return -EFAULT;
if (length < 1) if (length < 1)
return -ERANGE; return -ERANGE;
chars = 0; chars = 0;
--length; --length;
while (buffer[length] == '\r' || buffer[length] == '\n') { while (buffer[length] == '\r' || buffer[length] == '\n')
buffer[length] = '\0'; {
chars++; buffer[length] = '\0';
chars++;
/* Stop once we get to zero to prevent wrap-around */ /* Stop once we get to zero to prevent wrap-around */
if (length-- == 0) if (length-- == 0)
break; break;
} }
return chars; return chars;
} }

10
src/text.h
View File

@ -22,13 +22,13 @@
#define TINYPROXY_TEXT_H #define TINYPROXY_TEXT_H
#ifndef HAVE_STRLCAT #ifndef HAVE_STRLCAT
extern size_t strlcat(char *dst, const char *src, size_t size); extern size_t strlcat (char *dst, const char *src, size_t size);
#endif /* HAVE_STRLCAT */ #endif /* HAVE_STRLCAT */
#ifndef HAVE_STRLCPY #ifndef HAVE_STRLCPY
extern size_t strlcpy(char *dst, const char *src, size_t size); extern size_t strlcpy (char *dst, const char *src, size_t size);
#endif /* HAVE_STRLCPY */ #endif /* HAVE_STRLCPY */
extern ssize_t chomp(char *buffer, size_t length); extern ssize_t chomp (char *buffer, size_t length);
#endif #endif

620
src/tinyproxy.c
View File

@ -41,60 +41,61 @@
#include "stats.h" #include "stats.h"
#include "utils.h" #include "utils.h"
RETSIGTYPE takesig(int sig); RETSIGTYPE takesig (int sig);
/* /*
* Global Structures * Global Structures
*/ */
struct config_s config; struct config_s config;
float load = 0.00; float load = 0.00;
unsigned int received_sighup = FALSE; /* boolean */ unsigned int received_sighup = FALSE; /* boolean */
unsigned int processed_config_file = FALSE; /* boolean */ unsigned int processed_config_file = FALSE; /* boolean */
/* /*
* Handle a signal * Handle a signal
*/ */
RETSIGTYPE RETSIGTYPE
takesig(int sig) takesig (int sig)
{ {
pid_t pid; pid_t pid;
int status; int status;
switch (sig) { switch (sig)
case SIGHUP: {
received_sighup = TRUE; case SIGHUP:
break; received_sighup = TRUE;
break;
case SIGTERM: case SIGTERM:
config.quit = TRUE; config.quit = TRUE;
break; break;
case SIGCHLD: case SIGCHLD:
while ((pid = waitpid(-1, &status, WNOHANG)) > 0) ; while ((pid = waitpid (-1, &status, WNOHANG)) > 0);
break; break;
} }
return; return;
} }
/* /*
* Display the version information for the user. * Display the version information for the user.
*/ */
static void static void
display_version(void) display_version (void)
{ {
printf("%s %s (%s)\n", PACKAGE, VERSION, TARGET_SYSTEM); printf ("%s %s (%s)\n", PACKAGE, VERSION, TARGET_SYSTEM);
} }
/* /*
* Display the copyright and license for this program. * Display the copyright and license for this program.
*/ */
static void static void
display_license(void) display_license (void)
{ {
display_version(); display_version ();
printf("\ printf ("\
Copyright 1998 Steven Young (sdyoung@well.com)\n\ Copyright 1998 Steven Young (sdyoung@well.com)\n\
Copyright 1998-2002 Robert James Kaes (rjkaes@users.sourceforge.net)\n\ Copyright 1998-2002 Robert James Kaes (rjkaes@users.sourceforge.net)\n\
Copyright 1999 George Talusan (gstalusan@uwaterloo.ca)\n\ Copyright 1999 George Talusan (gstalusan@uwaterloo.ca)\n\
@ -119,10 +120,10 @@ display_license(void)
* Display usage to the user. * Display usage to the user.
*/ */
static void static void
display_usage(void) display_usage (void)
{ {
printf("Usage: %s [options]\n", PACKAGE); printf ("Usage: %s [options]\n", PACKAGE);
printf("\ printf ("\
Options:\n\ Options:\n\
-d Operate in DEBUG mode.\n\ -d Operate in DEBUG mode.\n\
-c FILE Use an alternate configuration file.\n\ -c FILE Use an alternate configuration file.\n\
@ -130,319 +131,344 @@ Options:\n\
-l Display the license.\n\ -l Display the license.\n\
-v Display the version number.\n"); -v Display the version number.\n");
/* Display the modes compiled into tinyproxy */ /* Display the modes compiled into tinyproxy */
printf("\nFeatures compiled in:\n"); printf ("\nFeatures compiled in:\n");
#ifdef XTINYPROXY_ENABLE #ifdef XTINYPROXY_ENABLE
printf(" XTinyproxy header\n"); printf (" XTinyproxy header\n");
#endif /* XTINYPROXY */ #endif /* XTINYPROXY */
#ifdef FILTER_ENABLE #ifdef FILTER_ENABLE
printf(" Filtering\n"); printf (" Filtering\n");
#endif /* FILTER_ENABLE */ #endif /* FILTER_ENABLE */
#ifndef NDEBUG #ifndef NDEBUG
printf(" Debugging code\n"); printf (" Debugging code\n");
#endif /* NDEBUG */ #endif /* NDEBUG */
#ifdef TRANSPARENT_PROXY #ifdef TRANSPARENT_PROXY
printf(" Transparent proxy support\n"); printf (" Transparent proxy support\n");
#endif /* TRANSPARENT_PROXY */ #endif /* TRANSPARENT_PROXY */
#ifdef REVERSE_SUPPORT #ifdef REVERSE_SUPPORT
printf(" Reverse proxy support\n"); printf (" Reverse proxy support\n");
#endif /* REVERSE_SUPPORT */ #endif /* REVERSE_SUPPORT */
} }
static int static int
get_id (char *str) get_id (char *str)
{ {
char *tstr; char *tstr;
if (str == NULL) if (str == NULL)
return -1; return -1;
tstr = str; tstr = str;
while (*tstr != 0) { while (*tstr != 0)
if (!isdigit(*tstr)) {
return -1; if (!isdigit (*tstr))
tstr++; return -1;
} tstr++;
}
return atoi(str); return atoi (str);
} }
int int
main(int argc, char **argv) main (int argc, char **argv)
{ {
int optch; int optch;
unsigned int godaemon = TRUE; /* boolean */ unsigned int godaemon = TRUE; /* boolean */
struct passwd *thisuser = NULL; struct passwd *thisuser = NULL;
struct group *thisgroup = NULL; struct group *thisgroup = NULL;
FILE *config_file; FILE *config_file;
/* Only allow u+rw bits. This may be required for some versions /* Only allow u+rw bits. This may be required for some versions
* of glibc so that mkstemp() doesn't make us vulnerable. * of glibc so that mkstemp() doesn't make us vulnerable.
*/ */
umask(0177); umask (0177);
/* Default configuration file location */ /* Default configuration file location */
config.config_file = DEFAULT_CONF_FILE; config.config_file = DEFAULT_CONF_FILE;
/* /*
* Process the various options * Process the various options
*/ */
while ((optch = getopt(argc, argv, "c:vldh")) != EOF) { while ((optch = getopt (argc, argv, "c:vldh")) != EOF)
switch (optch) { {
case 'v': switch (optch)
display_version(); {
exit(EX_OK); case 'v':
case 'l': display_version ();
display_license(); exit (EX_OK);
exit(EX_OK); case 'l':
case 'd': display_license ();
godaemon = FALSE; exit (EX_OK);
break; case 'd':
case 'c': godaemon = FALSE;
config.config_file = safestrdup(optarg); break;
if (!config.config_file) { case 'c':
fprintf(stderr, config.config_file = safestrdup (optarg);
"%s: Could not allocate memory.\n", if (!config.config_file)
argv[0]); {
exit(EX_SOFTWARE); fprintf (stderr, "%s: Could not allocate memory.\n", argv[0]);
} exit (EX_SOFTWARE);
break; }
case 'h': break;
default: case 'h':
display_usage(); default:
exit(EX_OK); display_usage ();
} exit (EX_OK);
} }
}
log_message(LOG_INFO, "Initializing " PACKAGE " ..."); log_message (LOG_INFO, "Initializing " PACKAGE " ...");
/* /*
* Make sure the HTML error pages array is NULL to begin with. * Make sure the HTML error pages array is NULL to begin with.
* (FIXME: Should have a better API for all this) * (FIXME: Should have a better API for all this)
*/ */
config.errorpages = NULL; config.errorpages = NULL;
/* /*
* Read in the settings from the config file. * Read in the settings from the config file.
*/ */
config_file = fopen(config.config_file, "r"); config_file = fopen (config.config_file, "r");
if (!config_file) { if (!config_file)
fprintf(stderr, {
"%s: Could not open configuration file \"%s\".\n", fprintf (stderr,
argv[0], config.config_file); "%s: Could not open configuration file \"%s\".\n",
exit(EX_SOFTWARE); argv[0], config.config_file);
} exit (EX_SOFTWARE);
if (config_compile() || config_parse(&config, config_file)) { }
fprintf(stderr, if (config_compile () || config_parse (&config, config_file))
"Unable to parse configuration file. Not starting.\n"); {
exit(EX_SOFTWARE); fprintf (stderr,
} "Unable to parse configuration file. Not starting.\n");
fclose(config_file); exit (EX_SOFTWARE);
}
fclose (config_file);
/* /*
* Write to a user supplied log file if it's defined. This * Write to a user supplied log file if it's defined. This
* will override using the syslog even if syslog is defined. * will override using the syslog even if syslog is defined.
*/ */
if (config.logf_name) { if (config.logf_name)
if (open_log_file(config.logf_name) < 0) { {
fprintf(stderr, if (open_log_file (config.logf_name) < 0)
"%s: Could not create log file.\n", argv[0]); {
exit(EX_SOFTWARE); fprintf (stderr, "%s: Could not create log file.\n", argv[0]);
} exit (EX_SOFTWARE);
config.syslog = FALSE; /* disable syslog */ }
} else if (config.syslog) { config.syslog = FALSE; /* disable syslog */
if (godaemon == TRUE) }
openlog("tinyproxy", LOG_PID, LOG_DAEMON); else if (config.syslog)
else {
openlog("tinyproxy", LOG_PID, LOG_USER); if (godaemon == TRUE)
} else { openlog ("tinyproxy", LOG_PID, LOG_DAEMON);
fprintf(stderr, else
"%s: Either define a logfile or enable syslog logging\n", openlog ("tinyproxy", LOG_PID, LOG_USER);
argv[0]); }
exit(EX_SOFTWARE); else
} {
fprintf (stderr,
"%s: Either define a logfile or enable syslog logging\n",
argv[0]);
exit (EX_SOFTWARE);
}
processed_config_file = TRUE; processed_config_file = TRUE;
send_stored_logs(); send_stored_logs ();
/* /*
* Set the default values if they were not set in the config file. * Set the default values if they were not set in the config file.
*/ */
if (config.port == 0) { if (config.port == 0)
fprintf(stderr, {
"%s: You MUST set a Port in the configuration file.\n", fprintf (stderr,
argv[0]); "%s: You MUST set a Port in the configuration file.\n",
exit(EX_SOFTWARE); argv[0]);
} exit (EX_SOFTWARE);
if (!config.stathost) { }
log_message(LOG_INFO, "Setting stathost to \"%s\".", if (!config.stathost)
DEFAULT_STATHOST); {
config.stathost = DEFAULT_STATHOST; log_message (LOG_INFO, "Setting stathost to \"%s\".", DEFAULT_STATHOST);
} config.stathost = DEFAULT_STATHOST;
if (!config.user) { }
log_message(LOG_WARNING, if (!config.user)
"You SHOULD set a UserName in the configuration file. Using current user instead."); {
} log_message (LOG_WARNING,
if (config.idletimeout == 0) { "You SHOULD set a UserName in the configuration file. Using current user instead.");
log_message(LOG_WARNING, }
"Invalid idle time setting. Only values greater than zero allowed; therefore setting idle timeout to %u seconds.", if (config.idletimeout == 0)
MAX_IDLE_TIME); {
config.idletimeout = MAX_IDLE_TIME; log_message (LOG_WARNING,
} "Invalid idle time setting. Only values greater than zero allowed; therefore setting idle timeout to %u seconds.",
MAX_IDLE_TIME);
config.idletimeout = MAX_IDLE_TIME;
}
init_stats(); init_stats ();
/* /*
* If ANONYMOUS is turned on, make sure that Content-Length is * If ANONYMOUS is turned on, make sure that Content-Length is
* in the list of allowed headers, since it is required in a * in the list of allowed headers, since it is required in a
* HTTP/1.0 request. Also add the Content-Type header since it goes * HTTP/1.0 request. Also add the Content-Type header since it goes
* hand in hand with Content-Length. * hand in hand with Content-Length.
* - rjkaes * - rjkaes
*/ */
if (is_anonymous_enabled()) { if (is_anonymous_enabled ())
anonymous_insert("Content-Length"); {
anonymous_insert("Content-Type"); anonymous_insert ("Content-Length");
} anonymous_insert ("Content-Type");
}
if (godaemon == TRUE) if (godaemon == TRUE)
makedaemon(); makedaemon ();
if (config.pidpath) { if (config.pidpath)
if (pidfile_create(config.pidpath) < 0) { {
fprintf(stderr, "%s: Could not create PID file.\n", if (pidfile_create (config.pidpath) < 0)
argv[0]); {
exit(EX_OSERR); fprintf (stderr, "%s: Could not create PID file.\n", argv[0]);
} exit (EX_OSERR);
} }
}
if (set_signal_handler(SIGPIPE, SIG_IGN) == SIG_ERR) { if (set_signal_handler (SIGPIPE, SIG_IGN) == SIG_ERR)
fprintf(stderr, "%s: Could not set the \"SIGPIPE\" signal.\n", {
argv[0]); fprintf (stderr, "%s: Could not set the \"SIGPIPE\" signal.\n",
exit(EX_OSERR); argv[0]);
} exit (EX_OSERR);
}
#ifdef FILTER_ENABLE #ifdef FILTER_ENABLE
if (config.filter) if (config.filter)
filter_init(); filter_init ();
#endif /* FILTER_ENABLE */ #endif /* FILTER_ENABLE */
/* /*
* Start listening on the selected port. * Start listening on the selected port.
*/ */
if (child_listening_sock(config.port) < 0) { if (child_listening_sock (config.port) < 0)
fprintf(stderr, "%s: Could not create listening socket.\n", {
argv[0]); fprintf (stderr, "%s: Could not create listening socket.\n", argv[0]);
exit(EX_OSERR); exit (EX_OSERR);
} }
/* /*
* Switch to a different user. * Switch to a different user.
*/ */
if (geteuid() == 0) { if (geteuid () == 0)
if (config.group && strlen(config.group) > 0) { {
int gid = get_id(config.group); if (config.group && strlen (config.group) > 0)
if (gid < 0) { {
thisgroup = getgrnam(config.group); int gid = get_id (config.group);
if (!thisgroup) { if (gid < 0)
fprintf(stderr, {
"%s: Unable to find " thisgroup = getgrnam (config.group);
"group \"%s\".\n", if (!thisgroup)
argv[0], config.group); {
exit(EX_NOUSER); fprintf (stderr,
} "%s: Unable to find "
gid = thisgroup->gr_gid; "group \"%s\".\n", argv[0], config.group);
} exit (EX_NOUSER);
if (setgid(gid) < 0) { }
fprintf(stderr, gid = thisgroup->gr_gid;
"%s: Unable to change to " }
"group \"%s\".\n", if (setgid (gid) < 0)
argv[0], config.group); {
exit(EX_CANTCREAT); fprintf (stderr,
} "%s: Unable to change to "
log_message(LOG_INFO, "Now running as group \"%s\".", "group \"%s\".\n", argv[0], config.group);
config.group); exit (EX_CANTCREAT);
} }
if (config.user && strlen(config.user) > 0) { log_message (LOG_INFO, "Now running as group \"%s\".",
int uid = get_id(config.user); config.group);
if (uid < 0) { }
thisuser = getpwnam(config.user); if (config.user && strlen (config.user) > 0)
if (!thisuser) { {
fprintf(stderr, int uid = get_id (config.user);
"%s: Unable to find " if (uid < 0)
"user \"%s\".", {
argv[0], config.user); thisuser = getpwnam (config.user);
exit(EX_NOUSER); if (!thisuser)
} {
uid = thisuser->pw_uid; fprintf (stderr,
} "%s: Unable to find "
if (setuid(uid) < 0) { "user \"%s\".", argv[0], config.user);
fprintf(stderr, exit (EX_NOUSER);
"%s: Unable to change to user \"%s\".", }
argv[0], config.user); uid = thisuser->pw_uid;
exit(EX_CANTCREAT); }
} if (setuid (uid) < 0)
log_message(LOG_INFO, "Now running as user \"%s\".", {
config.user); fprintf (stderr,
} "%s: Unable to change to user \"%s\".",
} else { argv[0], config.user);
log_message(LOG_WARNING, exit (EX_CANTCREAT);
"Not running as root, so not changing UID/GID."); }
} log_message (LOG_INFO, "Now running as user \"%s\".", config.user);
}
}
else
{
log_message (LOG_WARNING,
"Not running as root, so not changing UID/GID.");
}
if (child_pool_create() < 0) { if (child_pool_create () < 0)
fprintf(stderr, "%s: Could not create the pool of children.", {
argv[0]); fprintf (stderr, "%s: Could not create the pool of children.", argv[0]);
exit(EX_SOFTWARE); exit (EX_SOFTWARE);
} }
/* /*
* These signals are only for the parent process. * These signals are only for the parent process.
*/ */
log_message(LOG_INFO, "Setting the various signals."); log_message (LOG_INFO, "Setting the various signals.");
if (set_signal_handler(SIGCHLD, takesig) == SIG_ERR) { if (set_signal_handler (SIGCHLD, takesig) == SIG_ERR)
fprintf(stderr, "%s: Could not set the \"SIGCHLD\" signal.\n", {
argv[0]); fprintf (stderr, "%s: Could not set the \"SIGCHLD\" signal.\n",
exit(EX_OSERR); argv[0]);
} exit (EX_OSERR);
if (set_signal_handler(SIGTERM, takesig) == SIG_ERR) { }
fprintf(stderr, "%s: Could not set the \"SIGTERM\" signal.\n", if (set_signal_handler (SIGTERM, takesig) == SIG_ERR)
argv[0]); {
exit(EX_OSERR); fprintf (stderr, "%s: Could not set the \"SIGTERM\" signal.\n",
} argv[0]);
if (set_signal_handler(SIGHUP, takesig) == SIG_ERR) { exit (EX_OSERR);
fprintf(stderr, "%s: Could not set the \"SIGHUP\" signal.\n", }
argv[0]); if (set_signal_handler (SIGHUP, takesig) == SIG_ERR)
exit(EX_OSERR); {
} fprintf (stderr, "%s: Could not set the \"SIGHUP\" signal.\n", argv[0]);
exit (EX_OSERR);
}
/* /*
* Start the main loop. * Start the main loop.
*/ */
log_message(LOG_INFO, "Starting main loop. Accepting connections."); log_message (LOG_INFO, "Starting main loop. Accepting connections.");
child_main_loop(); child_main_loop ();
log_message(LOG_INFO, "Shutting down."); log_message (LOG_INFO, "Shutting down.");
child_kill_children(); child_kill_children ();
child_close_sock(); child_close_sock ();
/* /*
* Remove the PID file. * Remove the PID file.
*/ */
if (unlink(config.pidpath) < 0) { if (unlink (config.pidpath) < 0)
log_message(LOG_WARNING, {
"Could not remove PID file \"%s\": %s.", log_message (LOG_WARNING,
config.pidpath, strerror(errno)); "Could not remove PID file \"%s\": %s.",
} config.pidpath, strerror (errno));
}
#ifdef FILTER_ENABLE #ifdef FILTER_ENABLE
if (config.filter) if (config.filter)
filter_destroy(); filter_destroy ();
#endif /* FILTER_ENABLE */ #endif /* FILTER_ENABLE */
if (config.syslog) if (config.syslog)
closelog(); closelog ();
else else
close_log_file(); close_log_file ();
exit(EX_OK); exit (EX_OK);
} }

108
src/tinyproxy.h
View File

@ -26,82 +26,84 @@
#include "hashmap.h" #include "hashmap.h"
/* Global variables for the main controls of the program */ /* Global variables for the main controls of the program */
#define MAXBUFFSIZE ((size_t)(1024 * 96)) /* Max size of buffer */ #define MAXBUFFSIZE ((size_t)(1024 * 96)) /* Max size of buffer */
#define MAX_IDLE_TIME (60 * 10) /* 10 minutes of no activity */ #define MAX_IDLE_TIME (60 * 10) /* 10 minutes of no activity */
/* /*
* Even if upstream support is not compiled into tinyproxy, this * Even if upstream support is not compiled into tinyproxy, this
* structure still needs to be defined. * structure still needs to be defined.
*/ */
struct upstream { struct upstream
struct upstream *next; {
char *domain; /* optional */ struct upstream *next;
char *host; char *domain; /* optional */
int port; char *host;
in_addr_t ip, mask; int port;
in_addr_t ip, mask;
}; };
/* /*
* Hold all the configuration time information. * Hold all the configuration time information.
*/ */
struct config_s { struct config_s
char *logf_name; {
char *config_file; char *logf_name;
unsigned int syslog; /* boolean */ char *config_file;
int port; unsigned int syslog; /* boolean */
char *stathost; int port;
unsigned int quit; /* boolean */ char *stathost;
char *user; unsigned int quit; /* boolean */
char *group; char *user;
char *ipAddr; char *group;
char *ipAddr;
#ifdef FILTER_ENABLE #ifdef FILTER_ENABLE
char *filter; char *filter;
unsigned int filter_url; /* boolean */ unsigned int filter_url; /* boolean */
unsigned int filter_extended; /* boolean */ unsigned int filter_extended; /* boolean */
unsigned int filter_casesensitive; /* boolean */ unsigned int filter_casesensitive; /* boolean */
#endif /* FILTER_ENABLE */ #endif /* FILTER_ENABLE */
#ifdef XTINYPROXY_ENABLE #ifdef XTINYPROXY_ENABLE
char *my_domain; char *my_domain;
#endif #endif
#ifdef REVERSE_SUPPORT #ifdef REVERSE_SUPPORT
struct reversepath *reversepath_list; struct reversepath *reversepath_list;
unsigned int reverseonly; /* boolean */ unsigned int reverseonly; /* boolean */
unsigned int reversemagic; /* boolean */ unsigned int reversemagic; /* boolean */
char *reversebaseurl; char *reversebaseurl;
#endif #endif
#ifdef UPSTREAM_SUPPORT #ifdef UPSTREAM_SUPPORT
struct upstream *upstream_list; struct upstream *upstream_list;
#endif /* UPSTREAM_SUPPORT */ #endif /* UPSTREAM_SUPPORT */
char *pidpath; char *pidpath;
unsigned int idletimeout; unsigned int idletimeout;
char *bind_address; char *bind_address;
unsigned int bindsame; unsigned int bindsame;
/* /*
* The configured name to use in the HTTP "Via" header field. * The configured name to use in the HTTP "Via" header field.
*/ */
char *via_proxy_name; char *via_proxy_name;
/* /*
* Error page support. Map error numbers to file paths. * Error page support. Map error numbers to file paths.
*/ */
hashmap_t errorpages; hashmap_t errorpages;
/* /*
* Error page to be displayed if appropriate page cannot be located * Error page to be displayed if appropriate page cannot be located
* in the errorpages structure. * in the errorpages structure.
*/ */
char *errorpage_undef; char *errorpage_undef;
/* /*
* The HTML statistics page. * The HTML statistics page.
*/ */
char *statpage; char *statpage;
}; };
/* Global Structures used in the program */ /* Global Structures used in the program */
extern struct config_s config; extern struct config_s config;
extern unsigned int received_sighup; /* boolean */ extern unsigned int received_sighup; /* boolean */
extern unsigned int processed_config_file; /* boolean */ extern unsigned int processed_config_file; /* boolean */
#endif #endif

140
src/transparent-proxy.c
View File

@ -36,86 +36,86 @@
* Build a URL from parts. * Build a URL from parts.
*/ */
static int static int
build_url(char **url, const char *host, int port, const char *path) build_url (char **url, const char *host, int port, const char *path)
{ {
int len; int len;
assert(url != NULL); assert (url != NULL);
assert(host != NULL); assert (host != NULL);
assert(port > 0 && port < 32768); assert (port > 0 && port < 32768);
assert(path != NULL); assert (path != NULL);
len = strlen(host) + strlen(path) + 14; len = strlen (host) + strlen (path) + 14;
*url = safemalloc(len); *url = safemalloc (len);
if (*url == NULL) if (*url == NULL)
return -1; return -1;
return snprintf(*url, len, "http://%s:%d%s", host, port, path); return snprintf (*url, len, "http://%s:%d%s", host, port, path);
} }
int int
do_transparent_proxy(struct conn_s *connptr, hashmap_t hashofheaders, do_transparent_proxy (struct conn_s *connptr, hashmap_t hashofheaders,
struct request_s *request, struct config_s *conf, char *url) struct request_s *request, struct config_s *conf,
char *url)
{ {
socklen_t length; socklen_t length;
char *data; char *data;
length = length = hashmap_entry_by_key (hashofheaders, "host", (void **) &data);
hashmap_entry_by_key(hashofheaders, "host", (void **)&data); if (length <= 0)
if (length <= 0) { {
struct sockaddr_in dest_addr; struct sockaddr_in dest_addr;
if (getsockname if (getsockname
(connptr->client_fd, (struct sockaddr *)&dest_addr, (connptr->client_fd, (struct sockaddr *) &dest_addr, &length) < 0)
&length) < 0) { {
log_message(LOG_ERR, log_message (LOG_ERR,
"process_request: cannot get destination IP for %d", "process_request: cannot get destination IP for %d",
connptr->client_fd); connptr->client_fd);
indicate_http_error(connptr, 400, "Bad Request", indicate_http_error (connptr, 400, "Bad Request",
"detail", "detail",
"Unknown destination", "Unknown destination", "url", url, NULL);
"url", url, NULL); return 0;
return 0; }
} request->host = safemalloc (17);
request->host = safemalloc(17); strcpy (request->host, inet_ntoa (dest_addr.sin_addr));
strcpy(request->host, inet_ntoa(dest_addr.sin_addr)); request->port = ntohs (dest_addr.sin_port);
request->port = ntohs(dest_addr.sin_port); request->path = safemalloc (strlen (url) + 1);
request->path = safemalloc(strlen(url) + 1); strcpy (request->path, url);
strcpy(request->path, url); safefree (url);
safefree(url); build_url (&url, request->host, request->port, request->path);
build_url(&url, request->host, request->port, log_message (LOG_INFO,
request->path); "process_request: trans IP %s %s for %d",
log_message(LOG_INFO, request->method, url, connptr->client_fd);
"process_request: trans IP %s %s for %d", }
request->method, url, connptr->client_fd); else
} else { {
request->host = safemalloc(length + 1); request->host = safemalloc (length + 1);
if (sscanf if (sscanf (data, "%[^:]:%hu", request->host, &request->port) != 2)
(data, "%[^:]:%hu", request->host, {
&request->port) != 2) { strcpy (request->host, data);
strcpy(request->host, data); request->port = HTTP_PORT;
request->port = HTTP_PORT; }
} request->path = safemalloc (strlen (url) + 1);
request->path = safemalloc(strlen(url) + 1); strcpy (request->path, url);
strcpy(request->path, url); safefree (url);
safefree(url); build_url (&url, request->host, request->port, request->path);
build_url(&url, request->host, request->port, log_message (LOG_INFO,
request->path); "process_request: trans Host %s %s for %d",
log_message(LOG_INFO, request->method, url, connptr->client_fd);
"process_request: trans Host %s %s for %d", }
request->method, url, connptr->client_fd); if (conf->ipAddr && strcmp (request->host, conf->ipAddr) == 0)
} {
if (conf->ipAddr && strcmp(request->host, conf->ipAddr) == 0) { log_message (LOG_ERR,
log_message(LOG_ERR, "process_request: destination IP is localhost %d",
"process_request: destination IP is localhost %d", connptr->client_fd);
connptr->client_fd); indicate_http_error (connptr, 400, "Bad Request",
indicate_http_error(connptr, 400, "Bad Request", "detail",
"detail", "You tried to connect to the machine the proxy is running on",
"You tried to connect to the machine the proxy is running on", "url", url, NULL);
"url", url, NULL); return 0;
return 0; }
}
return 1; return 1;
} }

7
src/transparent-proxy.h
View File

@ -29,9 +29,10 @@
#include "hashmap.h" #include "hashmap.h"
#include "reqs.h" #include "reqs.h"
extern int do_transparent_proxy(struct conn_s *connptr, extern int do_transparent_proxy (struct conn_s *connptr,
hashmap_t hashofheaders, struct request_s *request, hashmap_t hashofheaders,
struct config_s *config, char *url); struct request_s *request,
struct config_s *config, char *url);
#endif #endif

284
src/utils.c
View File

@ -34,175 +34,183 @@
* Build the data for a complete HTTP & HTML message for the client. * Build the data for a complete HTTP & HTML message for the client.
*/ */
int int
send_http_message(struct conn_s *connptr, int http_code, send_http_message (struct conn_s *connptr, int http_code,
const char *error_title, const char *message) const char *error_title, const char *message)
{ {
static char *headers[] = { static char *headers[] = {
"Server: " PACKAGE "/" VERSION, "Server: " PACKAGE "/" VERSION,
"Content-type: text/html", "Content-type: text/html",
"Connection: close" "Connection: close"
}; };
http_message_t msg; http_message_t msg;
msg = http_message_create(http_code, error_title); msg = http_message_create (http_code, error_title);
if (msg == NULL) if (msg == NULL)
return -1; return -1;
http_message_add_headers(msg, headers, 3); http_message_add_headers (msg, headers, 3);
http_message_set_body(msg, message, strlen(message)); http_message_set_body (msg, message, strlen (message));
http_message_send(msg, connptr->client_fd); http_message_send (msg, connptr->client_fd);
http_message_destroy(msg); http_message_destroy (msg);
return 0; return 0;
} }
/* /*
* Safely creates filename and returns the low-level file descriptor. * Safely creates filename and returns the low-level file descriptor.
*/ */
int int
create_file_safely(const char *filename, unsigned int truncate_file) create_file_safely (const char *filename, unsigned int truncate_file)
{ {
struct stat lstatinfo; struct stat lstatinfo;
int fildes; int fildes;
/* /*
* lstat() the file. If it doesn't exist, create it with O_EXCL. * lstat() the file. If it doesn't exist, create it with O_EXCL.
* If it does exist, open it for writing and perform the fstat() * If it does exist, open it for writing and perform the fstat()
* check. * check.
*/ */
if (lstat(filename, &lstatinfo) < 0) { if (lstat (filename, &lstatinfo) < 0)
/* {
* If lstat() failed for any reason other than "file not /*
* existing", exit. * If lstat() failed for any reason other than "file not
*/ * existing", exit.
if (errno != ENOENT) { */
fprintf(stderr, if (errno != ENOENT)
"%s: Error checking file %s: %s\n", {
PACKAGE, filename, strerror(errno)); fprintf (stderr,
return -EACCES; "%s: Error checking file %s: %s\n",
} PACKAGE, filename, strerror (errno));
return -EACCES;
}
/* /*
* The file doesn't exist, so create it with O_EXCL to make * The file doesn't exist, so create it with O_EXCL to make
* sure an attacker can't slip in a file between the lstat() * sure an attacker can't slip in a file between the lstat()
* and open() * and open()
*/ */
if ((fildes = if ((fildes = open (filename, O_RDWR | O_CREAT | O_EXCL, 0600)) < 0)
open(filename, O_RDWR | O_CREAT | O_EXCL, 0600)) < 0) { {
fprintf(stderr, fprintf (stderr,
"%s: Could not create file %s: %s\n", "%s: Could not create file %s: %s\n",
PACKAGE, filename, strerror(errno)); PACKAGE, filename, strerror (errno));
return fildes; return fildes;
} }
} else { }
struct stat fstatinfo; else
int flags; {
struct stat fstatinfo;
int flags;
flags = O_RDWR; flags = O_RDWR;
if (!truncate_file) if (!truncate_file)
flags |= O_APPEND; flags |= O_APPEND;
/* /*
* Open an existing file. * Open an existing file.
*/ */
if ((fildes = open(filename, flags)) < 0) { if ((fildes = open (filename, flags)) < 0)
fprintf(stderr, {
"%s: Could not open file %s: %s\n", fprintf (stderr,
PACKAGE, filename, strerror(errno)); "%s: Could not open file %s: %s\n",
return fildes; PACKAGE, filename, strerror (errno));
} return fildes;
}
/* /*
* fstat() the opened file and check that the file mode bits, * fstat() the opened file and check that the file mode bits,
* inode, and device match. * inode, and device match.
*/ */
if (fstat(fildes, &fstatinfo) < 0 if (fstat (fildes, &fstatinfo) < 0
|| lstatinfo.st_mode != fstatinfo.st_mode || lstatinfo.st_mode != fstatinfo.st_mode
|| lstatinfo.st_ino != fstatinfo.st_ino || lstatinfo.st_ino != fstatinfo.st_ino
|| lstatinfo.st_dev != fstatinfo.st_dev) { || lstatinfo.st_dev != fstatinfo.st_dev)
fprintf(stderr, {
"%s: The file %s has been changed before it could be opened\n", fprintf (stderr,
PACKAGE, filename); "%s: The file %s has been changed before it could be opened\n",
close(fildes); PACKAGE, filename);
return -EIO; close (fildes);
} return -EIO;
}
/* /*
* If the above check was passed, we know that the lstat() * If the above check was passed, we know that the lstat()
* and fstat() were done on the same file. Now we check that * and fstat() were done on the same file. Now we check that
* there's only one link, and that it's a normal file (this * there's only one link, and that it's a normal file (this
* isn't strictly necessary because the fstat() vs lstat() * isn't strictly necessary because the fstat() vs lstat()
* st_mode check would also find this) * st_mode check would also find this)
*/ */
if (fstatinfo.st_nlink > 1 || !S_ISREG(lstatinfo.st_mode)) { if (fstatinfo.st_nlink > 1 || !S_ISREG (lstatinfo.st_mode))
fprintf(stderr, {
"%s: The file %s has too many links, or is not a regular file: %s\n", fprintf (stderr,
PACKAGE, filename, strerror(errno)); "%s: The file %s has too many links, or is not a regular file: %s\n",
close(fildes); PACKAGE, filename, strerror (errno));
return -EMLINK; close (fildes);
} return -EMLINK;
}
/* /*
* Just return the file descriptor if we _don't_ want the file * Just return the file descriptor if we _don't_ want the file
* truncated. * truncated.
*/ */
if (!truncate_file) if (!truncate_file)
return fildes; return fildes;
/* /*
* On systems which don't support ftruncate() the best we can * On systems which don't support ftruncate() the best we can
* do is to close the file and reopen it in create mode, which * do is to close the file and reopen it in create mode, which
* unfortunately leads to a race condition, however "systems * unfortunately leads to a race condition, however "systems
* which don't support ftruncate()" is pretty much SCO only, * which don't support ftruncate()" is pretty much SCO only,
* and if you're using that you deserve what you get. * and if you're using that you deserve what you get.
* ("Little sympathy has been extended") * ("Little sympathy has been extended")
*/ */
#ifdef HAVE_FTRUNCATE #ifdef HAVE_FTRUNCATE
ftruncate(fildes, 0); ftruncate (fildes, 0);
#else #else
close(fildes); close (fildes);
if ((fildes = if ((fildes = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0600)) < 0)
open(filename, O_RDWR | O_CREAT | O_TRUNC, 0600)) < 0) { {
fprintf(stderr, fprintf (stderr,
"%s: Could not open file %s: %s.", "%s: Could not open file %s: %s.",
PACKAGE, filename, strerror(errno)); PACKAGE, filename, strerror (errno));
return fildes; return fildes;
} }
#endif /* HAVE_FTRUNCATE */ #endif /* HAVE_FTRUNCATE */
} }
return fildes; return fildes;
} }
/* /*
* Write the PID of the program to the specified file. * Write the PID of the program to the specified file.
*/ */
int int
pidfile_create(const char *filename) pidfile_create (const char *filename)
{ {
int fildes; int fildes;
FILE *fd; FILE *fd;
/* /*
* Create a new file * Create a new file
*/ */
if ((fildes = create_file_safely(filename, TRUE)) < 0) if ((fildes = create_file_safely (filename, TRUE)) < 0)
return fildes; return fildes;
/* /*
* Open a stdio file over the low-level one. * Open a stdio file over the low-level one.
*/ */
if ((fd = fdopen(fildes, "w")) == NULL) { if ((fd = fdopen (fildes, "w")) == NULL)
fprintf(stderr, {
"%s: Could not write PID file %s: %s.", fprintf (stderr,
PACKAGE, filename, strerror(errno)); "%s: Could not write PID file %s: %s.",
close(fildes); PACKAGE, filename, strerror (errno));
unlink(filename); close (fildes);
return -EIO; unlink (filename);
} return -EIO;
}
fprintf(fd, "%ld\n", (long)getpid()); fprintf (fd, "%ld\n", (long) getpid ());
fclose(fd); fclose (fd);
return 0; return 0;
} }

9
src/utils.h
View File

@ -27,10 +27,11 @@
*/ */
struct conn_s; struct conn_s;
extern int send_http_message(struct conn_s *connptr, int http_code, extern int send_http_message (struct conn_s *connptr, int http_code,
const char *error_title, const char *message); const char *error_title, const char *message);
extern int pidfile_create(const char *path); extern int pidfile_create (const char *path);
extern int create_file_safely(const char *filename, unsigned int truncate_file); extern int create_file_safely (const char *filename,
unsigned int truncate_file);
#endif #endif

170
src/vector.c
View File

@ -33,17 +33,19 @@
* vector_s stores a pointer to the first vector (vector[0]) and a * vector_s stores a pointer to the first vector (vector[0]) and a
* count of the number of entries (or how long the vector is.) * count of the number of entries (or how long the vector is.)
*/ */
struct vectorentry_s { struct vectorentry_s
void *data; {
size_t len; void *data;
size_t len;
struct vectorentry_s *next; struct vectorentry_s *next;
}; };
struct vector_s { struct vector_s
size_t num_entries; {
struct vectorentry_s *head; size_t num_entries;
struct vectorentry_s *tail; struct vectorentry_s *head;
struct vectorentry_s *tail;
}; };
/* /*
@ -54,18 +56,18 @@ struct vector_s {
* vector. * vector.
*/ */
vector_t vector_t
vector_create(void) vector_create (void)
{ {
vector_t vector; vector_t vector;
vector = safemalloc(sizeof(struct vector_s)); vector = safemalloc (sizeof (struct vector_s));
if (!vector) if (!vector)
return NULL; return NULL;
vector->num_entries = 0; vector->num_entries = 0;
vector->head = vector->tail = NULL; vector->head = vector->tail = NULL;
return vector; return vector;
} }
/* /*
@ -75,25 +77,26 @@ vector_create(void)
* negative if a NULL vector is supplied * negative if a NULL vector is supplied
*/ */
int int
vector_delete(vector_t vector) vector_delete (vector_t vector)
{ {
struct vectorentry_s *ptr, *next; struct vectorentry_s *ptr, *next;
if (!vector) if (!vector)
return -EINVAL; return -EINVAL;
ptr = vector->head; ptr = vector->head;
while (ptr) { while (ptr)
next = ptr->next; {
safefree(ptr->data); next = ptr->next;
safefree(ptr); safefree (ptr->data);
safefree (ptr);
ptr = next; ptr = next;
} }
safefree(vector); safefree (vector);
return 0; return 0;
} }
/* /*
@ -110,44 +113,48 @@ vector_delete(vector_t vector)
#define INSERT_APPEND 1 #define INSERT_APPEND 1
static int static int
vector_insert(vector_t vector, void *data, ssize_t len, int pos) vector_insert (vector_t vector, void *data, ssize_t len, int pos)
{ {
struct vectorentry_s *entry; struct vectorentry_s *entry;
if (!vector || !data || len <= 0 || if (!vector || !data || len <= 0 ||
(pos != INSERT_PREPEND && pos != INSERT_APPEND)) (pos != INSERT_PREPEND && pos != INSERT_APPEND))
return -EINVAL; return -EINVAL;
entry = safemalloc(sizeof(struct vectorentry_s)); entry = safemalloc (sizeof (struct vectorentry_s));
if (!entry) if (!entry)
return -ENOMEM; return -ENOMEM;
entry->data = safemalloc(len); entry->data = safemalloc (len);
if (!entry->data) { if (!entry->data)
safefree(entry); {
return -ENOMEM; safefree (entry);
} return -ENOMEM;
}
memcpy(entry->data, data, len); memcpy (entry->data, data, len);
entry->len = len; entry->len = len;
entry->next = NULL; entry->next = NULL;
/* If there is no head or tail, create them */ /* If there is no head or tail, create them */
if (!vector->head && !vector->tail) if (!vector->head && !vector->tail)
vector->head = vector->tail = entry; vector->head = vector->tail = entry;
else if (pos == 0) { else if (pos == 0)
/* prepend the entry */ {
entry->next = vector->head; /* prepend the entry */
vector->head = entry; entry->next = vector->head;
} else { vector->head = entry;
/* append the entry */ }
vector->tail->next = entry; else
vector->tail = entry; {
} /* append the entry */
vector->tail->next = entry;
vector->tail = entry;
}
vector->num_entries++; vector->num_entries++;
return 0; return 0;
} }
/* /*
@ -156,15 +163,15 @@ vector_insert(vector_t vector, void *data, ssize_t len, int pos)
* arguments. * arguments.
*/ */
int int
vector_append(vector_t vector, void *data, ssize_t len) vector_append (vector_t vector, void *data, ssize_t len)
{ {
return vector_insert(vector, data, len, INSERT_APPEND); return vector_insert (vector, data, len, INSERT_APPEND);
} }
int int
vector_prepend(vector_t vector, void *data, ssize_t len) vector_prepend (vector_t vector, void *data, ssize_t len)
{ {
return vector_insert(vector, data, len, INSERT_PREPEND); return vector_insert (vector, data, len, INSERT_PREPEND);
} }
/* /*
@ -175,26 +182,27 @@ vector_prepend(vector_t vector, void *data, ssize_t len)
* length of data if position is valid * length of data if position is valid
*/ */
void * void *
vector_getentry(vector_t vector, size_t pos, size_t * size) vector_getentry (vector_t vector, size_t pos, size_t * size)
{ {
struct vectorentry_s *ptr; struct vectorentry_s *ptr;
size_t loc; size_t loc;
if (!vector || pos >= vector->num_entries) if (!vector || pos >= vector->num_entries)
return NULL; return NULL;
loc = 0; loc = 0;
ptr = vector->head; ptr = vector->head;
while (loc != pos) { while (loc != pos)
ptr = ptr->next; {
loc++; ptr = ptr->next;
} loc++;
}
if (size) if (size)
*size = ptr->len; *size = ptr->len;
return ptr->data; return ptr->data;
} }
/* /*
@ -204,10 +212,10 @@ vector_getentry(vector_t vector, size_t pos, size_t * size)
* positive length of vector otherwise * positive length of vector otherwise
*/ */
ssize_t ssize_t
vector_length(vector_t vector) vector_length (vector_t vector)
{ {
if (!vector) if (!vector)
return -EINVAL; return -EINVAL;
return vector->num_entries; return vector->num_entries;
} }

22
src/vector.h
View File

@ -23,7 +23,8 @@
/* Allow the use in C++ code. */ /* Allow the use in C++ code. */
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
/* /*
@ -31,14 +32,14 @@ extern "C" {
* vector. Sure, it's a pointer, but the struct is hidden in the C file. * vector. Sure, it's a pointer, but the struct is hidden in the C file.
* So, just use the vector_t like it's a cookie. :) * So, just use the vector_t like it's a cookie. :)
*/ */
typedef struct vector_s *vector_t; typedef struct vector_s *vector_t;
/* /*
* vector_create() takes no arguments. * vector_create() takes no arguments.
* vector_delete() is self explanatory. * vector_delete() is self explanatory.
*/ */
extern vector_t vector_create(void); extern vector_t vector_create (void);
extern int vector_delete(vector_t vector); extern int vector_delete (vector_t vector);
/* /*
* When you insert a piece of data into the vector, the data will be * When you insert a piece of data into the vector, the data will be
@ -48,8 +49,8 @@ extern "C" {
* Returns: negative on error * Returns: negative on error
* 0 upon successful insert. * 0 upon successful insert.
*/ */
extern int vector_append(vector_t vector, void *data, ssize_t len); extern int vector_append (vector_t vector, void *data, ssize_t len);
extern int vector_prepend(vector_t vector, void *data, ssize_t len); extern int vector_prepend (vector_t vector, void *data, ssize_t len);
/* /*
* A pointer to the data at position "pos" (zero based) is returned and the * A pointer to the data at position "pos" (zero based) is returned and the
@ -67,8 +68,7 @@ extern "C" {
* Returns: NULL on error * Returns: NULL on error
* valid pointer to data * valid pointer to data
*/ */
extern void *vector_getentry(vector_t vector, size_t pos, extern void *vector_getentry (vector_t vector, size_t pos, size_t * size);
size_t * size);
/* /*
* Returns the number of enteries (or the length) of the vector. * Returns the number of enteries (or the length) of the vector.
@ -76,9 +76,9 @@ extern "C" {
* Returns: negative if vector is not valid * Returns: negative if vector is not valid
* positive length of vector otherwise * positive length of vector otherwise
*/ */
extern ssize_t vector_length(vector_t vector); extern ssize_t vector_length (vector_t vector);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif /* C++ */ #endif /* C++ */
#endif /* _VECTOR_H */ #endif /* _VECTOR_H */