diff options
| -rw-r--r-- | ChangeLog | 9 | ||||
| -rw-r--r-- | apache1x/mod_httpauth.c | 20 | ||||
| -rw-r--r-- | common/hash.c | 112 | ||||
| -rw-r--r-- | common/hash.h | 293 | ||||
| -rw-r--r-- | configure.in | 4 | ||||
| -rw-r--r-- | daemon/httpauthd.c | 54 | ||||
| -rw-r--r-- | daemon/ldap.c | 7 | ||||
| -rw-r--r-- | daemon/ntlm.c | 9 | ||||
| -rw-r--r-- | daemon/simple.c | 7 | ||||
| -rw-r--r-- | sample/httpauthd.conf | 12 |
10 files changed, 355 insertions, 172 deletions
@@ -0,0 +1,9 @@ +0.3 + - Changed 'method' to 'handler' throughout + - Fixed bug in hash.c + - Imported new hash table features + - Writes out pid file when requested with -p option + +0.2 + - Changed protocol to a more secure resilient protocol + diff --git a/apache1x/mod_httpauth.c b/apache1x/mod_httpauth.c index 39cdd8d..43dfa1b 100644 --- a/apache1x/mod_httpauth.c +++ b/apache1x/mod_httpauth.c @@ -19,7 +19,7 @@ typedef struct httpauth_context const char* socketname; int socket; int types; - const char* method; + const char* handler; const char* domain; pool* child_pool; } @@ -66,10 +66,10 @@ static const char* set_socket(cmd_parms* cmd, void* config, const char* val) return NULL; } -static const char* set_method(cmd_parms* cmd, void* config, const char* val) +static const char* set_handler(cmd_parms* cmd, void* config, const char* val) { httpauth_context_t* conf = (httpauth_context_t*)config; - conf->method = val; + conf->handler = val; return NULL; } @@ -108,8 +108,8 @@ static const command_rec httpauth_cmds[] = { { "HttpAuthSocket", set_socket, NULL, OR_AUTHCFG, TAKE1, "The socket that httpauthd is listening on" }, - { "HttpAuthMethod", set_method, NULL, OR_AUTHCFG, TAKE1, - "The method that httpauthd should use to authenticate" }, + { "HttpAuthHandler", set_handler, NULL, OR_AUTHCFG, TAKE1, + "The handler that httpauthd should use to authenticate" }, { "HttpAuthTypes", set_types, NULL, OR_AUTHCFG, ITERATE, "The types of authentiction allowed (Basic, Digest, NTLM ...)" }, { "HttpAuthDigestDomain", set_domain, NULL, OR_AUTHCFG, RAW_ARGS, @@ -518,16 +518,16 @@ int connect_httpauth(httpauth_context_t* ctx, request_rec* r) goto finally; } - /* Send our method */ - if(ctx->method) + /* Send our handler */ + if(ctx->handler) { - t = ap_pstrcat(r->pool, "SET Method ", ctx->method, "\n", NULL); + t = ap_pstrcat(r->pool, "SET Handler ", ctx->handler, "\n", NULL); if(write_data(ctx, r->server, t) == -1) goto finally; ap_log_rerror(APLOG_MARK, APLOG_DEBUG, r, - "httpauth: sent method to daemon: %s", t); + "httpauth: sent handler to daemon: %s", t); if(read_response(ctx, r, &code, NULL, NULL) == -1) goto finally; @@ -659,7 +659,7 @@ static int httpauth_authenticate(request_rec* r) ctx = (httpauth_context_t*)ap_get_module_config(r->per_dir_config, &httpauth_module); - if(!ctx->socketname || !ctx->method) + if(!ctx->socketname || !ctx->handler) return DECLINED; mainreq = r; diff --git a/common/hash.c b/common/hash.c index 6471803..9bbe8ac 100644 --- a/common/hash.c +++ b/common/hash.c @@ -89,38 +89,90 @@ struct hash_t unsigned int klen; #endif #ifdef HASH_CALLBACKS - hash_free_val_t f_free; - void* arg; + hash_table_calls_t calls; #endif }; #define INITIAL_MAX 15 /* tunable == 2^n - 1 */ +#ifdef HASH_CALLBACKS + +/* A copy of the memory call table we've been set to */ +static hash_memory_calls_t g_memory_calls_cpy; + +/* Pointer to above. This indicates when we actually are set */ +static hash_memory_calls_t* g_memory_calls = NULL; + +static void* int_malloc(size_t len) +{ + if(g_memory_calls) + return (g_memory_calls->f_alloc)(g_memory_calls->arg, len); + else + return malloc(len); +} + +static void* int_calloc(size_t len) +{ + void* p = int_malloc(len); + memset(p, 0, len); + return p; +} + +static void int_free(void* ptr) +{ + if(g_memory_calls) + { + /* We allow for gc type memory allocation with a null free */ + if(g_memory_calls->f_free) + (g_memory_calls->f_free)(g_memory_calls->arg, ptr); + } + else + free(ptr); +} + +void hash_set_memory_calls(hash_memory_calls_t* hmc) +{ + if(hmc == NULL) + { + g_memory_calls = NULL; + } + else + { + memcpy(&g_memory_calls_cpy, hmc, sizeof(g_memory_calls_cpy)); + g_memory_calls = &g_memory_calls_cpy; + } +} + +void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc) +{ + memcpy(&(ht->calls), htc, sizeof(ht->calls)); +} + +#else + +#define int_malloc malloc +#define int_free free + +#endif + + /* * Hash creation functions. */ static hash_entry_t** alloc_array(hash_t* ht, unsigned int max) { - return malloc(sizeof(*(ht->array)) * (max + 1)); + return int_malloc(sizeof(*(ht->array)) * (max + 1)); } -#ifdef HASH_CALLBACKS - #ifdef HASH_COPYKEYS -hash_t* hash_create(size_t klen, hash_free_val_t f_free, void* arg) - #else -hash_t* hash_create(hash_free_val_t f_free, void* arg) - #endif -#else - #ifdef HASH_COPYKEYS +#ifdef HASH_COPYKEYS hash_t* hash_create(size_t klen) - #else +#else hash_t* hash_create() - #endif #endif { - hash_t* ht = malloc(sizeof(hash_t)); + hash_t* ht = int_malloc(sizeof(hash_t)); if(ht) { ht->count = 0; @@ -129,13 +181,9 @@ hash_t* hash_create() #ifdef HASH_COPYKEYS ht->klen = klen; #endif -#ifdef HASH_CALLBACKS - ht->f_free = f_free; - ht->arg = arg; -#endif if(!ht->array) { - free(ht); + int_free(ht); return NULL; } } @@ -149,16 +197,16 @@ void hash_free(hash_t* ht) for(hi = hash_first(ht); hi; hi = hash_next(hi)) { #ifdef HASH_CALLBACKS - if(hi->ths->val && ht->f_free) - ht->f_free(ht->arg, (void*)hi->ths->val); + if(hi->ths->val && ht->calls.f_freeval) + (ht->calls.f_freeval)(ht->calls.arg, (void*)hi->ths->val); #endif - free(hi->ths); + int_free(hi->ths); } if(ht->array) - free(ht->array); + int_free(ht->array); - free(ht); + int_free(ht); } /* @@ -335,9 +383,9 @@ static hash_entry_t** find_entry(hash_t* ht, const void* key, size_t klen, const /* add a new entry for non-NULL val */ #ifdef HASH_COPYKEYS - he = malloc(sizeof(*he) + klen); + he = int_malloc(sizeof(*he) + klen); #else - he = malloc(sizeof(*he)); + he = int_malloc(sizeof(*he)); #endif if(he) @@ -395,8 +443,8 @@ int hash_set(hash_t* ht, const void* key, size_t klen, void* val) if(hep && *hep) { #ifdef HASH_CALLBACKS - if((*hep)->val && (*hep)->val != val && ht->f_free) - ht->f_free(ht->arg, (void*)((*hep)->val)); + if((*hep)->val && (*hep)->val != val && ht->calls.f_freeval) + (ht->calls.f_freeval)(ht->calls.arg, (void*)((*hep)->val)); #endif /* replace entry */ @@ -467,8 +515,8 @@ int hash_purge(hash_t* ht, time_t stamp) #endif #ifdef HASH_CALLBACKS - if(val && ht->f_free) - (ht->f_free)(ht->arg, val); + if(val && ht->calls.f_freeval) + (ht->calls.f_freeval)(ht->calls.arg, val); #endif r++; @@ -523,8 +571,8 @@ int hash_bump(hash_t* ht) #endif #ifdef HASH_CALLBACKS - if(val && ht->f_free) - (ht->f_free)(ht->arg, (void*)val); + if(val && ht->calls.f_freeval) + (ht->calls.f_freeval)(ht->calls.arg, (void*)val); #endif return 1; diff --git a/common/hash.h b/common/hash.h index 2b22b64..174c209 100644 --- a/common/hash.h +++ b/common/hash.h @@ -21,30 +21,43 @@ #ifndef __HASH_H__ #define __HASH_H__ +#ifdef __cplusplus +extern "C" { +#endif + /* + * OPTIONAL FEATURES + * * Features to define. You need to build both this file and - * the corresponding hash.c file with whatever options you set here + * the corresponding hash.c file with whatever options you set here. + * These affect the method signatures, so see the sections below + * for the actual options */ /* Keep timestamps for the entries */ -#define HASH_TIMESTAMP 1 +#define HASH_TIMESTAMP /* Keep key values internally */ -#define HASH_COPYKEYS 1 +#define HASH_COPYKEYS /* Hash callback functionality */ -#define HASH_CALLBACKS 1 +#define HASH_CALLBACKS +/* + * ARGUMENT DOCUMENTATION + * + * ht: The hashtable + * key: Pointer to the key value + * klen: The length of the key + * val: Pointer to the value + * hi: A hashtable iterator + * stamp: A unix timestamp + */ -#ifdef __cplusplus -extern "C" { -#endif -/** - * When passing a key to hash_set or hash_get, this value can be passed to - * indicate a string-valued key, and have hash compute the length automatically. +/* ---------------------------------------------------------------------------------- + * TYPES */ -#define HASH_KEY_STRING (-1) /* Abstract type for hash tables. */ typedef struct hash_t hash_t; @@ -52,146 +65,216 @@ typedef struct hash_t hash_t; /* Abstract type for scanning hash tables. */ typedef struct hash_index_t hash_index_t; -/* A callback during remove operations */ -#ifdef HASH_CALLBACKS - typedef void (*hash_free_val_t)(void* arg, void* val); -#endif -/* Create a hash table */ -#ifdef HASH_CALLBACKS - #ifdef HASH_COPYKEYS - hash_t* hash_create(size_t klen, hash_free_val_t f_free, void* arg); - #else - hash_t* hash_create(hash_free_val_t f_free, void* arg); - #endif -#else - #ifdef HASH_COPYKEYS - hash_t* hash_create(size_t klen); - #else - hash_t* hash_create(); - #endif -#endif /* HASH_CALLBACKS */ +/* ---------------------------------------------------------------------------------- + * COPY KEYS MODE + * + * Use these functions when you want specific length keys, with those + * keys stored in the hashtable itself. + */ + +#ifdef HASH_COPYKEYS +/* + * hash_create : Create a hash table + * - returns an allocated hashtable + */ +hash_t* hash_create(size_t klen); -/* To release all resources for a hash table */ +/* + * hash_free : Free a hash table + */ void hash_free(hash_t* ht); +/* + * hash_count: Number of values in hash table + * - returns the number of entries in hash table + */ +unsigned int hash_count(hash_t* ht); -/** - * Associate a value with a key in a hash table. - * - * ht The hash table - * key Pointer to the key - * klen Length of the key. Can be HASH_KEY_STRING to use the string length. - * val Value to associate with the key - * - * val must not be null +/* + * hash_get: Retrieves a value from the hash table + * - returns the value of the entry */ -#ifdef HASH_COPYKEYS - int hash_set(hash_t* ht, const void* key, void* val); -#else - int hash_set(hash_t* ht, const void* key, size_t klen, void* val); -#endif +void* hash_get(hash_t* ht, const void* key); +/* + * hash_set: Set a value in the hash table + * - returns 1 if the entry was added properly + */ +int hash_set(hash_t* ht, const void* key, void* val); -/** - * Remove a value and key form the hash table - * - * ht The hash table - * key Pointer to the key - * klen Length of the key. Can be HASH_KEY_STRING to use the string length +/* + * hash_rem: Remove a value from the hash table + * - returns the value of the removed entry */ -#ifdef HASH_COPYKEYS - void* hash_rem(hash_t* ht, const void* key); -#else - void* hash_rem(hash_t* ht, const void* key, size_t klen); -#endif +void* hash_rem(hash_t* ht, const void* key); +/* + * hash_first: Start enumerating through the hash table + * - returns a hash iterator + */ +hash_index_t* hash_first(hash_t* ht); -/** - * Look up the value associated with a key in a hash table. - * - * ht The hash table - * key Pointer to the key - * klen Length of the key. Can be APR_HASH_KEY_STRING to use the string length. +/* + * hash_next: Enumerate through hash table + * - returns the hash iterator or null when no more entries + */ +hash_index_t* hash_next(hash_index_t* hi); + +/* + * hash_this: While enumerating get current value + * - returns the value that the iterator currently points to + */ +void* hash_this(hash_index_t* hi, const void** key); + + + +/* ---------------------------------------------------------------------------------- + * VARIABLE KEYS MODE * - * Returns NULL if the key is not present. + * Use these functions if you want to use variable length keys or for some + * other reason don't want the keys stored in the hash table. */ -#ifdef HASH_COPYKEYS - void* hash_get(hash_t* ht, const void* key); + #else - void* hash_get(hash_t* ht, const void* key, size_t klen); -#endif +/* + * hash_create : Create a hash table + * - returns an allocated hashtable + */ +hash_t* hash_create(); -/** - * Start iterating over the entries in a hash table. - * - * ht The hash table - * - * There is no restriction on adding or deleting hash entries during - * an iteration (although the results may be unpredictable unless all you do - * is delete the current entry). Only one iteration can be in progress at once. +/* + * hash_free : Free a hash table */ -hash_index_t* hash_first(hash_t* ht); +void hash_free(hash_t* ht); +/* + * hash_count: Number of values in hash table + * - returns the number of entries in hash table + */ +unsigned int hash_count(hash_t* ht); -/** - * Continue iterating over the entries in a hash table. - * - * hi The iteration state - * - * Returns a pointer to the updated iteration state. - * NULL if there are no more entries. +/* + * hash_get: Retrieves a value from the hash table + * - returns the value of the entry + */ +void* hash_get(hash_t* ht, const void* key, size_t klen); + +/* + * hash_set: Set a value in the hash table + * - returns 1 if the entry was added properly + */ +int hash_set(hash_t* ht, const void* key, size_t klen, void* val); + +/* + * hash_rem: Remove a value from the hash table + * - returns the value of the removed entry + */ +void* hash_rem(hash_t* ht, const void* key, size_t klen); + +/* + * hash_first: Start enumerating through the hash table + * - returns a hash iterator + */ +hash_index_t* hash_first(hash_t* ht); + +/* + * hash_next: Enumerate through hash table + * - returns the hash iterator or null when no more entries */ hash_index_t* hash_next(hash_index_t* hi); +/* + * hash_this: While enumerating get current value + * - returns the value that the iterator currently points to + */ +void* hash_this(hash_index_t* hi, const void** key, size_t* klen); -/** - * Get the current entry's details from the iteration state. - * - * hi The iteration state - * key Return pointer for the pointer to the key. - * klen Return pointer for the key length. - * val Return pointer for the associated value. - * - * The return pointers should point to a variable that will be set to the - * corresponding data, or they may be NULL if the data isn't interesting. +/* + * This can be passed as 'klen' in any of the above functions to indicate + * a string-valued key, and have hash compute the length automatically. */ -#ifdef HASH_COPYKEYS - void* hash_this(hash_index_t* hi, const void** key); -#else - void* hash_this(hash_index_t* hi, const void** key, size_t* klen); +#define HASH_KEY_STRING (-1) + #endif -/** - * Purge entries before a certain timestamp + +/* ---------------------------------------------------------------------------------- + * TIMESTAMP FUNCTIONALITY + * + * Use these functions to include functionality which tracks the time + * each key was added or changed. This is useful for caches. Use these + * functions in addition to one of the above 'key' modes. */ + #ifdef HASH_TIMESTAMP +/* + * hash_purge: Purge entries before a certain timestamp + * - returns the number of entries purged + */ int hash_purge(hash_t* ht, time_t stamp); +/* + * hash_touch: Touch an entry to make it's timestamp current + */ #ifdef HASH_COPYKEYS void hash_touch(hash_t* ht, const void* key); #else void hash_touch(hash_t* ht, const void* key, size_t* klen); #endif -/* Bumps the oldest out */ +/* + * hash_bump: Bumps the oldest entry out + */ int hash_bump(hash_t* ht); #endif -/** - * Get the number of key/value pairs in the hash table. - * - * ht The hash table + +/* ---------------------------------------------------------------------------------- + * CALLBACK FUNCTIONALITY * - * The number of key/value pairs in the hash table. + * Use these functions to replace certain calls (malloc, free etc...) as + * well as to get callbacks when an item is discarded. */ -unsigned int hash_count(hash_t* ht); + +#ifdef HASH_CALLBACKS + +typedef void* (*hash_falloc)(void* arg, size_t len); +typedef void (*hash_ffree)(void* arg, void* ptr); + +typedef struct hash_memory_calls +{ + hash_falloc f_alloc; + hash_ffree f_free; + void* arg; +} +hash_memory_calls_t; + +/* Set the global memory calls */ +void hash_set_memory_calls(hash_memory_calls_t* hmc); + + +typedef void (*hash_ffreeval)(void* arg, void* val); + +typedef struct hash_table_calls +{ + hash_ffreeval f_freeval; + void* arg; +} +hash_table_calls_t; + +/* Set the per table free value call */ +void hash_set_table_calls(hash_t* ht, hash_table_calls_t* htc); + +#endif + + #ifdef __cplusplus diff --git a/configure.in b/configure.in index 5ba49a1..ecd2c47 100644 --- a/configure.in +++ b/configure.in @@ -36,8 +36,8 @@ dnl Nate Nielsen <nielsen@memberwebs.com> dnl dnl Process this file with autoconf to produce a configure script. -AC_INIT(httpauth, 0.2, nielsen@memberwebs.com) -AM_INIT_AUTOMAKE(httpauth, 0.2) +AC_INIT(httpauth, 0.3, nielsen@memberwebs.com) +AM_INIT_AUTOMAKE(httpauth, 0.3) LDFLAGS="$LDFLAGS -L/usr/local/lib" CFLAGS="$CFLAGS -I/usr/local/include -g -O0" diff --git a/daemon/httpauthd.c b/daemon/httpauthd.c index 00cb261..03a331a 100644 --- a/daemon/httpauthd.c +++ b/daemon/httpauthd.c @@ -122,6 +122,7 @@ pthread_mutexattr_t g_mutexattr; */ static int usage(); +static void writepid(const char* pid); static void* httpauth_thread(void* arg); static int httpauth_processor(int ifd, int ofd); static int httpauth_respond(int ofd, int scode, int ccode, const char* msg); @@ -137,6 +138,7 @@ static void on_quit(int signal); int main(int argc, char* argv[]) { const char* conf = DEFAULT_CONFIG; + const char* pidfile = NULL; httpauth_thread_t* threads = NULL; httpauth_loaded_t* h; int daemonize = 1; @@ -154,7 +156,7 @@ int main(int argc, char* argv[]) errx(1, "threading problem. can't create mutex"); /* Parse the arguments nicely */ - while((ch = getopt(argc, argv, "d:f:X")) != -1) + while((ch = getopt(argc, argv, "d:f:p:X")) != -1) { switch(ch) { @@ -176,6 +178,11 @@ int main(int argc, char* argv[]) conf = optarg; break; + /* Write out a pid file */ + case 'p': + pidfile = optarg; + break; + /* Process console input instead */ case 'X': g_console = 1; @@ -282,9 +289,12 @@ int main(int argc, char* argv[]) exit(1); } + ha_messagex(LOG_DEBUG, "running as a daemon"); g_daemonized = 1; } + writepid(pidfile); + /* Handle some signals */ signal(SIGPIPE, SIG_IGN); signal(SIGHUP, SIG_IGN); @@ -413,10 +423,28 @@ static void on_quit(int signal) static int usage() { - fprintf(stderr, "usage: httpauthd [-d level] [-X] [-f conffile]\n"); + fprintf(stderr, "usage: httpauthd [-d level] [-X] [-p pidfile] [-f conffile]\n"); return 2; } +static void writepid(const char* pidfile) +{ + FILE* f = fopen(pidfile, "w"); + if(f == NULL) + { + warnx("couldn't open pid file: %s", pidfile); + } + else + { + fprintf(f, "%d\n", (int)getpid()); + + if(ferror(f)) + warnx("couldn't write to pid file: %s", pidfile); + + fclose(f); + } +} + static void* httpauth_thread(void* arg) { httpauth_thread_t* thread = (httpauth_thread_t*)arg; @@ -868,8 +896,8 @@ static int httpauth_auth(int ofd, ha_request_t* req, ha_response_t* resp) if(!req->context) { - ha_messagex(LOG_ERR, "no auth method set"); - return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "No Auth Method Set"); + ha_messagex(LOG_ERR, "no auth handler set"); + return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "No Auth Handler Set"); } /* Clear out our response */ @@ -930,11 +958,11 @@ static int httpauth_set(int ofd, ha_request_t* req) req->digest_domain = value ? value : ""; } - else if(strcasecmp(name, "Method") == 0) + else if(strcasecmp(name, "Handler") == 0) { if(!value || !*value) { - ha_messagex(LOG_ERR, "no auth method specified in SET request."); + ha_messagex(LOG_ERR, "no auth handler specified in SET request."); return HA_BADREQ; } @@ -952,7 +980,7 @@ static int httpauth_set(int ofd, ha_request_t* req) if(value != NULL) { ha_messagex(LOG_ERR, "unknown authentication type: %s", req->args[0]); - return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Method"); + return httpauth_respond(ofd, HA_SERVER_BADREQ, 0, "Unknown Auth Handler"); } } @@ -1126,7 +1154,7 @@ static ha_context_t* config_addhandler(ha_buffer_t* buf, const char* alias, for(;;) { if(strcasecmp(alias, l->ctx.name) == 0) - errx(1, "duplicate method section for '%s'", alias); + errx(1, "duplicate handler section for '%s'", alias); if(!(l->next)) break; @@ -1137,7 +1165,7 @@ static ha_context_t* config_addhandler(ha_buffer_t* buf, const char* alias, l->next = loaded; } - ha_messagex(LOG_DEBUG, "configuration: method: %s (%s)", alias, handler->type); + ha_messagex(LOG_DEBUG, "configuration: handler: %s (%s)", alias, handler->type); return &(loaded->ctx); } @@ -1202,7 +1230,7 @@ static int config_parse(const char* file, ha_buffer_t* buf) name = ha_bufparseline(buf, 1); if(!name || name[strlen(name) - 1] != ']') - errx(1, "method section invalid (line %d)", line); + errx(1, "handler section invalid (line %d)", line); /* remove the bracket */ @@ -1223,7 +1251,7 @@ static int config_parse(const char* file, ha_buffer_t* buf) /* Validate the alias name */ if(!*t || strspn(t, VALID_ALIAS_CHARS) != strlen(t)) - errx(1, "invalid name for method: %s", t); + errx(1, "invalid name for handler: %s", t); } /* Rid of whitespace */ @@ -1241,7 +1269,7 @@ static int config_parse(const char* file, ha_buffer_t* buf) } if(handler == NULL) - errx(1, "unknown method type '%s' (line %d)", name, line); + errx(1, "unknown handler type '%s' (line %d)", name, line); /* If we had a last handler then add it to handlers */ ctx = config_addhandler(buf, t ? t : name, handler, &defaults); @@ -1404,7 +1432,7 @@ static int config_parse(const char* file, ha_buffer_t* buf) } if(!g_handlers) - ha_messagex(LOG_WARNING, "configuration: no methods found in configuration file"); + ha_messagex(LOG_WARNING, "configuration: no handlers found in configuration file"); return 0; } diff --git a/daemon/ldap.c b/daemon/ldap.c index a996305..37ef27a 100644 --- a/daemon/ldap.c +++ b/daemon/ldap.c @@ -1310,6 +1310,7 @@ int ldap_inithand(ha_context_t* context) else { ldap_context_t* ctx = (ldap_context_t*)(context->ctx_data); + hash_table_calls_t htc; ASSERT(ctx); @@ -1337,12 +1338,16 @@ int ldap_inithand(ha_context_t* context) } /* The cache for digest records and basic */ - if(!(ctx->cache = hash_create(MD5_LEN, free_hash_object, NULL))) + if(!(ctx->cache = hash_create(MD5_LEN))) { ha_messagex(LOG_CRIT, "out of memory"); return HA_CRITERROR; } + htc.f_freeval = free_hash_object; + htc.arg = NULL; + hash_set_table_calls(ctx->cache, &htc); + ASSERT(!ctx->pool); ASSERT(ctx->ldap_max > 0); diff --git a/daemon/ntlm.c b/daemon/ntlm.c index 85bee1d..37de9e8 100644 --- a/daemon/ntlm.c +++ b/daemon/ntlm.c @@ -581,6 +581,7 @@ int ntlm_init(ha_context_t* context) if(context) { ntlm_context_t* ctx = (ntlm_context_t*)(context->ctx_data); + hash_table_calls_t htc; ASSERT(ctx); @@ -604,13 +605,17 @@ int ntlm_init(ha_context_t* context) ASSERT(!ctx->established); /* Initialize our tables */ - if(!(ctx->pending = hash_create(NTLM_HASH_KEY_LEN, free_hash_object, NULL)) || - !(ctx->established = hash_create(NTLM_HASH_KEY_LEN, NULL, NULL))) + if(!(ctx->pending = hash_create(NTLM_HASH_KEY_LEN)) || + !(ctx->established = hash_create(NTLM_HASH_KEY_LEN))) { ha_messagex(LOG_CRIT, "out of memory"); return HA_CRITERROR; } + htc.f_freeval = free_hash_object; + htc.arg = NULL; + hash_set_table_calls(ctx->pending, &htc); + ha_messagex(LOG_INFO, "ntlm: initialized handler"); } diff --git a/daemon/simple.c b/daemon/simple.c index 8059051..52d565d 100644 --- a/daemon/simple.c +++ b/daemon/simple.c @@ -611,6 +611,7 @@ int simple_init(ha_context_t* context) else { simple_context_t* ctx = (simple_context_t*)(context->ctx_data); + hash_table_calls_t htc; int fd; ASSERT(ctx); @@ -644,12 +645,16 @@ int simple_init(ha_context_t* context) ASSERT(!ctx->cache); /* The cache for digest records and basic */ - if(!(ctx->cache = hash_create(MD5_LEN, free_hash_object, NULL))) + if(!(ctx->cache = hash_create(MD5_LEN))) { ha_messagex(LOG_CRIT, "out of memory"); return HA_CRITERROR; } + htc.f_freeval = free_hash_object; + htc.arg = NULL; + hash_set_table_calls(ctx->cache, &htc); + ha_messagex(LOG_INFO, "simple: initialized handler"); } diff --git a/sample/httpauthd.conf b/sample/httpauthd.conf index c536dcd..f9481d2 100644 --- a/sample/httpauthd.conf +++ b/sample/httpauthd.conf @@ -3,13 +3,13 @@ # and blank lines MaxThreads: 18 CacheTimeout: 300 -AuthTypes: Digest -# AuthTypes: Basic Digest -Socket: 0.0.0.0:8030 +# AuthTypes: Digest +AuthTypes: Basic Digest +Socket: 0.0.0.0 -DigestIgnoreNC: True +# DigestIgnoreNC: True -[Simple:Test] +[Simple:UDB] Realm: blah PasswordFile: /data/projects/httpauth/sample/passwd.file @@ -17,7 +17,7 @@ PasswordFile: /data/projects/httpauth/sample/passwd.file Realm: blah LDAPServers: authdev.ws.local LDAPDoBind: False -# LDAPDNMap: cn=%u,ou=test,dc=fam +LDAPDNMap: cn=%u,ou=test,dc=fam # DigestDomains: http://test.ws.local/ LDAPUser: cn=root,dc=fam LDAPPassword: ldaptest@@password |