Pantyhose-X
/
tinyproxy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

replace leftover users of hashmap with htab 

also fixes a bug where the ErrorFile directive would create a
new hashmap on every added item, effectively allowing only
the use of the last specified errornumber, and producing memory
leaks on each config reload.
master
rofl0r 2020-09-12 21:33:59 +01:00
parent 34a8b28414
commit 155bfbbe87
12 changed files with 89 additions and 687 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Makefile.am
View File

@ -32,7 +32,6 @@ tinyproxy_SOURCES = \
conf.c conf.h \
conns.c conns.h \
daemon.c daemon.h \
hashmap.c hashmap.h \
heap.c heap.h \
html-error.c html-error.h \
http-message.c http-message.h \

16
src/anonymous.c
View File

@ -23,7 +23,7 @@
#include "main.h"
#include "anonymous.h"
#include "hashmap.h"
#include "hsearch.h"
#include "heap.h"
#include "log.h"
#include "conf.h"
@ -42,7 +42,7 @@ int anonymous_search (struct config_s *conf, const char *s)
assert (s != NULL);
assert (conf->anonymous_map != NULL);
return hashmap_search (conf->anonymous_map, s);
return !!htab_find (conf->anonymous_map, s);
}
/*
@ -51,23 +51,21 @@ int anonymous_search (struct config_s *conf, const char *s)
* Return -1 if there is an error, otherwise a 0 is returned if the insert was
* successful.
*/
int anonymous_insert (struct config_s *conf, const char *s)
int anonymous_insert (struct config_s *conf, char *s)
{
char data = 1;
assert (s != NULL);
if (!conf->anonymous_map) {
conf->anonymous_map = hashmap_create (32);
conf->anonymous_map = htab_create (32);
if (!conf->anonymous_map)
return -1;
}
if (hashmap_search (conf->anonymous_map, s) > 0) {
/* The key was already found, so return a positive number. */
if (htab_find (conf->anonymous_map, s)) {
/* The key was already found. */
return 0;
}
/* Insert the new key */
return hashmap_insert (conf->anonymous_map, s, &data, sizeof (data));
return htab_insert (conf->anonymous_map, s, HTV_N(1)) ? 0 : -1;
}

2
src/anonymous.h
View File

@ -23,6 +23,6 @@
extern short int is_anonymous_enabled (struct config_s *conf);
extern int anonymous_search (struct config_s *conf, const char *s);
extern int anonymous_insert (struct config_s *conf, const char *s);
extern int anonymous_insert (struct config_s *conf, char *s);
#endif

37
src/conf.c
View File

@ -288,6 +288,9 @@ free_added_headers (vector_t add_headers)
void free_config (struct config_s *conf)
{
char *k;
htab_value *v;
size_t it;
safefree (conf->logf_name);
safefree (conf->stathost);
safefree (conf->user);
@ -307,13 +310,25 @@ void free_config (struct config_s *conf)
safefree (conf->pidpath);
safefree (conf->bind_address);
safefree (conf->via_proxy_name);
hashmap_delete (conf->errorpages);
if (conf->errorpages) {
it = 0;
while((it = htab_next(conf->errorpages, it, &k, &v))) {
safefree(k);
safefree(v->p);
}
htab_destroy (conf->errorpages);
}
free_added_headers (conf->add_headers);
safefree (conf->errorpage_undef);
safefree (conf->statpage);
flush_access_list (conf->access_list);
free_connect_ports_list (conf->connect_ports);
hashmap_delete (conf->anonymous_map);
if (conf->anonymous_map) {
it = 0;
while((it = htab_next(conf->anonymous_map, it, &k, &v)))
safefree(k);
htab_destroy (conf->anonymous_map);
}
memset (conf, 0, sizeof(*conf));
}
@ -623,8 +638,14 @@ static HANDLE_FUNC (handle_anonymous)
if (!arg)
return -1;
anonymous_insert (conf, arg);
safefree (arg);
if(anonymous_insert (conf, arg) < 0) {
log_message (LOG_WARNING,
"anonymous_insert() failed: '%s'",
arg);
safefree(arg);
return -1;
}
return 0;
}
@ -814,8 +835,12 @@ static HANDLE_FUNC (handle_errorfile)
unsigned long int err = get_long_arg (line, &match[2]);
char *page = get_string_arg (line, &match[4]);
add_new_errorpage (conf, page, err);
safefree (page);
if(add_new_errorpage (conf, page, err) < 0) {
log_message (LOG_WARNING,
"add_new_errorpage() failed: '%s'",
page);
safefree (page);
}
return 0;
}

