/*
* destroy_auth_request - stop an auth request completely
*/
void destroy_auth_request(struct AuthRequest* auth, int send_reports)
{
struct AuthRequest** authList;
if (IsDoingAuth(auth)) {
authList = &AuthPollList;
if (-1 < auth->fd) {
close(auth->fd);
auth->fd = -1;
socket_del(&auth->socket);
}
if (send_reports && IsUserPort(auth->client))
sendheader(auth->client, REPORT_FAIL_ID);
} else
authList = &AuthIncompleteList;
if (IsDNSPending(auth)) {
delete_resolver_queries(auth);
if (send_reports && IsUserPort(auth->client))
sendheader(auth->client, REPORT_FAIL_DNS);
}
if (send_reports) {
log_write(LS_RESOLVER, L_INFO, 0, "DNS/AUTH timeout %s",
get_client_name(auth->client, HIDE_IP));
release_auth_client(auth->client);
}
unlink_auth_request(auth, authList);
free_auth_request(auth);
}
/* Called to close a given filedescriptor */
void
comm_close(int fd)
{
fde_t *F = &fd_table[fd];
s_assert(F->flags.open);
/* All disk fd's MUST go through file_close() ! */
s_assert(F->type != FD_FILE);
if(F->type == FD_FILE)
{
s_assert(F->read_handler == NULL);
s_assert(F->write_handler == NULL);
}
comm_setselect(F->fd, FDLIST_NONE, COMM_SELECT_WRITE | COMM_SELECT_READ, NULL, NULL, 0);
comm_setflush(F->fd, 0, NULL, NULL);
if (F->dns_query != NULL)
{
delete_resolver_queries(F->dns_query);
MyFree(F->dns_query);
F->dns_query = NULL;
}
F->flags.open = 0;
fdlist_update_biggest(fd, 0);
number_fd--;
memset(F, '\0', sizeof(fde_t));
F->timeout = 0;
/* Unlike squid, we're actually closing the FD here! -- adrian */
close(fd);
}
/** Free a struct ConfItem and any resources it owns.
* @param aconf Item to free.
*/
void free_conf(struct ConfItem *aconf)
{
Debug((DEBUG_DEBUG, "free_conf: %s %s %d",
aconf->host ? aconf->host : "*",
aconf->name ? aconf->name : "*",
aconf->address.port));
if (aconf->dns_pending)
delete_resolver_queries(aconf);
MyFree(aconf->username);
MyFree(aconf->host);
MyFree(aconf->origin_name);
if (aconf->passwd)
memset(aconf->passwd, 0, strlen(aconf->passwd));
MyFree(aconf->passwd);
MyFree(aconf->sslfp);
MyFree(aconf->sslciphers);
MyFree(aconf->name);
MyFree(aconf->hub_limit);
MyFree(aconf->countrymask);
MyFree(aconf->continentmask);
MyFree(aconf->redirserver);
MyFree(aconf->autojoinchan);
MyFree(aconf->autojoinnotice);
MyFree(aconf);
--GlobalConfCount;
}
static void auth_kill_client(struct AuthRequest* auth)
{
assert(0 != auth);
unlink_auth_request(auth, (IsDoingAuth(auth)) ? &AuthPollList : &AuthIncompleteList);
if (IsDNSPending(auth))
delete_resolver_queries(auth);
IPcheck_disconnect(auth->client);
Count_unknowndisconnects(UserStats);
cli_auth(auth->client) = 0;
free_client(auth->client);
free_auth_request(auth);
}
/* Called to close a given filedescriptor */
void
fd_close(fde_t *F)
{
unsigned int hashv = hash_fd(F->fd);
if (F == fd_next_in_loop)
fd_next_in_loop = F->hnext;
if (F->flags.is_socket)
comm_setselect(F, COMM_SELECT_WRITE | COMM_SELECT_READ, NULL, NULL, 0);
delete_resolver_queries(F);
#ifdef HAVE_LIBCRYPTO
if (F->ssl)
SSL_free(F->ssl);
#endif
if (fd_hash[hashv] == F)
fd_hash[hashv] = F->hnext;
else
{
fde_t *prev;
/* let it core if not found */
for (prev = fd_hash[hashv]; prev->hnext != F; prev = prev->hnext)
;
prev->hnext = F->hnext;
}
/* Unlike squid, we're actually closing the FD here! -- adrian */
close(F->fd);
number_fd--;
memset(F, 0, sizeof(fde_t));
}
