static void
mimeLoadIconFile(const char *icon)
{
int fd;
int n;
request_flags flags;
struct stat sb;
StoreEntry *e;
LOCAL_ARRAY(char, path, MAXPATHLEN);
LOCAL_ARRAY(char, url, MAX_URL);
char *buf;
const char *type = mimeGetContentType(icon);
HttpReply *reply;
if (type == NULL)
fatal("Unknown icon format while reading mime.conf\n");
buf = internalLocalUri("/squid-internal-static/icons/", icon);
xstrncpy(url, buf, MAX_URL);
if (storeGetPublic(url, METHOD_GET))
return;
snprintf(path, MAXPATHLEN, "%s/%s", Config.icons.directory, icon);
fd = file_open(path, O_RDONLY);
if (fd < 0) {
debug(25, 0) ("mimeLoadIconFile: %s: %s\n", path, xstrerror());
return;
}
if (fstat(fd, &sb) < 0) {
debug(50, 0) ("mimeLoadIconFile: FD %d: fstat: %s\n", fd, xstrerror());
return;
}
flags = null_request_flags;
flags.cachable = 1;
e = storeCreateEntry(url,
url,
flags,
METHOD_GET);
assert(e != NULL);
storeSetPublicKey(e);
storeBuffer(e);
e->mem_obj->request = requestLink(urlParse(METHOD_GET, url));
httpReplyReset(reply = e->mem_obj->reply);
httpReplySetHeaders(reply, 1.0, HTTP_OK, NULL,
type, (int) sb.st_size, sb.st_mtime, -1);
reply->cache_control = httpHdrCcCreate();
httpHdrCcSetMaxAge(reply->cache_control, 86400);
httpHeaderPutCc(&reply->header, reply->cache_control);
httpReplySwapOut(reply, e);
reply->hdr_sz = e->mem_obj->inmem_hi; /* yuk */
/* read the file into the buffer and append it to store */
buf = memAllocate(MEM_4K_BUF);
while ((n = read(fd, buf, 4096)) > 0)
storeAppend(e, buf, n);
file_close(fd);
EBIT_SET(e->flags, ENTRY_SPECIAL);
storeBufferFlush(e);
storeComplete(e);
storeTimestampsSet(e);
debug(25, 3) ("Loaded icon %s\n", url);
storeUnlockObject(e);
memFree(buf, MEM_4K_BUF);
}
static void
peerCountMcastPeersDone(void *data)
{
ps_state *psstate = data;
peer *p = psstate->callback_data;
StoreEntry *fake = psstate->entry;
if (cbdataValid(p)) {
p->mcast.flags.counting = 0;
p->mcast.avg_n_members = doubleAverage(p->mcast.avg_n_members,
(double) psstate->ping.n_recv,
++p->mcast.n_times_counted,
10);
debug(15, 1) ("Group %s: %d replies, %4.1f average, RTT %d\n",
p->host,
psstate->ping.n_recv,
p->mcast.avg_n_members,
p->stats.rtt);
p->mcast.n_replies_expected = (int) p->mcast.avg_n_members;
}
cbdataUnlock(p);
EBIT_SET(fake->flags, ENTRY_ABORTED);
requestUnlink(fake->mem_obj->request);
fake->mem_obj->request = NULL;
storeReleaseRequest(fake);
storeUnlockObject(fake);
requestUnlink(psstate->request);
cbdataFree(psstate);
}
static void asyncPrefetchTs(const char *url)
{
debug(207, 1) ("start asyncPrefetchTs async prefetch: '%s'\n", url);
request_t *request = NULL;
StoreEntry *entry = NULL;
request = modifyRequestUrlstoreUrl(url);
request->flags.cachable = CACHE;
if (storeGetPublicByRequest(request) != NULL) {
debug(207, 3) ("this entry has already exist,give up async prefetch: '%s'\n", request->store_url);
return;
}
entry = storeCreateEntry(urlCanonical(request),
request->flags,
request->method);
if (request->store_url)
storeEntrySetStoreUrl(entry, request->store_url);
if(Config.onoff.collapsed_forwarding)
{
EBIT_SET(entry->flags, KEY_EARLY_PUBLIC);
storeSetPublicKey(entry);
}
fwdStart(-1, entry, request);
requestUnlink(request);
}
static void
storeCleanup(void *datanotused)
{
static int bucketnum = -1;
static int validnum = 0;
static int store_errors = 0;
int validnum_start;
StoreEntry *e;
hash_link *link_ptr = NULL;
hash_link *link_next = NULL;
int limit = opt_foreground_rebuild ? 1 << 30 : 500;
validnum_start = validnum;
while (validnum - validnum_start < limit) {
if (++bucketnum >= store_hash_buckets) {
debug(20, 1) (" Completed Validation Procedure\n");
debug(20, 1) (" Validated %d Entries\n", validnum);
debug(20, 1) (" store_swap_size = %dk\n", store_swap_size);
store_dirs_rebuilding--;
assert(0 == store_dirs_rebuilding);
if (opt_store_doublecheck)
assert(store_errors == 0);
if (store_digest)
storeDigestNoteStoreReady();
return;
}
link_next = hash_get_bucket(store_table, bucketnum);
while (NULL != (link_ptr = link_next)) {
link_next = link_ptr->next;
e = (StoreEntry *) link_ptr;
if (EBIT_TEST(e->flags, ENTRY_VALIDATED))
continue;
/*
* Calling storeRelease() has no effect because we're
* still in 'store_rebuilding' state
*/
if (e->swap_filen < 0)
continue;
if (opt_store_doublecheck)
if (storeCleanupDoubleCheck(e))
store_errors++;
EBIT_SET(e->flags, ENTRY_VALIDATED);
/*
* Only set the file bit if we know its a valid entry
* otherwise, set it in the validation procedure
*/
storeDirUpdateSwapSize(&Config.cacheSwap.swapDirs[e->swap_dirn], e->swap_file_sz, 1);
/* Get rid of private objects. Not useful */
if (EBIT_TEST(e->flags, KEY_PRIVATE))
storeRelease(e);
if ((++validnum & 0x3FFFF) == 0)
debug(20, 1) (" %7d Entries Validated so far.\n", validnum);
}
}
eventAdd("storeCleanup", storeCleanup, NULL, 0.0, 1);
}
static void
storeDigestRewriteResume(void)
{
StoreEntry *e;
assert(sd_state.rewrite_lock);
assert(!sd_state.rebuild_lock);
e = sd_state.rewrite_lock->data;
sd_state.rewrite_offset = 0;
EBIT_SET(e->flags, ENTRY_SPECIAL);
/* setting public key will purge old digest entry if any */
storeSetPublicKey(e);
/* fake reply */
httpReplyReset(e->mem_obj->reply);
httpReplySetHeaders(e->mem_obj->reply, 200, "Cache Digest OK", "application/cache-digest", store_digest->mask_size + sizeof(sd_state.cblock), squid_curtime, squid_curtime + Config.digest.rewrite_period);
debug(71, 3) ("storeDigestRewriteResume: entry expires on %ld (%+d)\n",
(long int) e->mem_obj->reply->expires, (int) (e->mem_obj->reply->expires - squid_curtime));
storeBuffer(e);
httpReplySwapOut(e->mem_obj->reply, e);
e->mem_obj->reply->hdr_sz = e->mem_obj->inmem_hi;
storeDigestCBlockSwapOut(e);
storeBufferFlush(e);
eventAdd("storeDigestSwapOutStep", storeDigestSwapOutStep, sd_state.rewrite_lock, 0.0, 1);
}
