static void
authenticateAuthUserRequestFree(auth_user_request_t * auth_user_request)
{
dlink_node *link;
debug(29, 5) ("authenticateAuthUserRequestFree: freeing request %p\n", auth_user_request);
if (!auth_user_request)
return;
assert(auth_user_request->references == 0);
if (auth_user_request->auth_user) {
if (auth_user_request->scheme_data != NULL) {
/* we MUST know the module */
assert((auth_user_request->auth_user->auth_module > 0));
/* and the module MUST support requestFree if it has created scheme data */
assert(authscheme_list[auth_user_request->auth_user->auth_module - 1].requestFree != NULL);
authscheme_list[auth_user_request->auth_user->auth_module - 1].requestFree(auth_user_request);
}
/* unlink from the auth_user struct */
link = auth_user_request->auth_user->requests.head;
while (link && (link->data != auth_user_request))
link = link->next;
assert(link != NULL);
dlinkDelete(link, &auth_user_request->auth_user->requests);
dlinkNodeDelete(link);
/* unlock the request structure's lock */
authenticateAuthUserUnlock(auth_user_request->auth_user);
auth_user_request->auth_user = NULL;
} else
assert(auth_user_request->scheme_data == NULL);
if (auth_user_request->message)
xfree(auth_user_request->message);
memPoolFree(auth_user_request_pool, auth_user_request);
}
static void
authDigestNonceUserUnlink(digest_nonce_h * nonce)
{
digest_user_h *digest_user;
dlink_node *link, *tmplink;
if (!nonce)
return;
if (!nonce->auth_user)
return;
digest_user = nonce->auth_user->scheme_data;
/* unlink from the user list. Yes we're crossing structures but this is the only
* time this code is needed
*/
link = digest_user->nonces.head;
while (link) {
tmplink = link;
link = link->next;
if (tmplink->data == nonce) {
dlinkDelete(tmplink, &digest_user->nonces);
authDigestNonceUnlink(tmplink->data);
dlinkNodeDelete(tmplink);
link = NULL;
}
}
/* this reference to auth_user was not locked because freeeing the auth_user frees
* the nonce too.
*/
nonce->auth_user = NULL;
}
void
authenticateFreeProxyAuthUser(void *data)
{
auth_user_t *u = data;
auth_user_request_t *auth_user_request;
dlink_node *link, *tmplink;
assert(data != NULL);
debug(29, 5) ("authenticateFreeProxyAuthUser: Freeing auth_user '%p' with refcount '%ld'.\n", u, (long int) u->references);
assert(u->references == 0);
/* were they linked in by username ? */
if (u->usernamehash)
{
assert(u->usernamehash->auth_user == u);
debug(29, 5) ("authenticateFreeProxyAuthUser: removing usernamehash entry '%p'\n", u->usernamehash);
hash_remove_link(proxy_auth_username_cache,
(hash_link *) u->usernamehash);
/* don't free the key as we use the same user string as the auth_user
* structure */
memFree(u->usernamehash, MEM_AUTH_USER_HASH);
}
/* remove any outstanding requests */
link = u->requests.head;
while (link)
{
debug(29, 5) ("authenticateFreeProxyAuthUser: removing request entry '%p'\n", link->data);
auth_user_request = link->data;
tmplink = link;
link = link->next;
dlinkDelete(tmplink, &u->requests);
dlinkNodeDelete(tmplink);
authenticateAuthUserRequestFree(auth_user_request);
}
/* free cached acl results */
aclCacheMatchFlush(&u->proxy_match_cache);
/* free seen ip address's */
authenticateAuthUserClearIp(u);
if (u->scheme_data && u->auth_module > 0)
authscheme_list[u->auth_module - 1].FreeUser(u);
/* prevent accidental reuse */
u->auth_type = AUTH_UNKNOWN;
memFree(u, MEM_AUTH_USER_T);
}
static void
authenticateDigestUserFree(auth_user_t * auth_user)
{
digest_user_h *digest_user = auth_user->scheme_data;
dlink_node *link, *tmplink;
debug(29, 9) ("authenticateDigestFreeUser: Clearing Digest scheme data\n");
if (!digest_user)
return;
safe_free(digest_user->username);
link = digest_user->nonces.head;
while (link) {
tmplink = link;
link = link->next;
dlinkDelete(tmplink, &digest_user->nonces);
authDigestNoncePurge(tmplink->data);
authDigestNonceUnlink(tmplink->data);
dlinkNodeDelete(tmplink);
}
memPoolFree(digest_user_pool, auth_user->scheme_data);
auth_user->scheme_data = NULL;
}
