/* add client with fd to client list */
store_client *
storeClientListAdd(StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
store_client *sc;
assert(mem);
#if STORE_CLIENT_LIST_DEBUG
if (storeClientListSearch(mem, data) != NULL)
assert(1 == 0); /* XXX die! */
#endif
e->refcount++;
mem->nclients++;
sc = cbdataAlloc(store_client);
cbdataLock(data); /* locked while we point to it */
sc->callback_data = data;
sc->seen_offset = 0;
sc->copy_offset = 0;
sc->flags.disk_io_pending = 0;
sc->entry = e;
sc->type = storeClientType(e);
dlinkAdd(sc, &sc->node, &mem->clients);
#if DELAY_POOLS
sc->delay_id = 0;
#endif
return sc;
}
void
peerSelect(request_t * request,
StoreEntry * entry,
PSC * callback,
void *callback_data)
{
ps_state *psstate;
if (entry)
debug(44, 3) ("peerSelect: %s\n", storeUrl(entry));
else
debug(44, 3) ("peerSelect: %s\n", RequestMethods[request->method].str);
psstate = cbdataAlloc(ps_state);
psstate->request = requestLink(request);
psstate->entry = entry;
psstate->callback = callback;
psstate->callback_data = callback_data;
psstate->direct = DIRECT_UNKNOWN;
#if USE_CACHE_DIGESTS
request->hier.peer_select_start = current_time;
#endif
if (psstate->entry)
storeLockObject(psstate->entry);
cbdataLock(callback_data);
peerSelectFoo(psstate);
}
/* starts swap out sequence for the digest */
static void
storeDigestRewriteStart(void *datanotused)
{
request_flags flags;
char *url;
StoreEntry *e;
assert(store_digest);
/* prevent overlapping if rewrite schedule is too tight */
if (sd_state.rewrite_lock) {
debug(71, 1) ("storeDigestRewriteStart: overlap detected, consider increasing rewrite period\n");
return;
}
debug(71, 2) ("storeDigestRewriteStart: start rewrite #%d\n", sd_state.rewrite_count + 1);
/* make new store entry */
url = internalStoreUri("/squid-internal-periodic/", StoreDigestFileName);
flags = null_request_flags;
flags.cachable = 1;
e = storeCreateEntry(url, flags, METHOD_GET);
assert(e);
sd_state.rewrite_lock = cbdataAlloc(generic_cbdata);
sd_state.rewrite_lock->data = e;
debug(71, 3) ("storeDigestRewriteStart: url: %s key: %s\n", url, storeKeyText(e->hash.key));
e->mem_obj->request = requestLink(urlParse(METHOD_GET, url));
/* wait for rebuild (if any) to finish */
if (sd_state.rebuild_lock) {
debug(71, 2) ("storeDigestRewriteStart: waiting for rebuild to finish.\n");
return;
}
storeDigestRewriteResume();
}
int
errorMapStart(const errormap * map, request_t * client_req, HttpReply * reply, const char *aclname, ERRMAPCB * callback, void *callback_data)
{
char squid_error[100];
int len = 0;
const char *errorUrl;
ErrorMapState *state;
const char *tmp;
http_status status;
request_t *req;
HttpHeaderPos hdrpos;
HttpHeaderEntry *hdr;
if (!client_req || !reply)
return 0;
status = reply->sline.status;
tmp = httpHeaderGetStr(&reply->header, HDR_X_SQUID_ERROR);
squid_error[0] = '\0';
if (tmp) {
xstrncpy(squid_error, tmp, sizeof(squid_error));
len = strcspn(squid_error, " ");
}
squid_error[len] = '\0';
errorUrl = getErrorMap(map, status, squid_error, aclname);
if (!errorUrl)
return 0;
req = urlParse(urlMethodGetKnownByCode(METHOD_GET), (char *) errorUrl);
if (!req) {
debug(0, 0) ("errorMapStart: Invalid error URL '%s'\n", errorUrl);
return 0;
}
req->urlgroup = xstrdup("error");
state = cbdataAlloc(ErrorMapState);
state->req = requestLink(req);
state->e = storeCreateEntry(errorUrl, req->flags, req->method);
state->sc = storeClientRegister(state->e, state);
state->callback = callback;
state->callback_data = callback_data;
cbdataLock(callback_data);
hdrpos = HttpHeaderInitPos;
while ((hdr = httpHeaderGetEntry(&client_req->header, &hdrpos)) != NULL) {
if (CBIT_TEST(client_headers, hdr->id))
httpHeaderAddClone(&req->header, hdr);
}
hdrpos = HttpHeaderInitPos;
while ((hdr = httpHeaderGetEntry(&reply->header, &hdrpos)) != NULL) {
if (CBIT_TEST(server_headers, hdr->id))
httpHeaderAddClone(&req->header, hdr);
}
httpHeaderPutInt(&req->header, HDR_X_ERROR_STATUS, (int) reply->sline.status);
httpHeaderPutStr(&req->header, HDR_X_REQUEST_URI, urlCanonical(client_req));
fwdStart(-1, state->e, req);
storeClientRef(state->sc, state->e, 0, 0, SM_PAGE_SIZE, errorMapFetchHeaders, state);
return 1;
}
static void private_openAnIdleConn(char* server_ip,int server_port , struct in_addr outgoing , unsigned short tos, int ctimeout,FwdState *fwdState)
{
int fd = comm_openex(SOCK_STREAM,IPPROTO_TCP,outgoing,0,COMM_NONBLOCKING,tos,server_ip);
if (fd < 0)
{
debug(151, 4) ("private_openAnIdleConn: %s\n", xstrerror());
return;
}
// debug(151,3)("mod_server_persist_connections-->private_openAnIdleConn: openIdleConn fd == %d,timeout:%d\n",fd,ctimeout);
server *s = cbdataAlloc(server);
s->ip_addr = xstrdup(server_ip);
s->port = server_port;
s->proto = fwdState->request->protocol;
s->pconn_timeout=ctimeout;
commSetTimeout(fd,ctimeout,fwdConnectIdleTimeout,s);
/* if(ctimeout>36000)
commSetTcpKeepalive(fd, 3600, ctimeout/36000, ctimeout);
else
commSetTcpKeepalive(fd, 3600, 100, 360000);
*/
commSetTcpKeepalive(fd, 1000, 10000, 360000);
commConnectStart(fd, server_ip, server_port, private_openIdleConnDone, s);
}
RemovalPolicy *
createRemovalPolicy_lru(wordlist * args)
{
RemovalPolicy *policy;
LruPolicyData *lru_data;
/* no arguments expected or understood */
assert(!args);
/* Initialize */
if (!lru_node_pool)
lru_node_pool = memPoolCreate("LRU policy node", sizeof(LruNode));
/* Allocate the needed structures */
lru_data = xcalloc(1, sizeof(*lru_data));
policy = cbdataAlloc(RemovalPolicy);
/* Initialize the URL data */
lru_data->policy = policy;
/* Populate the policy structure */
policy->_type = "lru";
policy->_data = lru_data;
policy->Free = lru_free;
policy->Add = lru_add;
policy->Remove = lru_remove;
policy->Referenced = lru_referenced;
policy->Dereferenced = lru_referenced;
policy->WalkInit = lru_walkInit;
policy->PurgeInit = lru_purgeInit;
policy->Stats = lru_stats;
/* Increase policy usage count */
nr_lru_policies += 0;
return policy;
}
void
idnsPTRLookup(const struct in_addr addr, IDNSCB * callback, void *data)
{
idns_query *q;
const char *ip = inet_ntoa(addr);
q = cbdataAlloc(idns_query);
q->tcp_socket = -1;
q->id = idnsQueryID();
q->sz = rfc1035BuildPTRQuery(addr, q->buf, sizeof(q->buf), q->id, &q->query);
debug(78, 3) ("idnsPTRLookup: buf is %d bytes for %s, id = %#hx\n",
(int) q->sz, ip, q->id);
if (q->sz < 0) {
/* problem with query data -- query not sent */
callback(data, NULL, 0, "Internal error");
cbdataFree(q);
return;
}
if (idnsCachedLookup(q->query.name, callback, data)) {
cbdataFree(q);
return;
}
q->callback = callback;
q->callback_data = data;
cbdataLock(q->callback_data);
q->start_t = current_time;
idnsCacheQuery(q);
idnsSendQuery(q);
}
/* send the initial data to a digest authenticator module */
static void
authenticateDigestStart(auth_user_request_t * auth_user_request, RH * handler, void *data)
{
authenticateStateData *r = NULL;
char buf[8192];
digest_request_h *digest_request;
digest_user_h *digest_user;
assert(auth_user_request);
assert(handler);
assert(auth_user_request->auth_user->auth_type == AUTH_DIGEST);
assert(auth_user_request->auth_user->scheme_data != NULL);
assert(auth_user_request->scheme_data != NULL);
digest_request = auth_user_request->scheme_data;
digest_user = auth_user_request->auth_user->scheme_data;
debug(29, 9) ("authenticateStart: '\"%s\":\"%s\"'\n", digest_user->username,
digest_request->realm);
if (digestConfig->authenticate == NULL) {
handler(data, NULL);
return;
}
r = cbdataAlloc(authenticateStateData);
r->handler = handler;
cbdataLock(data);
r->data = data;
r->auth_user_request = auth_user_request;
authenticateAuthUserRequestLock(r->auth_user_request);
snprintf(buf, 8192, "\"%s\":\"%s\"\n", digest_user->username, digest_request->realm);
helperSubmit(digestauthenticators, buf, authenticateDigestHandleReply, r);
}
static void
asnCacheStart(int as)
{
LOCAL_ARRAY(char, asres, 4096);
StoreEntry *e;
request_t *req;
ASState *asState;
method_t *method_get;
method_get = urlMethodGetKnownByCode(METHOD_GET);
asState = cbdataAlloc(ASState);
debug(53, 3) ("asnCacheStart: AS %d\n", as);
snprintf(asres, 4096, "whois://%s/!gAS%d", Config.as_whois_server, as);
asState->as_number = as;
req = urlParse(method_get, asres);
assert(NULL != req);
asState->request = requestLink(req);
if ((e = storeGetPublic(asres, method_get)) == NULL) {
e = storeCreateEntry(asres, null_request_flags, method_get);
asState->sc = storeClientRegister(e, asState);
fwdStart(-1, e, asState->request);
} else {
storeLockObject(e);
asState->sc = storeClientRegister(e, asState);
}
asState->entry = e;
asState->seen = 0;
asState->offset = 0;
storeClientRef(asState->sc,
e,
asState->seen,
asState->offset,
SM_PAGE_SIZE,
asHandleReply,
asState);
}
void
netdbExchangeStart(void *data)
{
#if USE_ICMP
peer *p = data;
char *uri;
netdbExchangeState *ex;
method_t *method_get;
CBDATA_INIT_TYPE(netdbExchangeState);
ex = cbdataAlloc(netdbExchangeState);
cbdataLock(p);
ex->p = p;
uri = internalRemoteUri(p->host, p->http_port, "/squid-internal-dynamic/", "netdb");
debug(38, 3) ("netdbExchangeStart: Requesting '%s'\n", uri);
assert(NULL != uri);
method_get = urlMethodGetKnownByCode(METHOD_GET);
ex->r = urlParse(method_get, uri);
if (NULL == ex->r) {
debug(38, 1) ("netdbExchangeStart: Bad URI %s\n", uri);
return;
}
requestLink(ex->r);
assert(NULL != ex->r);
httpBuildVersion(&ex->r->http_ver, 1, 0);
ex->e = storeCreateEntry(uri, null_request_flags, method_get);
assert(NULL != ex->e);
ex->sc = storeClientRegister(ex->e, ex);
storeClientRef(ex->sc, ex->e, ex->seen, ex->used, SM_PAGE_SIZE,
netdbExchangeHandleReply, ex);
ex->r->flags.loopdetect = 1; /* cheat! -- force direct */
if (p->login)
xstrncpy(ex->r->login, p->login, MAX_LOGIN_SZ);
fwdStart(-1, ex->e, ex->r);
#endif
}
/* add client with fd to client list */
store_client *
storeClientRegister(StoreEntry * e, void *owner)
{
MemObject *mem = e->mem_obj;
store_client *sc;
assert(mem);
e->refcount++;
mem->nclients++;
sc = cbdataAlloc(store_client);
sc->callback_data = NULL;
sc->seen_offset = 0;
sc->copy_offset = 0;
sc->flags.disk_io_pending = 0;
sc->entry = e;
storeLockObject(sc->entry);
sc->type = storeClientType(e);
#if STORE_CLIENT_LIST_DEBUG
assert(!storeClientListSearch(mem, owner));
sc->owner = owner;
#endif
dlinkAdd(sc, &sc->node, &mem->clients);
#if DELAY_POOLS
sc->delay_id = 0;
#endif
return sc;
}
void
refreshCheckSubmit(StoreEntry * entry, REFRESHCHECK * callback, void *callback_data)
{
MemBuf buf;
const char *key;
refresh_check_helper *def = Config.Program.refresh_check;
refreshCheckState *state;
dlink_node *node;
refreshCheckState *oldstate = NULL;
if (!def) {
callback(callback_data, 0, NULL);
return;
}
key = makeRefreshCheckRequest(entry, def->format);
if (!key) {
callback(callback_data, 0, NULL);
return;
}
debug(84, 2) ("refreshCheckSubmit: for '%s'\n", key);
/* Check for a pending lookup to hook into */
for (node = def->queue.head; node; node = node->next) {
refreshCheckState *oldstatetmp = node->data;
if (entry == oldstatetmp->entry) {
oldstate = oldstatetmp;
break;
}
}
state = cbdataAlloc(refreshCheckState);
state->def = def;
cbdataLock(state->def);
state->entry = entry;
storeLockObject(entry);
state->callback = callback;
state->callback_data = callback_data;
cbdataLock(state->callback_data);
if (oldstate) {
/* Hook into pending lookup */
state->queue = oldstate->queue;
oldstate->queue = state;
} else {
/* No pending lookup found. Sumbit to helper */
/* Check for queue overload */
if (refreshCheckOverload(def)) {
debug(84, 1) ("refreshCheckSubmit: queue overload\n");
cbdataFree(state);
callback(callback_data, 0, "Overload");
return;
}
/* Send it off to the helper */
memBufDefInit(&buf);
memBufPrintf(&buf, "%s\n", key);
helperSubmit(def->helper, buf.buf, refreshCheckHandleReply, state);
dlinkAdd(state, &state->list, &def->queue);
memBufClean(&buf);
}
}
storeIOState *
storeDiskdCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback,
STIOCB * callback, void *callback_data)
{
sfileno f;
int x;
storeIOState *sio;
char *buf;
int shm_offset;
diskdinfo_t *diskdinfo = SD->fsdata;
diskdstate_t *diskdstate;
/*
* Fail on open() if there are too many requests queued.
*/
if (diskdinfo->away > diskdinfo->magic1) {
diskd_stats.open_fail_queue_len++;
return NULL;
}
/* Allocate a number */
f = storeDiskdDirMapBitAllocate(SD);
debug(79, 3) ("storeDiskdCreate: fileno %08X\n", f);
CBDATA_INIT_TYPE_FREECB(storeIOState, storeDiskdIOFreeEntry);
sio = cbdataAlloc(storeIOState);
sio->fsstate = diskdstate = memPoolAlloc(diskd_state_pool);
sio->swap_filen = f;
sio->swap_dirn = SD->index;
sio->mode = O_WRONLY | O_CREAT | O_TRUNC;
sio->callback = callback;
sio->callback_data = callback_data;
sio->e = e;
cbdataLock(callback_data);
diskdstate->flags.writing = 0;
diskdstate->flags.reading = 0;
diskdstate->flags.close_request = 0;
diskdstate->id = diskd_stats.sio_id++;
buf = storeDiskdShmGet(SD, &shm_offset);
xstrncpy(buf, storeDiskdDirFullPath(SD, f, NULL), SHMBUF_BLKSZ);
x = storeDiskdSend(_MQD_OPEN,
SD,
diskdstate->id,
sio,
strlen(buf) + 1,
sio->mode,
shm_offset);
if (x < 0) {
debug(79, 1) ("storeDiskdSend OPEN: %s\n", xstrerror());
storeDiskdShmPut(SD, shm_offset);
cbdataUnlock(sio->callback_data);
cbdataFree(sio);
return NULL;
}
storeDiskdDirReplAdd(SD, e);
diskd_stats.create.ops++;
return sio;
}
helper *
helperCreate(const char *name)
{
helper *hlp;
hlp = cbdataAlloc(helper);
hlp->id_name = name;
return hlp;
}
statefulhelper *
helperStatefulCreate(const char *name)
{
statefulhelper *hlp;
hlp = cbdataAlloc(statefulhelper);
hlp->id_name = name;
return hlp;
}
void
urnStart(request_t * r, StoreEntry * e)
{
LOCAL_ARRAY(char, urlres, 4096);
request_t *urlres_r = NULL;
const char *t;
char *host;
UrnState *urnState;
StoreEntry *urlres_e;
ErrorState *err;
debug(52, 3) ("urnStart: '%s'\n", storeUrl(e));
CBDATA_INIT_TYPE(UrnState);
urnState = cbdataAlloc(UrnState);
urnState->entry = e;
urnState->request = requestLink(r);
storeLockObject(urnState->entry);
if (strncasecmp(strBuf(r->urlpath), "menu.", 5) == 0) {
char *new_path = xstrdup(strBuf(r->urlpath) + 5);
urnState->flags.force_menu = 1;
stringReset(&r->urlpath, new_path);
xfree(new_path);
}
if ((t = strChr(r->urlpath, ':')) != NULL) {
strSet(r->urlpath, t, '\0');
host = xstrdup(strBuf(r->urlpath));
strSet(r->urlpath, t, ':');
} else {
host = xstrdup(strBuf(r->urlpath));
}
snprintf(urlres, 4096, "http://%s/uri-res/N2L?urn:%s", host, strBuf(r->urlpath));
safe_free(host);
urlres_r = urlParse(METHOD_GET, urlres);
if (urlres_r == NULL) {
debug(52, 3) ("urnStart: Bad uri-res URL %s\n", urlres);
err = errorCon(ERR_URN_RESOLVE, HTTP_NOT_FOUND);
err->url = xstrdup(urlres);
errorAppendEntry(e, err);
return;
}
httpHeaderPutStr(&urlres_r->header, HDR_ACCEPT, "text/plain");
if ((urlres_e = storeGetPublic(urlres, METHOD_GET)) == NULL) {
urlres_e = storeCreateEntry(urlres, urlres, null_request_flags, METHOD_GET);
urnState->sc = storeClientListAdd(urlres_e, urnState);
fwdStart(-1, urlres_e, urlres_r);
} else {
storeLockObject(urlres_e);
urnState->sc = storeClientListAdd(urlres_e, urnState);
}
urnState->urlres_e = urlres_e;
urnState->urlres_r = requestLink(urlres_r);
storeClientCopy(urnState->sc, urlres_e,
0,
0,
4096,
memAllocate(MEM_4K_BUF),
urnHandleReply,
urnState);
}
Logfile *
logfileOpen(const char *path, size_t bufsz, int fatal_flag)
{
Logfile *lf;
const char *patharg;
int ret;
debug(50, 1) ("logfileOpen: opening log %s\n", path);
CBDATA_INIT_TYPE(Logfile);
lf = cbdataAlloc(Logfile);
xstrncpy(lf->path, path, MAXPATHLEN);
patharg = path;
/* need to call the per-logfile-type code */
if (strncmp(path, "stdio:", 6) == 0)
{
patharg = path + 6;
ret = logfile_mod_stdio_open(lf, patharg, bufsz, fatal_flag);
}
else if (strncmp(path, "daemon:", 7) == 0)
{
patharg = path + 7;
ret = logfile_mod_daemon_open(lf, patharg, bufsz, fatal_flag);
}
else if (strncmp(path, "udp:", 4) == 0)
{
patharg = path + 4;
ret = logfile_mod_udp_open(lf, patharg, bufsz, fatal_flag);
#if HAVE_SYSLOG
}
else if (strncmp(path, "syslog:", 7) == 0)
{
patharg = path + 7;
ret = logfile_mod_syslog_open(lf, patharg, bufsz, fatal_flag);
#endif
}
else
{
ret = logfile_mod_stdio_open(lf, patharg, bufsz, fatal_flag);
}
if (!ret)
{
if (fatal_flag)
fatalf("logfileOpen: path %s: couldn't open!\n", path);
else
debug(50, 1) ("logfileOpen: path %s: couldn't open!\n", path);
lf->f_close(lf);
cbdataFree(lf);
return NULL;
}
assert(lf->data != NULL);
if (fatal_flag)
lf->flags.fatal = 1;
lf->sequence_number = 0;
return lf;
}
/* open for creating */
storeIOState *
storeAufsCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data)
{
char *path;
storeIOState *sio;
sfileno filn;
sdirno dirn;
#if !ASYNC_CREATE
int fd;
#endif
/* Allocate a number */
dirn = SD->index;
filn = storeAufsDirMapBitAllocate(SD);
path = storeAufsDirFullPath(SD, filn, NULL);
debug(79, 3) ("storeAufsCreate: fileno %08X\n", filn);
/*
* we should detect some 'too many files open' condition and return
* NULL here.
*/
#ifdef MAGIC2
if (aioQueueSize() > MAGIC2)
return NULL;
#endif
#if !ASYNC_CREATE
fd = file_open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY);
if (fd < 0) {
debug(79, 3) ("storeAufsCreate: got failure (%d)\n", errno);
return NULL;
}
#endif
CBDATA_INIT_TYPE_FREECB(storeIOState, storeAufsIOFreeEntry);
sio = cbdataAlloc(storeIOState);
sio->fsstate = memPoolAlloc(squidaio_state_pool);
((squidaiostate_t *) (sio->fsstate))->fd = -1;
((squidaiostate_t *) (sio->fsstate))->flags.opening = 1;
sio->swap_filen = filn;
sio->swap_dirn = dirn;
sio->mode = O_WRONLY | O_BINARY;
sio->callback = callback;
sio->callback_data = callback_data;
sio->e = (StoreEntry *) e;
cbdataLock(callback_data);
Opening_FD++;
statCounter.syscalls.disk.opens++;
#if ASYNC_CREATE
aioOpen(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644, storeAufsOpenDone, sio, INDEX_OF_SD(SD));
#else
storeAufsOpenDone(fd, sio, fd, 0);
#endif
/* now insert into the replacement policy */
storeAufsDirReplAdd(SD, e);
return sio;
}
void
redirectStart(clientHttpRequest * http, RH * handler, void *data)
{
ConnStateData *conn = http->conn;
redirectStateData *r = NULL;
const char *fqdn;
char *urlgroup = conn->port->urlgroup;
char buf[8192];
char claddr[20];
char myaddr[20];
assert(http);
assert(handler);
debug(61, 5) ("redirectStart: '%s'\n", http->uri);
if (Config.onoff.redirector_bypass && redirectors->stats.queue_size) {
/* Skip redirector if there is one request queued */
n_bypassed++;
handler(data, NULL);
return;
}
r = cbdataAlloc(redirectStateData);
r->orig_url = xstrdup(http->uri);
r->client_addr = conn->log_addr;
r->client_ident = NULL;
if (http->request->auth_user_request)
r->client_ident = authenticateUserRequestUsername(http->request->auth_user_request);
else if (http->request->extacl_user) {
r->client_ident = http->request->extacl_user;
}
if (!r->client_ident && conn->rfc931[0])
r->client_ident = conn->rfc931;
#if USE_SSL
if (!r->client_ident)
r->client_ident = sslGetUserEmail(fd_table[conn->fd].ssl);
#endif
if (!r->client_ident)
r->client_ident = dash_str;
r->method_s = http->request->method->string;
r->handler = handler;
r->data = data;
cbdataLock(r->data);
if ((fqdn = fqdncache_gethostbyaddr(r->client_addr, 0)) == NULL)
fqdn = dash_str;
xstrncpy(claddr, inet_ntoa(r->client_addr), 20);
xstrncpy(myaddr, inet_ntoa(http->request->my_addr), 20);
snprintf(buf, 8191, "%s %s/%s %s %s %s myip=%s myport=%d",
r->orig_url,
claddr,
fqdn,
r->client_ident[0] ? rfc1738_escape(r->client_ident) : dash_str,
r->method_s,
urlgroup ? urlgroup : "-",
myaddr,
http->request->my_port);
debug(61, 6) ("redirectStart: sending '%s' to the helper\n", buf);
strcat(buf, "\n");
helperSubmit(redirectors, buf, redirectHandleReply, r);
}
void
idnsALookup(const char *name, IDNSCB * callback, void *data)
{
unsigned int i;
int nd = 0;
idns_query *q;
if (idnsCachedLookup(name, callback, data))
return;
q = cbdataAlloc(idns_query);
q->tcp_socket = -1;
q->id = idnsQueryID();
for (i = 0; i < strlen(name); i++)
{
if (name[i] == '.')
{
nd++;
}
}
if (Config.onoff.res_defnames && npc > 0 && name[strlen(name) - 1] != '.')
{
q->do_searchpath = 1;
}
else
{
q->do_searchpath = 0;
}
strcpy(q->orig, name);
strcpy(q->name, q->orig);
if (q->do_searchpath && nd < ndots)
{
q->domain = 0;
strcat(q->name, ".");
strcat(q->name, searchpath[q->domain].domain);
debug(78, 3) ("idnsALookup: searchpath used for %s\n",
q->name);
}
q->sz = rfc1035BuildAQuery(q->name, q->buf, sizeof(q->buf), q->id,
&q->query);
if (q->sz < 0)
{
/* problem with query data -- query not sent */
callback(data, NULL, 0, "Internal error");
cbdataFree(q);
return;
}
debug(78, 3) ("idnsALookup: buf is %d bytes for %s, id = %#hx\n",
(int) q->sz, q->name, q->id);
q->callback = callback;
q->callback_data = data;
cbdataLock(q->callback_data);
q->start_t = current_time;
idnsCacheQuery(q);
idnsSendQuery(q);
}
/*
* Function: errorCon
*
* Abstract: This function creates a ErrorState object.
*/
ErrorState *
errorCon(err_type type, http_status status)
{
ErrorState *err;
err = cbdataAlloc(ErrorState);
err->page_id = type; /* has to be reset manually if needed */
err->type = type;
err->http_status = status;
return err;
}
/* send the initial data to a basic authenticator module */
static void
authenticateBasicStart(auth_user_request_t * auth_user_request, RH * handler, void *data)
{
authenticateStateData *r = NULL;
char buf[8192];
char user[1024], pass[1024];
basic_data *basic_auth;
assert(auth_user_request);
assert(handler);
assert(auth_user_request->auth_user->auth_type == AUTH_BASIC);
assert(auth_user_request->auth_user->scheme_data != NULL);
basic_auth = auth_user_request->auth_user->scheme_data;
debug(29, 9) ("authenticateStart: '%s:%s'\n", basic_auth->username,
basic_auth->passwd);
if (basicConfig->authenticate == NULL) {
handler(data, NULL);
return;
}
/* check to see if the auth_user already has a request outstanding */
if (basic_auth->flags.credentials_ok == 2) {
/* there is a request with the same credentials already being verified */
auth_basic_queue_node *node;
node = xmalloc(sizeof(auth_basic_queue_node));
assert(node);
/* save the details */
node->next = basic_auth->auth_queue;
basic_auth->auth_queue = node;
node->handler = handler;
node->data = data;
cbdataLock(data);
return;
} else {
r = cbdataAlloc(authenticateStateData);
r->handler = handler;
cbdataLock(data);
r->data = data;
r->auth_user_request = auth_user_request;
authenticateAuthUserRequestLock(r->auth_user_request);
/* mark the user as haveing verification in progress */
basic_auth->flags.credentials_ok = 2;
if (basicConfig->utf8) {
latin1_to_utf8(user, sizeof(user), basic_auth->username);
latin1_to_utf8(pass, sizeof(pass), basic_auth->passwd);
xstrncpy(user, rfc1738_escape(user), sizeof(user));
xstrncpy(pass, rfc1738_escape(pass), sizeof(pass));
} else {
xstrncpy(user, rfc1738_escape(basic_auth->username), sizeof(user));
xstrncpy(pass, rfc1738_escape(basic_auth->passwd), sizeof(pass));
}
snprintf(buf, sizeof(buf), "%s %s\n", user, pass);
helperSubmit(basicauthenticators, buf, authenticateBasicHandleReply, r);
}
}
/* allocate new peer digest, call Init, and lock everything */
PeerDigest *
peerDigestCreate(peer * p)
{
PeerDigest *pd;
assert(p);
CBDATA_INIT_TYPE(PeerDigest);
pd = cbdataAlloc(PeerDigest);
peerDigestInit(pd, p);
cbdataLock(pd->peer); /* we will use the peer */
return pd;
}
static void
authenticateAuthUserRequestSetIp(auth_user_request_t * auth_user_request, struct in_addr ipaddr, request_t * request)
{
auth_user_ip_t *ipdata, *next;
auth_user_t *auth_user;
char *ip1;
int found = 0;
CBDATA_INIT_TYPE(auth_user_ip_t);
if (!auth_user_request->auth_user)
return;
auth_user = auth_user_request->auth_user;
next = (auth_user_ip_t *) auth_user->ip_list.head;
/*
* we walk the entire list to prevent the first item in the list
* preventing old entries being flushed and locking a user out after
* a timeout+reconfigure
*/
while ((ipdata = next) != NULL)
{
next = (auth_user_ip_t *) ipdata->node.next;
/* walk the ip list */
if (ipdata->ipaddr.s_addr == ipaddr.s_addr)
{
/* This ip has already been seen. */
found = 1;
/* update IP ttl */
ipdata->ip_expiretime = squid_curtime;
}
else if (ipdata->ip_expiretime + Config.authenticateIpTTL < squid_curtime)
{
/* This IP has expired - remove from the seen list */
authenticateAuthUserRemoveIpEntry(auth_user, ipdata);
}
}
authenticateAuthUserRequestLinkIp(auth_user_request, ipaddr, request);
if (found)
return;
/* This ip is not in the seen list */
ipdata = cbdataAlloc(auth_user_ip_t);
ipdata->ip_expiretime = squid_curtime;
ipdata->ipaddr = ipaddr;
dlinkAddTail(ipdata, &ipdata->node, &auth_user->ip_list);
auth_user->ipcount++;
ip1 = xstrdup(inet_ntoa(ipaddr));
debug(29, 2) ("authenticateAuthUserRequestSetIp: user '%s' has been seen at a new IP address (%s)\n", authenticateUserUsername(auth_user), ip1);
safe_free(ip1);
}
/*
* Function: errorCon
*
* Abstract: This function creates a ErrorState object.
*/
ErrorState *
errorCon(err_type type, http_status status, request_t * request)
{
ErrorState *err;
err = cbdataAlloc(ErrorState);
err->page_id = type; /* has to be reset manually if needed */
err->type = type;
err->http_status = status;
if (request != NULL) {
err->request = requestLink(request);
err->src_addr = request->client_addr;
}
return err;
}
static void
icapProcessHttpReplyHeader(IcapStateData * icap, const char *buf, int size)
{
if (NULL == icap->httpState) {
icap->httpState = cbdataAlloc(HttpStateData);
icap->httpState->request = requestLink(icap->request);
icap->httpState->orig_request = requestLink(icap->request);
icap->httpState->entry = icap->respmod.entry;
storeLockObject(icap->httpState->entry); /* lock it */
}
httpProcessReplyHeader(icap->httpState, buf, size);
if (2 == icap->httpState->reply_hdr_state)
EBIT_CLR(icap->httpState->entry->flags, ENTRY_FWD_HDR_WAIT);
}
/*
* start a TCP connection to the peer host on port 113
*/
void
identStart(struct sockaddr_in *me, struct sockaddr_in *my_peer, IDCB * callback, void *data)
{
IdentStateData *state;
int fd;
char key1[IDENT_KEY_SZ];
char key2[IDENT_KEY_SZ];
char key[IDENT_KEY_SZ];
snprintf(key1, IDENT_KEY_SZ, "%s:%d",
inet_ntoa(me->sin_addr),
ntohs(me->sin_port));
snprintf(key2, IDENT_KEY_SZ, "%s:%d",
inet_ntoa(my_peer->sin_addr),
ntohs(my_peer->sin_port));
snprintf(key, IDENT_KEY_SZ, "%s,%s", key1, key2);
if ((state = hash_lookup(ident_hash, key)) != NULL)
{
identClientAdd(state, callback, data);
return;
}
fd = comm_open(SOCK_STREAM,
IPPROTO_TCP,
me->sin_addr,
0,
COMM_NONBLOCKING,
"ident");
if (fd == COMM_ERROR)
{
/* Failed to get a local socket */
callback(NULL, data);
return;
}
CBDATA_INIT_TYPE(IdentStateData);
state = cbdataAlloc(IdentStateData);
state->hash.key = xstrdup(key);
state->fd = fd;
state->me = *me;
state->my_peer = *my_peer;
identClientAdd(state, callback, data);
hash_join(ident_hash, &state->hash);
comm_add_close_handler(fd,
identClose,
state);
commSetTimeout(fd, Config.Timeout.ident, identTimeout, state);
commConnectStart(fd,
inet_ntoa(state->my_peer.sin_addr),
IDENT_PORT,
identConnectDone,
state);
}
void
netdbPingSite(const char *hostname)
{
#if USE_ICMP
netdbEntry *n;
generic_cbdata *h;
if ((n = netdbLookupHost(hostname)) != NULL)
if (n->next_ping_time > squid_curtime)
return;
h = cbdataAlloc(generic_cbdata);
h->data = xstrdup(hostname);
ipcache_nbgethostbyname(hostname, netdbSendPing, h);
#endif
}
/* open for reading */
storeIOState *
storeAufsOpen(SwapDir * SD, StoreEntry * e, STFNCB * file_callback,
STIOCB * callback, void *callback_data)
{
sfileno f = e->swap_filen;
char *path = storeAufsDirFullPath(SD, f, NULL);
storeIOState *sio;
#if !ASYNC_OPEN
int fd;
#endif
debug(79, 3) ("storeAufsOpen: fileno %08X\n", f);
/*
* we should detect some 'too many files open' condition and return
* NULL here.
*/
#ifdef MAGIC2
#ifndef CC_FRAMEWORK
if (aioQueueSize() > MAGIC2)
return NULL;
#endif
#endif
#if !ASYNC_OPEN
fd = file_open(path, O_RDONLY | O_BINARY | O_NOATIME);
if (fd < 0) {
debug(79, 3) ("storeAufsOpen: got failure (%d)\n", errno);
return NULL;
}
#endif
CBDATA_INIT_TYPE_FREECB(storeIOState, storeAufsIOFreeEntry);
sio = cbdataAlloc(storeIOState);
sio->fsstate = memPoolAlloc(squidaio_state_pool);
((squidaiostate_t *) (sio->fsstate))->fd = -1;
((squidaiostate_t *) (sio->fsstate))->flags.opening = 1;
sio->swap_filen = f;
sio->swap_dirn = SD->index;
sio->mode = O_RDONLY | O_BINARY;
sio->callback = callback;
sio->callback_data = callback_data;
sio->e = e;
cbdataLock(callback_data);
Opening_FD++;
statCounter.syscalls.disk.opens++;
#if ASYNC_OPEN
aioOpen(path, O_RDONLY | O_BINARY | O_NOATIME, 0644, storeAufsOpenDone, sio, INDEX_OF_SD(SD));
#else
storeAufsOpenDone(fd, sio, fd, 0);
#endif
return sio;
}
static RemovalPolicyWalker *
lru_walkInit(RemovalPolicy * policy)
{
LruPolicyData *lru = policy->_data;
RemovalPolicyWalker *walker;
LruWalkData *lru_walk;
lru->nwalkers += 1;
walker = cbdataAlloc(RemovalPolicyWalker);
lru_walk = xcalloc(1, sizeof(*lru_walk));
walker->_policy = policy;
walker->_data = lru_walk;
walker->Next = lru_walkNext;
walker->Done = lru_walkDone;
lru_walk->current = (LruNode *) lru->list.head;
return walker;
}