6
src/conf.h
View File

@ -22,7 +22,7 @@
#ifndef TINYPROXY_CONF_H
#define TINYPROXY_CONF_H
#include "hashmap.h"
#include "hsearch.h"
#include "vector.h"
#include "acl.h"
@ -81,7 +81,7 @@ struct config_s {
/*
* Error page support. Map error numbers to file paths.
*/
hashmap_t errorpages;
struct htab *errorpages;
/*
* Error page to be displayed if appropriate page cannot be located
@ -105,7 +105,7 @@ struct config_s {
* Map of headers which should be let through when the
* anonymous feature is turned on.
*/
hashmap_t anonymous_map;
struct htab *anonymous_map;
/*
* Extra headers to be added to outgoing HTTP requests.

12
src/conns.c
View File

@ -122,8 +122,16 @@ void destroy_conn (struct conn_s *connptr)
if (connptr->request_line)
safefree (connptr->request_line);
if (connptr->error_variables)
hashmap_delete (connptr->error_variables);
if (connptr->error_variables) {
char *k;
htab_value *v;
size_t it = 0;
while((it = htab_next(connptr->error_variables, it, &k, &v))) {
safefree(v->p);
safefree(k);
}
htab_destroy (connptr->error_variables);
}
if (connptr->error_string)
safefree (connptr->error_string);

4
src/conns.h
View File

@ -22,7 +22,7 @@
#define TINYPROXY_CONNS_H
#include "main.h"
#include "hashmap.h"
#include "hsearch.h"
/*
* Connection Definition
@ -45,7 +45,7 @@ struct conn_s {
* This structure stores key -> value mappings for substitution
* in the error HTML files.
*/
hashmap_t error_variables;
struct htab *error_variables;
int error_number;
char *error_string;

516
src/hashmap.c
View File

@ -1,516 +0,0 @@
/* tinyproxy - A fast light-weight HTTP proxy
* Copyright (C) 2002 Robert James Kaes <rjkaes@users.sourceforge.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/* A hashmap implementation. The keys are case-insensitive NULL terminated
* strings, and the data is arbitrary lumps of data. Copies of both the
* key and the data in the hashmap itself, so you must free the original
* key and data to avoid a memory leak. The hashmap returns a pointer
* to the data when a key is searched for, so take care in modifying the
* data as it's modifying the data stored in the hashmap. (In other words,
* don't try to free the data, or realloc the memory. :)
*/
#include "main.h"
#include "hashmap.h"
#include "heap.h"
/*
* These structures are the storage for the hashmap. Entries are stored in
* struct hashentry_s (the key, data, and length), and all the "buckets" are
* grouped together in hashmap_s. The hashmap_s.size member is for
* internal use. It stores the number of buckets the hashmap was created
* with.
*/
struct hashentry_s {
char *key;
void *data;
size_t len;
struct hashentry_s *prev, *next;
};
struct hashbucket_s {
struct hashentry_s *head, *tail;
};
struct hashmap_s {
uint32_t seed;
unsigned int size;
hashmap_iter end_iterator;
struct hashbucket_s *buckets;
};
/*
* A NULL terminated string is passed to this function and a "hash" value
* is produced within the range of [0 .. size) (In other words, 0 to one
* less than size.)
* The contents of the key are converted to lowercase, so this function
* is not case-sensitive.
*
* This is Dan Bernstein's hash function as described, for example, here:
* http://www.cse.yorku.ca/~oz/hash.html
*
* If any of the arguments are invalid a negative number is returned.
*/
static int hashfunc (const char *key, unsigned int size, uint32_t seed)
{
uint32_t hash;
if (key == NULL)
return -EINVAL;
if (size == 0)
return -ERANGE;
for (hash = seed; *key != '\0'; key++) {
hash = ((hash << 5) + hash) ^ tolower (*key);
}
/* Keep the hash within the table limits */
return hash % size;
}
/*
* Create a hashmap with the requested number of buckets. If "nbuckets" is
* not greater than zero a NULL is returned; otherwise, a _token_ to the
* hashmap is returned.
*
* NULLs are also returned if memory could not be allocated for hashmap.
*/
hashmap_t hashmap_create (unsigned int nbuckets)
{
struct hashmap_s *ptr;
if (nbuckets == 0)
return NULL;
ptr = (struct hashmap_s *) safecalloc (1, sizeof (struct hashmap_s));
if (!ptr)
return NULL;
ptr->seed = (uint32_t)rand();
ptr->size = nbuckets;
ptr->buckets = (struct hashbucket_s *) safecalloc (nbuckets,
sizeof (struct
hashbucket_s));
if (!ptr->buckets) {
safefree (ptr);
return NULL;
}
/* This points to "one" past the end of the hashmap. */
ptr->end_iterator = 0;
return ptr;
}
/*
* Follow the chain of hashentries and delete them (including the data and
* the key.)
*
* Returns: 0 if the function completed successfully
* negative number is returned if "entry" was NULL
*/
static int delete_hashbucket (struct hashbucket_s *bucket)
{
struct hashentry_s *nextptr;
struct hashentry_s *ptr;
if (bucket == NULL || bucket->head == NULL)
return -EINVAL;
ptr = bucket->head;
while (ptr) {
nextptr = ptr->next;
safefree (ptr->key);
safefree (ptr->data);
safefree (ptr);
ptr = nextptr;
}
return 0;
}
/*
* Deletes a hashmap. All the key/data pairs are also deleted.
*
* Returns: 0 on success
* negative if a NULL "map" was supplied
*/
int hashmap_delete (hashmap_t map)
{
unsigned int i;
if (map == NULL)
return -EINVAL;
for (i = 0; i != map->size; i++) {
if (map->buckets[i].head != NULL) {
delete_hashbucket (&map->buckets[i]);
}
}
safefree (map->buckets);
safefree (map);
return 0;
}
/*
* Inserts a NULL terminated string (as the key), plus any arbitrary "data"
* of "len" bytes. Both the key and the data are copied, so the original
* key/data must be freed to avoid a memory leak.
* The "data" must be non-NULL and "len" must be greater than zero. You
* cannot insert NULL data in association with the key.
*
* Returns: 0 on success
* negative number if there are errors
*/
int
hashmap_insert (hashmap_t map, const char *key, const void *data, size_t len)
{
struct hashentry_s *ptr;
int hash;
char *key_copy;
void *data_copy;
assert (map != NULL);
assert (key != NULL);
assert (data != NULL);
assert (len > 0);
if (map == NULL || key == NULL)
return -EINVAL;
if (!data || len < 1)
return -ERANGE;
hash = hashfunc (key, map->size, map->seed);
if (hash < 0)
return hash;
/*
* First make copies of the key and data in case there is a memory
* problem later.
*/
key_copy = safestrdup (key);
if (!key_copy)
return -ENOMEM;
data_copy = safemalloc (len);
if (!data_copy) {
safefree (key_copy);
return -ENOMEM;
}
memcpy (data_copy, data, len);
ptr = (struct hashentry_s *) safemalloc (sizeof (struct hashentry_s));
if (!ptr) {
safefree (key_copy);
safefree (data_copy);
return -ENOMEM;
}
ptr->key = key_copy;
ptr->data = data_copy;
ptr->len = len;
/*
* Now add the entry to the end of the bucket chain.
*/
ptr->next = NULL;
ptr->prev = map->buckets[hash].tail;
if (map->buckets[hash].tail)
map->buckets[hash].tail->next = ptr;
map->buckets[hash].tail = ptr;
if (!map->buckets[hash].head)
map->buckets[hash].head = ptr;
map->end_iterator++;
return 0;
}
/*
* Get an iterator to the first entry.
*
* Returns: an negative value upon error.
*/
hashmap_iter hashmap_first (hashmap_t map)
{
assert (map != NULL);
if (!map)
return -EINVAL;
if (map->end_iterator == 0)
return -1;
else
return 0;
}
/*
* Checks to see if the iterator is pointing at the "end" of the entries.
*
* Returns: 1 if it is the end
* 0 otherwise
*/
int hashmap_is_end (hashmap_t map, hashmap_iter iter)
{
assert (map != NULL);
assert (iter >= 0);
if (!map || iter < 0)
return -EINVAL;
if (iter == map->end_iterator)
return 1;
else
return 0;
}
/*
* Return a "pointer" to the first instance of the particular key. It can
* be tested against hashmap_is_end() to see if the key was not found.
*
* Returns: negative upon an error
* an "iterator" pointing at the first key
* an "end-iterator" if the key wasn't found
*/
hashmap_iter hashmap_find (hashmap_t map, const char *key)
{
unsigned int i;
hashmap_iter iter = 0;
struct hashentry_s *ptr;
assert (map != NULL);
assert (key != NULL);
if (!map || !key)
return -EINVAL;
/*
* Loop through all the keys and look for the first occurrence
* of a particular key.
*/
for (i = 0; i != map->size; i++) {
ptr = map->buckets[i].head;
while (ptr) {
if (strcasecmp (ptr->key, key) == 0) {
/* Found it, so return the current count */
return iter;
}
iter++;
ptr = ptr->next;
}
}
return iter;
}
/*
* Retrieve the data associated with a particular iterator.
*
* Returns: the length of the data block upon success
* negative upon error
*/
ssize_t
hashmap_return_entry (hashmap_t map, hashmap_iter iter, char **key, void **data)
{
unsigned int i;
struct hashentry_s *ptr;
hashmap_iter count = 0;
assert (map != NULL);
assert (iter >= 0);
assert (iter != map->end_iterator);
assert (key != NULL);
assert (data != NULL);
if (!map || iter < 0 || !key || !data)
return -EINVAL;
for (i = 0; i != map->size; i++) {
ptr = map->buckets[i].head;
while (ptr) {
if (count == iter) {
/* This is the data so return it */
*key = ptr->key;
*data = ptr->data;
return ptr->len;
}
ptr = ptr->next;
count++;
}
}
return -EFAULT;
}
/*
* Searches for _any_ occurrences of "key" within the hashmap.
*
* Returns: negative upon an error
* zero if no key is found
* count found
*/
ssize_t hashmap_search (hashmap_t map, const char *key)
{
int hash;
struct hashentry_s *ptr;
ssize_t count = 0;
if (map == NULL || key == NULL)
return -EINVAL;
hash = hashfunc (key, map->size, map->seed);
if (hash < 0)
return hash;
ptr = map->buckets[hash].head;
/* All right, there is an entry here, now see if it's the one we want */
while (ptr) {
if (strcasecmp (ptr->key, key) == 0)
++count;
/* This entry didn't contain the key; move to the next one */
ptr = ptr->next;
}
return count;
}
/*
* Get the first entry (assuming there is more than one) for a particular
* key. The data MUST be non-NULL.
*
* Returns: negative upon error
* zero if no entry is found
* length of data for the entry
*/
ssize_t hashmap_entry_by_key (hashmap_t map, const char *key, void **data)
{
int hash;
struct hashentry_s *ptr;
if (!map || !key || !data)
return -EINVAL;
hash = hashfunc (key, map->size, map->seed);
if (hash < 0)
return hash;
ptr = map->buckets[hash].head;
while (ptr) {
if (strcasecmp (ptr->key, key) == 0) {
*data = ptr->data;
return ptr->len;
}
ptr = ptr->next;
}
return 0;
}
/*
* Go through the hashmap and remove the particular key.
* NOTE: This will invalidate any iterators which have been created.
*
* Remove: negative upon error
* 0 if the key was not found
* positive count of entries deleted
*/
ssize_t hashmap_remove (hashmap_t map, const char *key)
{
int hash;
struct hashentry_s *ptr, *next;
short int deleted = 0;
if (map == NULL || key == NULL)
return -EINVAL;
hash = hashfunc (key, map->size, map->seed);
if (hash < 0)
return hash;
ptr = map->buckets[hash].head;
while (ptr) {
if (strcasecmp (ptr->key, key) == 0) {
/*
* Found the data, now need to remove everything
* and update the hashmap.
*/
next = ptr->next;
if (ptr->prev)
ptr->prev->next = ptr->next;
if (ptr->next)
ptr->next->prev = ptr->prev;
if (map->buckets[hash].head == ptr)
map->buckets[hash].head = ptr->next;
if (map->buckets[hash].tail == ptr)
map->buckets[hash].tail = ptr->prev;
safefree (ptr->key);
safefree (ptr->data);
safefree (ptr);
++deleted;
--map->end_iterator;
ptr = next;
continue;
}
/* This entry didn't contain the key; move to the next one */
ptr = ptr->next;
}
/* The key was not found, so return 0 */
return deleted;
}
/*
* Look up the value for a variable.
*/
char *lookup_variable (hashmap_t map, const char *varname)
{
hashmap_iter result_iter;
char *key;
char *data;
result_iter = hashmap_find (map, varname);
if (hashmap_is_end (map, result_iter))
return (NULL);
if (hashmap_return_entry (map, result_iter,
&key, (void **) &data) < 0)
return (NULL);
return (data);
}

125
src/hashmap.h
View File

@ -1,125 +0,0 @@
/* tinyproxy - A fast light-weight HTTP proxy
* Copyright (C) 2002 Robert James Kaes <rjkaes@users.sourceforge.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/* See 'hashmap.c' for detailed information. */
#ifndef _HASHMAP_H
#define _HASHMAP_H
#include "common.h"
/*
* We're using a typedef here to "hide" the implementation details of the
* 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. :)
*/
typedef struct hashmap_s *hashmap_t;
typedef int hashmap_iter;
/*
* hashmap_create() takes one argument, which is the number of buckets to
* use internally. hashmap_delete() is self explanatory.
*/
extern hashmap_t hashmap_create (unsigned int nbuckets);
extern int hashmap_delete (hashmap_t map);
/*
* When the you insert a key/data pair into the hashmap it will the key
* and data are duplicated, so you must free your copy if it was created
* on the heap. The key must be a NULL terminated string. "data" must be
* non-NULL and length must be greater than zero.
*
* Returns: negative on error
* 0 upon successful insert
*/
extern int hashmap_insert (hashmap_t map, const char *key,
const void *data, size_t len);
/*
* Get an iterator to the first entry.
*
* Returns: an negative value upon error.
*/
extern hashmap_iter hashmap_first (hashmap_t map);
/*
* Checks to see if the iterator is pointing at the "end" of the entries.
*
* Returns: 1 if it is the end
* 0 otherwise
*/
extern int hashmap_is_end (hashmap_t map, hashmap_iter iter);
/*
* Return a "pointer" to the first instance of the particular key. It can
* be tested against hashmap_is_end() to see if the key was not found.
*
* Returns: negative upon an error
* an "iterator" pointing at the first key
* an "end-iterator" if the key wasn't found
*/
extern hashmap_iter hashmap_find (hashmap_t map, const char *key);
/*
* Retrieve the key/data associated with a particular iterator.
* NOTE: These are pointers to the actual data, so don't mess around with them
* too much.
*
* Returns: the length of the data block upon success
* negative upon error
*/
extern ssize_t hashmap_return_entry (hashmap_t map, hashmap_iter iter,
char **key, void **data);
/*
* Get the first entry (assuming there is more than one) for a particular
* key. The data MUST be non-NULL.
*
* Returns: negative upon error
* zero if no entry is found
* length of data for the entry
*/
extern ssize_t hashmap_entry_by_key (hashmap_t map, const char *key,
void **data);
/*
* Searches for _any_ occurrances of "key" within the hashmap and returns the
* number of matching entries.
*
* Returns: negative upon an error
* zero if no key is found
* count found (positive value)
*/
extern ssize_t hashmap_search (hashmap_t map, const char *key);
/*
* Go through the hashmap and remove the particular key.
* NOTE: This will invalidate any iterators which have been created.
*
* Remove: negative upon error
* 0 if the key was not found
* positive count of entries deleted
*/
extern ssize_t hashmap_remove (hashmap_t map, const char *key);
/*
* Look up the value for a variable.
*/
extern char *lookup_variable (hashmap_t map, const char *varname);
#endif /* _HASHMAP_H */

51
src/html-error.c
View File

@ -40,17 +40,22 @@
int add_new_errorpage (struct config_s *conf, char *filepath,
unsigned int errornum)
{
char errornbuf[ERRORNUM_BUFSIZE];
char errornbuf[ERRORNUM_BUFSIZE], *k;
conf->errorpages = hashmap_create (ERRPAGES_BUCKETCOUNT);
if (!conf->errorpages)
conf->errorpages = htab_create (ERRPAGES_BUCKETCOUNT);
if (!conf->errorpages)
return (-1);
snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
if (hashmap_insert (conf->errorpages, errornbuf,
filepath, strlen (filepath) + 1) < 0)
k = safestrdup(errornbuf);
if (!k) return -1;
if (!htab_insert (conf->errorpages, k, HTV_P(filepath))) {
safefree(k);
return (-1);
}
return (0);
}
@ -60,10 +65,8 @@ int add_new_errorpage (struct config_s *conf, char *filepath,
*/
static char *get_html_file (unsigned int errornum)
{
hashmap_iter result_iter;
char errornbuf[ERRORNUM_BUFSIZE];
char *key;
char *val;
htab_value *hv;
assert (errornum >= 100 && errornum < 1000);
@ -72,16 +75,15 @@ static char *get_html_file (unsigned int errornum)
snprintf (errornbuf, ERRORNUM_BUFSIZE, "%u", errornum);
result_iter = hashmap_find (config->errorpages, errornbuf);
hv = htab_find (config->errorpages, errornbuf);
if (!hv) return (config->errorpage_undef);
return hv->p;
}
if (hashmap_is_end (config->errorpages, result_iter))
return (config->errorpage_undef);
if (hashmap_return_entry (config->errorpages, result_iter,
&key, (void **) &val) < 0)
return (config->errorpage_undef);
return (val);
static char *lookup_variable (struct htab *map, const char *varname) {
htab_value *v;
v = htab_find(map, varname);
return v ? v->p : 0;
}
static void varsubst_sendline(struct conn_s *connptr, regex_t *re, char *p) {
@ -203,14 +205,25 @@ int send_http_error_message (struct conn_s *connptr)
int
add_error_variable (struct conn_s *connptr, const char *key, const char *val)
{
char *k, *v;
if (!connptr->error_variables)
if (!
(connptr->error_variables =
hashmap_create (ERRVAR_BUCKETCOUNT)))
htab_create (ERRVAR_BUCKETCOUNT)))
return (-1);
return hashmap_insert (connptr->error_variables, key, val,
strlen (val) + 1);
k = safestrdup(key);
v = safestrdup(val);
if (!v || !k) goto oom;
if(htab_insert (connptr->error_variables, k, HTV_P(v)))
return 1;
oom:;
safefree(k);
safefree(v);
return -1;
}
#define ADD_VAR_RET(x, y) \

4
src/main.c
View File

@ -337,8 +337,8 @@ main (int argc, char **argv)
* HTTP/1.0 request. Also add the Content-Type header since it
* goes hand in hand with Content-Length. */
if (is_anonymous_enabled (config)) {
anonymous_insert (config, "Content-Length");
anonymous_insert (config, "Content-Type");
anonymous_insert (config, safestrdup("Content-Length"));
anonymous_insert (config, safestrdup("Content-Type"));
}
if (daemonized == TRUE) {

2
src/reqs.c
View File

@ -32,7 +32,7 @@
#include "buffer.h"
#include "conns.h"
#include "filter.h"
#include "hashmap.h"
#include "hsearch.h"
#include "orderedmap.h"
#include "heap.h"
#include "html-error.h"