static void
sslProxyConnected(int fd, void *data)
{
SslStateData *sslState = data;
MemBuf mb;
HttpHeader hdr_out;
Packer p;
http_state_flags flags;
debug(26, 3) ("sslProxyConnected: FD %d sslState=%p\n", fd, sslState);
memset(&flags, '\0', sizeof(flags));
memBufDefInit(&mb);
memBufPrintf(&mb, "CONNECT %s HTTP/1.0\r\n", sslState->url);
httpBuildRequestHeader(sslState->request,
sslState->request,
NULL, /* StoreEntry */
&hdr_out,
sslState->client.fd,
flags); /* flags */
packerToMemInit(&p, &mb);
httpHeaderPackInto(&hdr_out, &p);
httpHeaderClean(&hdr_out);
packerClean(&p);
memBufAppend(&mb, "\r\n", 2);
xstrncpy(sslState->client.buf, mb.buf, SQUID_TCP_SO_RCVBUF);
debug(26, 3) ("sslProxyConnected: Sending {%s}\n", sslState->client.buf);
sslState->client.len = mb.size;
memBufClean(&mb);
commSetTimeout(sslState->server.fd,
Config.Timeout.read,
sslTimeout,
sslState);
sslSetSelect(sslState);
}
void
httpReplyPackInto(const HttpReply * rep, Packer * p)
{
assert(rep);
httpStatusLinePackInto(&rep->sline, p);
httpHeaderPackInto(&rep->header, p);
packerAppend(p, "\r\n", 2);
httpBodyPackInto(&rep->body, p);
}
/* 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);
}
/*
* parses a given string then packs compiled headers and compares the result
* with the original, reports discrepancies
*/
void
httpHeaderTestParser(const char *hstr)
{
static int bug_count = 0;
int hstr_len;
int parse_success;
HttpHeader hdr;
int pos;
Packer p;
MemBuf mb;
assert(hstr);
/* skip start line if any */
if (!strncasecmp(hstr, "HTTP/", 5)) {
const char *p = strchr(hstr, '\n');
if (p)
hstr = p + 1;
}
/* skip invalid first line if any */
if (xisspace(*hstr)) {
const char *p = strchr(hstr, '\n');
if (p)
hstr = p + 1;
}
hstr_len = strlen(hstr);
/* skip terminator if any */
if (strstr(hstr, "\n\r\n"))
hstr_len -= 2;
else if (strstr(hstr, "\n\n"))
hstr_len -= 1;
httpHeaderInit(&hdr, hoReply);
/* debugLevels[55] = 8; */
parse_success = httpHeaderParse(&hdr, hstr, hstr + hstr_len);
/* debugLevels[55] = 2; */
if (!parse_success) {
debug(66, 2) ("TEST (%d): failed to parsed a header: {\n%s}\n", bug_count, hstr);
return;
}
/* we think that we parsed it, veryfy */
memBufDefInit(&mb);
packerToMemInit(&p, &mb);
httpHeaderPackInto(&hdr, &p);
if ((pos = abs(httpHeaderStrCmp(hstr, mb.buf, hstr_len)))) {
bug_count++;
debug(66, 2) ("TEST (%d): hdr parsing bug (pos: %d near '%s'): expected: {\n%s} got: {\n%s}\n",
bug_count, pos, hstr + pos, hstr, mb.buf);
}
httpHeaderClean(&hdr);
packerClean(&p);
memBufClean(&mb);
}
/* packs debug info, canonical request-line and headers, appends <crlf> terminator */
void
httpRequestPackDebug(request_t * req, Packer * p)
{
assert(req && p);
/* Client info */
packerPrintf(p, "Client: %s ", inet_ntoa(req->client_addr));
packerPrintf(p, "http_port: %s:%d", inet_ntoa(req->my_addr), req->my_port);
if (req->auth_user_request && authenticateUserRequestUsername(req->auth_user_request))
packerPrintf(p, "user: %s", authenticateUserRequestUsername(req->auth_user_request));
packerPrintf(p, "\n");
/* pack request-line */
packerPrintf(p, "%s %s HTTP/%d.%d\r\n",
RequestMethodStr[req->method], urlCanonical(req), req->http_ver.major, req->http_ver.minor);
/* headers */
httpHeaderPackInto(&req->header, p);
/* trailer */
packerAppend(p, "\r\n", 2);
}
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;
}