HttpHdrContRange *
httpHeaderGetContRange(const HttpHeader * hdr)
{
HttpHdrContRange *cr = NULL;
HttpHeaderEntry *e;
if ((e = httpHeaderFindEntry(hdr, HDR_CONTENT_RANGE))) {
cr = httpHdrContRangeParseCreate(strBuf(e->value));
httpHeaderNoteParsedEntry(e->id, e->value, !cr);
}
return cr;
}
/* packs request-line and headers, appends <crlf> terminator */
static void
httpRequestPack(const request_t * req, Packer * p)
{
assert(req && p);
/* pack request-line */
packerPrintf(p, "%s %s HTTP/1.0\r\n",
RequestMethodStr[req->method], strBuf(req->urlpath));
/* headers */
httpHeaderPackInto(&req->header, p);
/* trailer */
packerAppend(p, "\r\n", 2);
}
static int
peerDigestUseful(const PeerDigest * pd)
{
/* TODO: we should calculate the prob of a false hit instead of bit util */
const int bit_util = cacheDigestBitUtil(pd->cd);
if (bit_util > 65) {
debug(72, 0) ("Warning: %s peer digest has too many bits on (%d%%).\n",
strBuf(pd->host), bit_util);
return 0;
}
return 1;
}
/* returns true if header is allowed to be passed on */
int
httpRequestHdrAllowed(const HttpHeaderEntry * e, String * strConn)
{
assert(e);
/* check with anonymizer tables */
if (CBIT_TEST(Config.anonymize_headers, e->id))
return 0;
/* check connection header */
if (strConn && strListIsMember(strConn, strBuf(e->name), ','))
return 0;
return 1;
}
/* unusual */
const char *
httpHeaderGetLastStr(const HttpHeader * hdr, http_hdr_type id)
{
HttpHeaderEntry *e;
assert_eid(id);
assert(Headers[id].type == ftStr); /* must be of an appropriate type */
if ((e = httpHeaderFindLastEntry(hdr, id))) {
httpHeaderNoteParsedEntry(e->id, e->value, 0); /* no errors are possible */
return strBuf(e->value);
}
return NULL;
}
static inline void modify_request(clientHttpRequest * http)
{
debug(97, 3)("modify_request: start, uri=[%s]\n", http->uri);
request_t* old_request = http->request;
request_t* new_request = urlParse(old_request->method, http->uri);
safe_free(http->uri);
if (new_request)
{
safe_free(http->uri);
http->uri = xstrdup(urlCanonical(new_request));
if(!http->log_uri)
http->log_uri = xstrdup(urlCanonicalClean(old_request));
new_request->http_ver = old_request->http_ver;
httpHeaderAppend(&new_request->header, &old_request->header);
new_request->client_addr = old_request->client_addr;
new_request->client_port = old_request->client_port;
#if FOLLOW_X_FORWARDED_FOR
new_request->indirect_client_addr = old_request->indirect_client_addr;
#endif /* FOLLOW_X_FORWARDED_FOR */
new_request->my_addr = old_request->my_addr;
new_request->my_port = old_request->my_port;
new_request->flags = old_request->flags;
new_request->flags.redirected = 1;
if (old_request->auth_user_request)
{
new_request->auth_user_request = old_request->auth_user_request;
authenticateAuthUserRequestLock(new_request->auth_user_request);
}
if (old_request->body_reader)
{
new_request->body_reader = old_request->body_reader;
new_request->body_reader_data = old_request->body_reader_data;
old_request->body_reader = NULL;
old_request->body_reader_data = NULL;
}
new_request->content_length = old_request->content_length;
if (strBuf(old_request->extacl_log))
new_request->extacl_log = stringDup(&old_request->extacl_log);
if (old_request->extacl_user)
new_request->extacl_user = xstrdup(old_request->extacl_user);
if (old_request->extacl_passwd)
new_request->extacl_passwd = xstrdup(old_request->extacl_passwd);
if(old_request->cc_request_private_data)
{
new_request->cc_request_private_data = old_request->cc_request_private_data;
old_request->cc_request_private_data = NULL;
}
requestUnlink(old_request);
http->request = requestLink(new_request);
}
}
int
httpHeaderIdByName(const char *name, int name_len, const HttpHeaderFieldInfo * info, int end)
{
int i;
for (i = 0; i < end; ++i) {
if (name_len >= 0 && name_len != strLen(info[i].name))
continue;
if (!strncasecmp(name, strBuf(info[i].name),
name_len < 0 ? strLen(info[i].name) + 1 : name_len))
return i;
}
return -1;
}
time_t
httpHeaderGetTime(const HttpHeader * hdr, http_hdr_type id)
{
HttpHeaderEntry *e;
time_t value = -1;
assert_eid(id);
assert(Headers[id].type == ftDate_1123); /* must be of an appropriate type */
if ((e = httpHeaderFindEntry(hdr, id))) {
value = parse_rfc1123(strBuf(e->value));
httpHeaderNoteParsedEntry(e->id, e->value, value < 0);
}
return value;
}
int
httpHeaderGetInt(const HttpHeader * hdr, http_hdr_type id)
{
HttpHeaderEntry *e;
int value = -1;
int ok;
assert_eid(id);
assert(Headers[id].type == ftInt); /* must be of an appropriate type */
if ((e = httpHeaderFindEntry(hdr, id))) {
ok = httpHeaderParseInt(strBuf(e->value), &value);
httpHeaderNoteParsedEntry(e->id, e->value, !ok);
}
return value;
}
/* return a string or list of entries with the same id separated by ',' and ws */
String
httpHeaderGetStrOrList(const HttpHeader * hdr, http_hdr_type id)
{
HttpHeaderEntry *e;
if (CBIT_TEST(ListHeadersMask, id))
return httpHeaderGetList(hdr, id);
if ((e = httpHeaderFindEntry(hdr, id))) {
String s;
stringInit(&s, strBuf(e->value));
return s;
}
return StringNull;
}
static void
httpHeaderFieldStatDumper(StoreEntry * sentry, int idx, double val, double size, int count)
{
const int id = (int) val;
const int valid_id = id >= 0 && id < HDR_ENUM_END;
const char *name = valid_id ? strBuf(Headers[id].name) : "INVALID";
int visible = count > 0;
/* for entries with zero count, list only those that belong to current type of message */
if (!visible && valid_id && dump_stat->owner_mask)
visible = CBIT_TEST(*dump_stat->owner_mask, id);
if (visible)
storeAppendPrintf(sentry, "%2d\t %-20s\t %5d\t %6.2f\n",
id, name, count, xdiv(count, dump_stat->busyDestroyedCount));
}
void
storeLog(int tag, const StoreEntry * e)
{
MemObject *mem = e->mem_obj;
HttpReply *reply;
if (NULL == storelog)
return;
#if UNUSED_CODE
if (EBIT_TEST(e->flags, ENTRY_DONT_LOG))
return;
#endif
if (mem != NULL) {
if (mem->log_url == NULL) {
debug(20, 1) ("storeLog: NULL log_url for %s\n", mem->url);
storeMemObjectDump(mem);
mem->log_url = xstrdup(mem->url);
}
reply = mem->reply;
/*
* XXX Ok, where should we print the dir number here?
* Because if we print it before the swap file number, it'll break
* the existing log format.
*/
logfilePrintf(storelog, "%9d.%03d %-7s %02d %08X %s %4d %9d %9d %9d %s %d/%d %s %s\n",
(int) current_time.tv_sec,
(int) current_time.tv_usec / 1000,
storeLogTags[tag],
e->swap_dirn,
e->swap_filen,
storeKeyText(e->hash.key),
reply->sline.status,
(int) reply->date,
(int) reply->last_modified,
(int) reply->expires,
strLen(reply->content_type) ? strBuf(reply->content_type) : "unknown",
reply->content_length,
(int) (mem->inmem_hi - mem->reply->hdr_sz),
RequestMethodStr[mem->method],
mem->log_url);
} else {
/* no mem object. Most RELEASE cases */
logfilePrintf(storelog, "%9d.%03d %-7s %02d %08X %s ? ? ? ? ?/? ?/? ? ?\n",
(int) current_time.tv_sec,
(int) current_time.tv_usec / 1000,
storeLogTags[tag],
e->swap_dirn,
e->swap_filen,
storeKeyText(e->hash.key));
}
}
/*
* iterates through a 0-terminated string of items separated by 'del's.
* white space around 'del' is considered to be a part of 'del'
* like strtok, but preserves the source, and can iterate several strings at once
*
* returns true if next item is found.
* init pos with NULL to start iteration.
*/
int
strListGetItem(const String * str, char del, const char **item, int *ilen, const char **pos)
{
size_t len;
/* ',' is always enabled as field delimiter as this is required for
* processing merged header values properly, even if Cookie normally
* uses ';' as delimiter.
*/
static char delim[3][8] =
{
"\"?,",
"\"\\",
" ?,\t\r\n"
};
int quoted = 0;
delim[0][1] = del;
delim[2][1] = del;
assert(str && item && pos);
if (!*pos) {
*pos = strBuf(*str);
if (!*pos)
return 0;
}
/* skip leading whitespace and delimiters */
*pos += strspn(*pos, delim[2]);
*item = *pos; /* remember item's start */
/* find next delimiter */
do {
*pos += strcspn(*pos, delim[quoted]);
if (**pos == '"') {
quoted = !quoted;
*pos += 1;
} else if (quoted && **pos == '\\') {
*pos += 1;
if (**pos)
*pos += 1;
} else {
break; /* Delimiter found, marking the end of this value */
}
} while (**pos);
len = *pos - *item; /* *pos points to del or '\0' */
/* rtrim */
while (len > 0 && xisspace((*item)[len - 1]))
len--;
if (ilen)
*ilen = len;
return len > 0;
}
void
storeLog(int tag, const StoreEntry * e)
{
MemObject *mem = e->mem_obj;
HttpReply *reply;
if (NULL == storelog)
return;
#if UNUSED_CODE
if (EBIT_TEST(e->flags, ENTRY_DONT_LOG))
return;
#endif
if (mem != NULL) {
reply = mem->reply;
/*
* XXX Ok, where should we print the dir number here?
* Because if we print it before the swap file number, it'll break
* the existing log format.
*/
logfileLineStart(storelog);
logfilePrintf(storelog, "%9ld.%03d %-7s %02d %08X %s %4d %9ld %9ld %9ld %s %" PRINTF_OFF_T "/%" PRINTF_OFF_T " %s %s\n",
(long int) current_time.tv_sec,
(int) current_time.tv_usec / 1000,
storeLogTags[tag],
e->swap_dirn,
e->swap_filen,
storeKeyText(e->hash.key),
reply->sline.status,
(long int) reply->date,
(long int) reply->last_modified,
(long int) reply->expires,
strLen(reply->content_type) ? strBuf(reply->content_type) : "unknown",
reply->content_length,
mem->inmem_hi - mem->reply->hdr_sz,
RequestMethods[mem->method].str,
rfc1738_escape_unescaped(mem->url));
logfileLineEnd(storelog);
} else {
/* no mem object. Most RELEASE cases */
logfileLineStart(storelog);
logfilePrintf(storelog, "%9ld.%03d %-7s %02d %08X %s ? ? ? ? ?/? ?/? ? ?\n",
(long int) current_time.tv_sec,
(int) current_time.tv_usec / 1000,
storeLogTags[tag],
e->swap_dirn,
e->swap_filen,
storeKeyText(e->hash.key));
logfileLineEnd(storelog);
}
}
/* disables peer for good */
static void
peerDigestDisable(PeerDigest * pd)
{
debug(72, 2) ("peerDigestDisable: peer %s disabled for good\n",
strBuf(pd->host));
pd->times.disabled = squid_curtime;
pd->times.next_check = -1; /* never */
pd->flags.usable = 0;
if (pd->cd) {
cacheDigestDestroy(pd->cd);
pd->cd = NULL;
}
/* we do not destroy the pd itself to preserve its "history" and stats */
}
//显示消息提示
EXT_CLASS void ShowBubleMessageTip(const HWND hParentWnd,const CString& strMsg,EBUBLEPOSITION pos)
{
//创建窗体
CTipWnd tipWnd;
tipWnd.Create(hParentWnd,NULL,UI_WNDSTYLE_DIALOG,0,0,0,0,0,NULL);
//相关区域位置
RECT rc,rect;
GetClientRect(tipWnd.GetHWND(),&rc);
GetWindowRect(hParentWnd,&rect);
//偏移量读取
int propX = 0;
int propY = 0;
CBcfFile bcfFile(CBcfFile::GetAppPath()+"..\\ClientMessage.bcf");
//设置位置
int moveX = 0;
int moveY = 0;
switch (pos)
{
case BUBLE_ON_BANK_OK_BTN:
{
int posX = bcfFile.GetKeyVal("CustomDuiMessagePos","game_bank_ok_btn_posX",500);
int posY = bcfFile.GetKeyVal("CustomDuiMessagePos","game_bank_ok_btn_posY",80);
moveX = rect.right - posX;
moveY = rect.bottom - posY;
}
break;
default:
{}
}
//移动位置
::MoveWindow(tipWnd.GetHWND(),moveX,moveY,rc.right-rc.left,rc.bottom-rc.top,true);
//设置显示字体
CString strBuf(strMsg);
tipWnd.SetText(strBuf.GetBuffer());
tipWnd.ShowModal();
tipWnd.ShowWindow(SW_SHOW);
Sleep(200);
strBuf.ReleaseBuffer();
}
/* use fresh entries to replace old ones */
void
httpHeaderUpdate(HttpHeader * old, const HttpHeader * fresh, const HttpHeaderMask * denied_mask)
{
const HttpHeaderEntry *e;
HttpHeaderPos pos = HttpHeaderInitPos;
assert(old && fresh);
assert(old != fresh);
debug(55, 7) ("updating hdr: %p <- %p\n", old, fresh);
while ((e = httpHeaderGetEntry(fresh, &pos))) {
/* deny bad guys (ok to check for HDR_OTHER) here */
if (denied_mask && CBIT_TEST(*denied_mask, e->id))
continue;
httpHeaderDelByName(old, strBuf(e->name));
httpHeaderAddEntry(old, httpHeaderEntryClone(e));
}
}
void
peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e)
{
#define f2s(flag) (pd->flags.flag ? "yes" : "no")
#define appendTime(tm) storeAppendPrintf(e, "%s\t %10d\t %+d\t %+d\n", \
""#tm, pd->times.tm, \
saneDiff(pd->times.tm - squid_curtime), \
saneDiff(pd->times.tm - pd->times.initialized))
const char *host = pd ? strBuf(pd->host) : NULL;
assert(pd);
storeAppendPrintf(e, "\npeer digest from %s\n", host);
cacheDigestGuessStatsReport(&pd->stats.guess, e, host);
storeAppendPrintf(e, "\nevent\t timestamp\t secs from now\t secs from init\n");
appendTime(initialized);
appendTime(needed);
appendTime(requested);
appendTime(received);
appendTime(next_check);
storeAppendPrintf(e, "peer digest state:\n");
storeAppendPrintf(e, "\tneeded: %3s, usable: %3s, requested: %3s\n",
f2s(needed), f2s(usable), f2s(requested));
storeAppendPrintf(e, "\n\tlast retry delay: %d secs\n",
pd->times.retry_delay);
storeAppendPrintf(e, "\tlast request response time: %d secs\n",
pd->times.req_delay);
storeAppendPrintf(e, "\tlast request result: %s\n",
pd->req_result ? pd->req_result : "(none)");
storeAppendPrintf(e, "\npeer digest traffic:\n");
storeAppendPrintf(e, "\trequests sent: %d, volume: %d KB\n",
pd->stats.sent.msgs, (int) pd->stats.sent.kbytes.kb);
storeAppendPrintf(e, "\treplies recv: %d, volume: %d KB\n",
pd->stats.recv.msgs, (int) pd->stats.recv.kbytes.kb);
storeAppendPrintf(e, "\npeer digest structure:\n");
if (pd->cd)
cacheDigestReport(pd->cd, host, e);
else
storeAppendPrintf(e, "\tno in-memory copy\n");
}
/** Write Unicode string to stream (blocks until write is completed)
* @param buf string to write
* @return NS_OK on success
*/
NS_IMETHODIMP mozXMLTermStream::Write(const PRUnichar* buf)
{
nsresult result;
XMLT_LOG(mozXMLTermStream::Write,50,("\n"));
if (!buf)
return NS_ERROR_FAILURE;
nsAutoString strBuf ( buf );
// Convert Unicode string to UTF8 and store in buffer
char* utf8Str = ToNewUTF8String(strBuf);
mUTF8Buffer = utf8Str;
nsMemory::Free(utf8Str);
mUTF8Offset = 0;
#ifdef NO_WORKAROUND
PRUint32 sourceOffset = 0;
while (mUTF8Offset < mUTF8Buffer.Length()) {
PRUint32 remCount = mUTF8Buffer.Length() - mUTF8Offset;
result = mStreamListener->OnDataAvailable(mChannel, mContext,
this, sourceOffset, remCount);
if (NS_FAILED(result))
return result;
}
#else // !NO_WORKAROUND
result = mDOMHTMLDocument->Write(strBuf);
if (NS_FAILED(result))
return result;
#endif // !NO_WORKAROUND
XMLT_WARNING("mozXMLTermStream::Write: str=%s\n", mUTF8Buffer.get());
XMLT_LOG(mozXMLTermStream::Write,51,
("returning mUTF8Offset=%u\n", mUTF8Offset));
return NS_OK;
}
void
whoisStart(FwdState * fwd)
{
WhoisState *p;
int fd = fwd->server_fd;
char *buf;
size_t l;
CBDATA_INIT_TYPE(WhoisState);
p = cbdataAlloc(WhoisState);
p->request = fwd->request;
p->entry = fwd->entry;
p->fwd = fwd;
storeLockObject(p->entry);
comm_add_close_handler(fd, whoisClose, p);
l = strLen(p->request->urlpath) + 3;
buf = xmalloc(l);
snprintf(buf, l, "%s\r\n", strBuf(p->request->urlpath) + 1);
comm_write(fd, buf, strlen(buf), NULL, p, xfree);
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, 0);
commSetTimeout(fd, Config.Timeout.read, whoisTimeout, p);
}
/* destroys digest if peer disappeared
* must be called only when fetch and pd cbdata are valid */
static void
peerDigestPDFinish(DigestFetchState * fetch, int pcb_valid, int err)
{
PeerDigest *pd = fetch->pd;
const char *host = strBuf(pd->host);
pd->times.received = squid_curtime;
pd->times.req_delay = fetch->resp_time;
kb_incr(&pd->stats.sent.kbytes, (size_t) fetch->sent.bytes);
kb_incr(&pd->stats.recv.kbytes, (size_t) fetch->recv.bytes);
pd->stats.sent.msgs += fetch->sent.msg;
pd->stats.recv.msgs += fetch->recv.msg;
if (err) {
debug(72, 1) ("%sdisabling (%s) digest from %s\n",
pcb_valid ? "temporary " : "",
pd->req_result, host);
if (pd->cd) {
cacheDigestDestroy(pd->cd);
pd->cd = NULL;
}
pd->flags.usable = 0;
if (!pcb_valid)
peerDigestNotePeerGone(pd);
} else {
assert(pcb_valid);
pd->flags.usable = 1;
/* XXX: ugly condition, but how? */
if (fetch->entry->store_status == STORE_OK)
debug(72, 2) ("re-used old digest from %s\n", host);
else
debug(72, 2) ("received valid digest from %s\n", host);
}
fetch->pd = NULL;
cbdataUnlock(pd);
}
static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
{
// Try to insert Window menu in front of Help, otherwise append it.
HMENU hmenu = (HMENU)menu;
if (subMenu)
{
int N = GetMenuItemCount(hmenu);
bool success = false;
for ( int i = 0; i < N; i++ )
{
wxChar buf[256];
int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
if ( chars == 0 )
{
wxLogLastError(wxT("GetMenuString"));
continue;
}
wxString strBuf(buf);
if ( wxStripMenuCodes(strBuf) == wxGetStockLabel(wxID_HELP,false) )
{
success = true;
::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
(UINT)subMenu, _("&Window"));
break;
}
}
if ( !success )
{
::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window"));
}
}
MDISetMenu(win, hmenu, subMenu);
}
TimeOrTag
httpHeaderGetTimeOrTag(const HttpHeader * hdr, http_hdr_type id)
{
TimeOrTag tot;
HttpHeaderEntry *e;
assert(Headers[id].type == ftDate_1123_or_ETag); /* must be of an appropriate type */
memset(&tot, 0, sizeof(tot));
if ((e = httpHeaderFindEntry(hdr, id))) {
const char *str = strBuf(e->value);
/* try as an ETag */
if (etagParseInit(&tot.tag, str)) {
tot.valid = tot.tag.str != NULL;
tot.time = -1;
} else {
/* or maybe it is time? */
tot.time = parse_rfc1123(str);
tot.valid = tot.time >= 0;
tot.tag.str = NULL;
}
}
assert(tot.time < 0 || !tot.tag.str); /* paranoid */
return tot;
}
/* Parse a gopher request into components. By Anawat. */
static void
gopher_request_parse(const request_t * req, char *type_id, char *request)
{
const char *path = strBuf(req->urlpath);
if (request)
request[0] = '\0';
if (path && (*path == '/'))
path++;
if (!path || !*path) {
*type_id = GOPHER_DIRECTORY;
return;
}
*type_id = path[0];
if (request) {
xstrncpy(request, path + 1, MAX_URL);
/* convert %xx to char */
url_convert_hex(request, 0);
}
}
void
httpHeaderStoreReport(StoreEntry * e)
{
int i;
http_hdr_type ht;
assert(e);
HttpHeaderStats[0].parsedCount =
HttpHeaderStats[hoRequest].parsedCount + HttpHeaderStats[hoReply].parsedCount;
HttpHeaderStats[0].ccParsedCount =
HttpHeaderStats[hoRequest].ccParsedCount + HttpHeaderStats[hoReply].ccParsedCount;
HttpHeaderStats[0].destroyedCount =
HttpHeaderStats[hoRequest].destroyedCount + HttpHeaderStats[hoReply].destroyedCount;
HttpHeaderStats[0].busyDestroyedCount =
HttpHeaderStats[hoRequest].busyDestroyedCount + HttpHeaderStats[hoReply].busyDestroyedCount;
for (i = 1; i < HttpHeaderStatCount; i++) {
httpHeaderStatDump(HttpHeaderStats + i, e);
storeAppendPrintf(e, "%s\n", "<br>");
}
/* field stats for all messages */
storeAppendPrintf(e, "\nHttp Fields Stats (replies and requests)\n");
storeAppendPrintf(e, "%2s\t %-20s\t %5s\t %6s\t %6s\n",
"id", "name", "#alive", "%err", "%repeat");
for (ht = 0; ht < HDR_ENUM_END; ht++) {
HttpHeaderFieldInfo *f = Headers + ht;
storeAppendPrintf(e, "%2d\t %-20s\t %5d\t %6.3f\t %6.3f\n",
f->id, strBuf(f->name), f->stat.aliveCount,
xpercent(f->stat.errCount, f->stat.parsCount),
xpercent(f->stat.repCount, f->stat.seenCount));
}
storeAppendPrintf(e, "Headers Parsed: %d + %d = %d\n",
HttpHeaderStats[hoRequest].parsedCount,
HttpHeaderStats[hoReply].parsedCount,
HttpHeaderStats[0].parsedCount);
storeAppendPrintf(e, "Hdr Fields Parsed: %d\n", HeaderEntryParsedCount);
}
bool CsocketClient::_Send(const CString& str)
{
CStringA strBuf(str);
strBuf = strBuf.Trim();
strBuf += "\n";
int iLength = strBuf.GetLength();
LPSTR p = strBuf.GetBuffer();
int iSent = Send(p, iLength);
strBuf.ReleaseBuffer();
if (iSent == SOCKET_ERROR)
{
//
return false;
}
else if (iSent != iLength)
{
//
}
return true;
}
/*
* Returns the value of the specified header.
*/
String
httpHeaderGetByName(const HttpHeader * hdr, const char *name)
{
http_hdr_type id;
HttpHeaderPos pos = HttpHeaderInitPos;
HttpHeaderEntry *e;
String result = StringNull;
assert(hdr);
assert(name);
/* First try the quick path */
id = httpHeaderIdByNameDef(name, strlen(name));
if (id != -1)
return httpHeaderGetStrOrList(hdr, id);
/* Sorry, an unknown header name. Do linear search */
while ((e = httpHeaderGetEntry(hdr, &pos))) {
if (e->id == HDR_OTHER && strCaseCmp(e->name, name) == 0) {
strListAdd(&result, strBuf(e->value), ',');
}
}
return result;
}
/* fetch headers from disk, pass on to SwapInCBlock */
static void
peerDigestSwapInHeaders(void *data, mem_node_ref nr, ssize_t size)
{
DigestFetchState *fetch = data;
assert(size <= nr.node->len - nr.offset);
if (peerDigestFetchedEnough(fetch, size, "peerDigestSwapInHeaders"))
goto finish;
assert(!fetch->offset);
assert(fetch->entry->mem_obj->reply);
if (fetch->entry->mem_obj->reply->sline.status != HTTP_OK) {
debug(72, 1) ("peerDigestSwapInHeaders: %s status %d got cached!\n",
strBuf(fetch->pd->host), fetch->entry->mem_obj->reply->sline.status);
peerDigestFetchAbort(fetch, "internal status error");
goto finish;
}
fetch->offset = fetch->entry->mem_obj->reply->hdr_sz;
fetch->buf = memAllocate(MEM_4K_BUF);
storeClientRef(fetch->sc, fetch->entry, fetch->offset, fetch->offset,
SM_PAGE_SIZE, peerDigestSwapInCBlock, fetch);
finish:
stmemNodeUnref(&nr);
}
static const char *
errorConvert(char token, ErrorState * err)
{
request_t *r = err->request;
static MemBuf mb = MemBufNULL;
const char *p = NULL; /* takes priority over mb if set */
int do_quote = 1;
memBufReset(&mb);
switch (token) {
case 'a':
if (r && r->auth_user_request)
p = authenticateUserRequestUsername(r->auth_user_request);
if (!p)
p = "-";
break;
case 'B':
p = r ? ftpUrlWith2f(r) : "[no URL]";
break;
case 'c':
p = errorPageName(err->type);
break;
case 'e':
memBufPrintf(&mb, "%d", err->xerrno);
break;
case 'E':
if (err->xerrno)
memBufPrintf(&mb, "(%d) %s", err->xerrno, strerror(err->xerrno));
else
memBufPrintf(&mb, "[No Error]");
break;
case 'f':
/* FTP REQUEST LINE */
if (err->ftp.request)
p = err->ftp.request;
else
p = "nothing";
break;
case 'F':
/* FTP REPLY LINE */
if (err->ftp.request)
p = err->ftp.reply;
else
p = "nothing";
break;
case 'g':
/* FTP SERVER MESSAGE */
wordlistCat(err->ftp.server_msg, &mb);
break;
case 'h':
memBufPrintf(&mb, "%s", getMyHostname());
break;
case 'H':
if (r) {
if (r->hier.host)
p = r->hier.host;
else
p = r->host;
} else
p = "[unknown host]";
break;
case 'i':
memBufPrintf(&mb, "%s", inet_ntoa(err->src_addr));
break;
case 'I':
if (r && r->hier.host) {
memBufPrintf(&mb, "%s", r->hier.host);
} else
p = "[unknown]";
break;
case 'L':
if (Config.errHtmlText) {
memBufPrintf(&mb, "%s", Config.errHtmlText);
do_quote = 0;
} else
p = "[not available]";
break;
case 'm':
p = authenticateAuthUserRequestMessage(err->auth_user_request) ? authenticateAuthUserRequestMessage(err->auth_user_request) : "[not available]";
break;
case 'M':
p = r ? RequestMethods[r->method].str : "[unknown method]";
break;
case 'o':
p = external_acl_message;
if (!p)
p = "[not available]";
break;
case 'p':
if (r) {
memBufPrintf(&mb, "%d", (int) r->port);
} else {
p = "[unknown port]";
}
break;
case 'P':
p = r ? ProtocolStr[r->protocol] : "[unkown protocol]";
break;
case 'R':
if (NULL != r) {
Packer p;
memBufPrintf(&mb, "%s %s HTTP/%d.%d\n",
RequestMethods[r->method].str,
strLen(r->urlpath) ? strBuf(r->urlpath) : "/",
r->http_ver.major, r->http_ver.minor);
packerToMemInit(&p, &mb);
httpHeaderPackInto(&r->header, &p);
packerClean(&p);
} else if (err->request_hdrs) {
p = err->request_hdrs;
} else {
p = "[no request]";
}
break;
case 's':
p = visible_appname_string;
break;
case 'S':
/* signature may contain %-escapes, recursion */
if (err->page_id != ERR_SQUID_SIGNATURE) {
const int saved_id = err->page_id;
MemBuf sign_mb;
err->page_id = ERR_SQUID_SIGNATURE;
sign_mb = errorBuildContent(err);
memBufPrintf(&mb, "%s", sign_mb.buf);
memBufClean(&sign_mb);
err->page_id = saved_id;
do_quote = 0;
} else {
/* wow, somebody put %S into ERR_SIGNATURE, stop recursion */
p = "[%S]";
}
break;
case 't':
memBufPrintf(&mb, "%s", mkhttpdlogtime(&squid_curtime));
break;
case 'T':
memBufPrintf(&mb, "%s", mkrfc1123(squid_curtime));
break;
case 'U':
p = r ? urlCanonicalClean(r) : err->url ? err->url : "[no URL]";
break;
case 'u':
p = r ? urlCanonical(r) : err->url ? err->url : "[no URL]";
break;
case 'w':
if (Config.adminEmail)
memBufPrintf(&mb, "%s", Config.adminEmail);
else
p = "[unknown]";
break;
case 'z':
if (err->dnsserver_msg)
p = err->dnsserver_msg;
else
p = "[unknown]";
break;
case '%':
p = "%";
break;
default:
memBufPrintf(&mb, "%%%c", token);
do_quote = 0;
break;
}
if (!p)
p = mb.buf; /* do not use mb after this assignment! */
assert(p);
debug(4, 3) ("errorConvert: %%%c --> '%s'\n", token, p);
if (do_quote)
p = html_quote(p);
return p;
}
static int
peerDigestSetCBlock(PeerDigest * pd, const char *buf)
{
StoreDigestCBlock cblock;
int freed_size = 0;
const char *host = strBuf(pd->host);
xmemcpy(&cblock, buf, sizeof(cblock));
/* network -> host conversions */
cblock.ver.current = ntohs(cblock.ver.current);
cblock.ver.required = ntohs(cblock.ver.required);
cblock.capacity = ntohl(cblock.capacity);
cblock.count = ntohl(cblock.count);
cblock.del_count = ntohl(cblock.del_count);
cblock.mask_size = ntohl(cblock.mask_size);
debug(72, 2) ("got digest cblock from %s; ver: %d (req: %d)\n",
host, (int) cblock.ver.current, (int) cblock.ver.required);
debug(72, 2) ("\t size: %d bytes, e-cnt: %d, e-util: %d%%\n",
cblock.mask_size, cblock.count,
xpercentInt(cblock.count, cblock.capacity));
/* check version requirements (both ways) */
if (cblock.ver.required > CacheDigestVer.current) {
debug(72, 1) ("%s digest requires version %d; have: %d\n",
host, cblock.ver.required, CacheDigestVer.current);
return 0;
}
if (cblock.ver.current < CacheDigestVer.required) {
debug(72, 1) ("%s digest is version %d; we require: %d\n",
host, cblock.ver.current, CacheDigestVer.required);
return 0;
}
/* check consistency */
if (cblock.ver.required > cblock.ver.current ||
cblock.mask_size <= 0 || cblock.capacity <= 0 ||
cblock.bits_per_entry <= 0 || cblock.hash_func_count <= 0) {
debug(72, 0) ("%s digest cblock is corrupted.\n", host);
return 0;
}
/* check consistency further */
if (cblock.mask_size != cacheDigestCalcMaskSize(cblock.capacity, cblock.bits_per_entry)) {
debug(72, 0) ("%s digest cblock is corrupted (mask size mismatch: %d ? %d).\n",
host, cblock.mask_size, cacheDigestCalcMaskSize(cblock.capacity, cblock.bits_per_entry));
return 0;
}
/* there are some things we cannot do yet */
if (cblock.hash_func_count != CacheDigestHashFuncCount) {
debug(72, 0) ("%s digest: unsupported #hash functions: %d ? %d.\n",
host, cblock.hash_func_count, CacheDigestHashFuncCount);
return 0;
}
/*
* no cblock bugs below this point
*/
/* check size changes */
if (pd->cd && cblock.mask_size != pd->cd->mask_size) {
debug(72, 2) ("%s digest changed size: %d -> %d\n",
host, cblock.mask_size, pd->cd->mask_size);
freed_size = pd->cd->mask_size;
cacheDigestDestroy(pd->cd);
pd->cd = NULL;
}
if (!pd->cd) {
debug(72, 2) ("creating %s digest; size: %d (%+d) bytes\n",
host, cblock.mask_size, (int) (cblock.mask_size - freed_size));
pd->cd = cacheDigestCreate(cblock.capacity, cblock.bits_per_entry);
if (cblock.mask_size >= freed_size)
kb_incr(&Counter.cd.memory, cblock.mask_size - freed_size);
}
assert(pd->cd);
/* these assignments leave us in an inconsistent state until we finish reading the digest */
pd->cd->count = cblock.count;
pd->cd->del_count = cblock.del_count;
return 1;
}