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 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);
}
/* create MIME Header for Gopher Data */
static void
gopherMimeCreate(GopherStateData * gopherState)
{
StoreEntry *e = gopherState->entry;
HttpReply *reply = e->mem_obj->reply;
http_version_t version;
const char *mime_type = NULL;
const char *mime_enc = NULL;
switch (gopherState->type_id) {
case GOPHER_DIRECTORY:
case GOPHER_INDEX:
case GOPHER_HTML:
case GOPHER_WWW:
case GOPHER_CSO:
mime_type = "text/html";
break;
case GOPHER_GIF:
case GOPHER_IMAGE:
case GOPHER_PLUS_IMAGE:
mime_type = "image/gif";
break;
case GOPHER_SOUND:
case GOPHER_PLUS_SOUND:
mime_type = "audio/basic";
break;
case GOPHER_PLUS_MOVIE:
mime_type = "video/mpeg";
break;
case GOPHER_MACBINHEX:
mime_type = "application/macbinary";
break;
case GOPHER_DOSBIN:
case GOPHER_UUENCODED:
case GOPHER_BIN:
case GOPHER_FILE:
default:
/* Rightnow We have no idea what it is. */
mime_type = mimeGetContentType(gopherState->request);
mime_enc = mimeGetContentEncoding(gopherState->request);
break;
}
storeBuffer(e);
httpReplyReset(reply);
EBIT_CLR(gopherState->entry->flags, ENTRY_FWD_HDR_WAIT);
httpBuildVersion(&version, 1, 0);
httpReplySetHeaders(reply, version, HTTP_OK, "Gatewaying", mime_type, -1, -1, -1);
if (mime_enc)
httpHeaderPutStr(&reply->header, HDR_CONTENT_ENCODING, mime_enc);
httpReplySwapOut(reply, e);
reply->hdr_sz = e->mem_obj->inmem_hi;
storeTimestampsSet(e);
if (EBIT_TEST(e->flags, ENTRY_CACHABLE)) {
storeSetPublicKey(e);
} else {
storeRelease(e);
}
}
static void
whoisReadReply(int fd, void *data)
{
WhoisState *p = data;
StoreEntry *entry = p->entry;
char *buf = memAllocate(MEM_4K_BUF);
MemObject *mem = entry->mem_obj;
int len;
statCounter.syscalls.sock.reads++;
len = FD_READ_METHOD(fd, buf, 4095);
buf[len] = '\0';
debug(75, 3) ("whoisReadReply: FD %d read %d bytes\n", fd, len);
debug(75, 5) ("{%s}\n", buf);
if (len > 0) {
if (0 == mem->inmem_hi) {
http_reply *reply = mem->reply;
http_version_t version;
storeBuffer(entry);
httpBuildVersion(&version, 1, 0);
httpReplySetHeaders(reply, version, HTTP_OK, "Gatewaying", "text/plain", -1, -1, -2);
httpReplySwapOut(reply, entry);
}
fd_bytes(fd, len, FD_READ);
kb_incr(&statCounter.server.all.kbytes_in, len);
kb_incr(&statCounter.server.http.kbytes_in, len);
storeAppend(entry, buf, len);
storeBufferFlush(entry);
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else if (len < 0) {
debug(50, 2) ("whoisReadReply: FD %d: read failure: %s.\n",
fd, xstrerror());
if (ignoreErrno(errno)) {
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else {
ErrorState *err;
err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR, p->fwd->request);
err->xerrno = errno;
fwdFail(p->fwd, err);
comm_close(fd);
}
} else {
storeTimestampsSet(entry);
storeBufferFlush(entry);
if (!EBIT_TEST(entry->flags, RELEASE_REQUEST))
storeSetPublicKey(entry);
fwdComplete(p->fwd);
debug(75, 3) ("whoisReadReply: Done: %s\n", storeUrl(entry));
comm_close(fd);
}
memFree(buf, MEM_4K_BUF);
}
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);
}
void
storeUpdate(StoreEntry * entry, request_t * request)
{
StoreUpdateState *state;
request_flags flags = null_request_flags;
const char *vary;
if (!request)
request = entry->mem_obj->request;
if (EBIT_TEST(entry->flags, KEY_PRIVATE))
return; /* Nothing to do here... */
if (!Config.onoff.update_headers)
return; /* Disabled */
CBDATA_INIT_TYPE_FREECB(StoreUpdateState, free_StoreUpdateState);
if (entry->mem_obj)
entry->mem_obj->refresh_timestamp = 0;
state = cbdataAlloc(StoreUpdateState);
state->oldentry = entry;
storeLockObject(state->oldentry);
flags.cachable = 1;
state->newentry = storeCreateEntry(storeUrl(entry), flags, entry->mem_obj->method);
storeRegisterAbort(state->newentry, storeUpdateAbort, state);
state->sc = storeClientRegister(state->oldentry, state);
state->offset = entry->mem_obj->reply->hdr_sz;
storeBuffer(state->newentry);
httpReplySwapOut(httpReplyClone(entry->mem_obj->reply), state->newentry);
state->newentry->timestamp = entry->timestamp;
state->newentry->lastref = entry->lastref;
state->newentry->expires = entry->expires;
state->newentry->lastmod = entry->lastmod;
state->newentry->refcount = entry->refcount;
if (request) {
state->newentry->mem_obj->request = requestLink(request);
vary = httpMakeVaryMark(request, state->newentry->mem_obj->reply);
if (vary) {
state->newentry->mem_obj->vary_headers = xstrdup(vary);
if (strBuf(request->vary_encoding))
state->newentry->mem_obj->vary_encoding = xstrdup(strBuf(request->vary_encoding));
}
} else {
if (entry->mem_obj->vary_headers)
state->newentry->mem_obj->vary_headers = xstrdup(entry->mem_obj->vary_headers);
if (entry->mem_obj->vary_encoding)
state->newentry->mem_obj->vary_encoding = xstrdup(entry->mem_obj->vary_encoding);
}
storeSetPublicKey(state->newentry);
storeBufferFlush(state->newentry);
if (EBIT_TEST(entry->flags, ENTRY_ABORTED)) {
/*
* the above storeBufferFlush() call could ABORT this entry,
* in that case, there's nothing for us to do.
*/
debug(20, 1) ("storeUpdate: Aborted on write\n");
return;
}
storeClientCopy(state->sc, state->oldentry, state->offset, state->offset, sizeof(state->buf), state->buf, storeUpdateCopy, state);
return;
}
