static void
authBasicParse(authScheme * scheme, int n_configured, char *param_str)
{
if (scheme->scheme_data == NULL) {
assert(basicConfig == NULL);
/* this is the first param to be found */
scheme->scheme_data = xmalloc(sizeof(auth_basic_config));
memset(scheme->scheme_data, 0, sizeof(auth_basic_config));
basicConfig = scheme->scheme_data;
basicConfig->basicAuthRealm = xstrdup("Squid proxy-caching web server");
basicConfig->authenticateChildren = 5;
basicConfig->credentialsTTL = 2 * 60 * 60; /* two hours */
}
basicConfig = scheme->scheme_data;
if (strcasecmp(param_str, "program") == 0) {
if (basicConfig->authenticate)
wordlistDestroy(&basicConfig->authenticate);
parse_wordlist(&basicConfig->authenticate);
} else if (strcasecmp(param_str, "children") == 0) {
parse_int(&basicConfig->authenticateChildren);
} else if (strcasecmp(param_str, "concurrency") == 0) {
parse_int(&basicConfig->authenticateConcurrency);
} else if (strcasecmp(param_str, "realm") == 0) {
parse_eol(&basicConfig->basicAuthRealm);
} else if (strcasecmp(param_str, "credentialsttl") == 0) {
parse_time_t(&basicConfig->credentialsTTL);
} else if (strcasecmp(param_str, "casesensitive") == 0) {
parse_onoff(&basicConfig->casesensitive);
} else if (strcasecmp(param_str, "blankpassword") == 0) {
parse_onoff(&basicConfig->blankpassword);
} else {
debug(29, 0) ("unrecognised basic auth scheme parameter '%s'\n", param_str);
}
}
static void
authNegotiateParse(authScheme * scheme, int n_configured, char *param_str)
{
if (scheme->scheme_data == NULL) {
assert(negotiateConfig == NULL);
/* this is the first param to be found */
scheme->scheme_data = xmalloc(sizeof(auth_negotiate_config));
memset(scheme->scheme_data, 0, sizeof(auth_negotiate_config));
negotiateConfig = scheme->scheme_data;
negotiateConfig->authenticateChildren = 5;
negotiateConfig->keep_alive = 1;
}
negotiateConfig = scheme->scheme_data;
if (strcasecmp(param_str, "program") == 0) {
if (negotiateConfig->authenticate)
wordlistDestroy(&negotiateConfig->authenticate);
parse_wordlist(&negotiateConfig->authenticate);
} else if (strcasecmp(param_str, "children") == 0) {
parse_int(&negotiateConfig->authenticateChildren);
} else if (strcasecmp(param_str, "keep_alive") == 0) {
parse_onoff(&negotiateConfig->keep_alive);
} else {
debug(29, 0) ("unrecognised negotiate auth scheme parameter '%s'\n", param_str);
}
}
static void
free_external_acl_data(void *data)
{
external_acl_data *p = data;
wordlistDestroy(&p->arguments);
cbdataUnlock(p->def);
p->def = NULL;
}
/* free any allocated configuration details */
static void
authNegotiateFreeConfig(authScheme * scheme)
{
if (negotiateConfig == NULL)
return;
assert(negotiateConfig == scheme->scheme_data);
if (negotiateConfig->authenticate)
wordlistDestroy(&negotiateConfig->authenticate);
safe_free(negotiateConfig);
scheme->scheme_data = NULL;
}
void
dnsShutdown(void)
{
if (!dnsservers)
return;
helperShutdown(dnsservers);
wordlistDestroy(&dnsservers->cmdline);
if (!shutting_down)
return;
helperFree(dnsservers);
dnsservers = NULL;
}
/* free any allocated configuration details */
void
authBasicFreeConfig(authScheme * scheme)
{
if (basicConfig == NULL)
return;
assert(basicConfig == scheme->scheme_data);
if (basicConfig->authenticate)
wordlistDestroy(&basicConfig->authenticate);
if (basicConfig->basicAuthRealm)
safe_free(basicConfig->basicAuthRealm);
xfree(basicConfig);
basicConfig = NULL;
}
/* free any allocated configuration details */
void
authDigestFreeConfig(authScheme * scheme)
{
if (digestConfig == NULL)
return;
assert(digestConfig == scheme->scheme_data);
if (digestConfig->authenticate)
wordlistDestroy(&digestConfig->authenticate);
if (digestConfig->digestAuthRealm)
safe_free(digestConfig->digestAuthRealm);
xfree(digestConfig);
digestConfig = NULL;
}
void
netdbFreeMemory(void)
{
#if USE_ICMP
hashFreeItems(addr_table, netdbFreeNetdbEntry);
hashFreeMemory(addr_table);
addr_table = NULL;
hashFreeItems(host_table, netdbFreeNameEntry);
hashFreeMemory(host_table);
host_table = NULL;
wordlistDestroy(&peer_names);
peer_names = NULL;
#endif
}
static void
authDigestParse(authScheme * scheme, int n_configured, char *param_str)
{
if (scheme->scheme_data == NULL) {
assert(digestConfig == NULL);
/* this is the first param to be found */
scheme->scheme_data = xmalloc(sizeof(auth_digest_config));
memset(scheme->scheme_data, 0, sizeof(auth_digest_config));
digestConfig = scheme->scheme_data;
digestConfig->authenticateChildren = 5;
digestConfig->digestAuthRealm = xstrdup("Squid proxy-caching web server");
/* 5 minutes */
digestConfig->nonceGCInterval = 5 * 60;
/* 30 minutes */
digestConfig->noncemaxduration = 30 * 60;
/* 50 requests */
digestConfig->noncemaxuses = 50;
/* Not strict nonce count behaviour */
digestConfig->NonceStrictness = 0;
/* Verify nonce count */
digestConfig->CheckNonceCount = 1;
digestConfig->PostWorkaround = 0;
}
digestConfig = scheme->scheme_data;
if (strcasecmp(param_str, "program") == 0) {
if (digestConfig->authenticate)
wordlistDestroy(&digestConfig->authenticate);
parse_wordlist(&digestConfig->authenticate);
requirePathnameExists("authparam digest program", digestConfig->authenticate->key);
} else if (strcasecmp(param_str, "children") == 0) {
parse_int(&digestConfig->authenticateChildren);
} else if (strcasecmp(param_str, "realm") == 0) {
parse_eol(&digestConfig->digestAuthRealm);
} else if (strcasecmp(param_str, "nonce_garbage_interval") == 0) {
parse_time_t(&digestConfig->nonceGCInterval);
} else if (strcasecmp(param_str, "nonce_max_duration") == 0) {
parse_time_t(&digestConfig->noncemaxduration);
} else if (strcasecmp(param_str, "nonce_max_count") == 0) {
parse_int(&digestConfig->noncemaxuses);
} else if (strcasecmp(param_str, "nonce_strictness") == 0) {
parse_onoff(&digestConfig->NonceStrictness);
} else if (strcasecmp(param_str, "check_nonce_count") == 0) {
parse_onoff(&digestConfig->CheckNonceCount);
} else if (strcasecmp(param_str, "post_workaround") == 0) {
parse_onoff(&digestConfig->PostWorkaround);
} else {
debug(28, 0) ("unrecognised digest auth scheme parameter '%s'\n", param_str);
}
}
void
errorStateFree(ErrorState * err)
{
requestUnlink(err->request);
safe_free(err->redirect_url);
safe_free(err->url);
safe_free(err->dnsserver_msg);
safe_free(err->request_hdrs);
wordlistDestroy(&err->ftp.server_msg);
safe_free(err->ftp.request);
safe_free(err->ftp.reply);
if (err->auth_user_request)
authenticateAuthUserRequestUnlock(err->auth_user_request);
err->auth_user_request = NULL;
cbdataFree(err);
}
static void
free_refresh_check_helper(void *data)
{
refresh_check_helper *p = data;
while (p->format) {
refresh_check_format *f = p->format;
p->format = f->next;
cbdataFree(f);
}
wordlistDestroy(&p->cmdline);
if (p->helper) {
helperShutdown(p->helper);
helperFree(p->helper);
p->helper = NULL;
}
}
static void
free_external_acl(void *data)
{
external_acl *p = data;
safe_free(p->name);
while (p->format) {
external_acl_format *f = p->format;
p->format = f->next;
cbdataFree(f);
}
wordlistDestroy(&p->cmdline);
if (p->helper) {
helperShutdown(p->helper);
helperFree(p->helper);
p->helper = NULL;
}
while (p->lru_list.tail)
external_acl_cache_delete(p, p->lru_list.tail->data);
if (p->cache)
hashFreeMemory(p->cache);
}
