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
requestDestroy(request_t * req)
{
assert(req);
if (req->body_reader)
requestAbortBody(req);
if (req->auth_user_request)
authenticateAuthUserRequestUnlock(req->auth_user_request);
safe_free(req->canonical);
safe_free(req->vary_hdr);
safe_free(req->vary_headers);
stringClean(&req->vary_encoding);
safe_free(req->urlgroup);
safe_free(req->extacl_user);
safe_free(req->extacl_passwd);
stringClean(&req->urlpath);
httpHeaderClean(&req->header);
if (req->cache_control)
httpHdrCcDestroy(req->cache_control);
if (req->range)
httpHdrRangeDestroy(req->range);
stringClean(&req->extacl_log);
if (req->vary) {
if (req->etags == &req->vary->etags)
req->etags = NULL;
storeLocateVaryDone(req->vary);
req->vary = NULL;
}
assert(req->etags == NULL);
safe_free(req->etag);
if (req->pinned_connection)
cbdataUnlock(req->pinned_connection);
req->pinned_connection = NULL;
memFree(req, MEM_REQUEST_T);
}
static void
httpReplyClean(HttpReply * rep)
{
assert(rep);
httpBodyClean(&rep->body);
httpReplyHdrCacheClean(rep);
httpHeaderClean(&rep->header);
httpStatusLineClean(&rep->sline);
}
/* just handy in parsing: resets and returns false */
int
httpHeaderReset(HttpHeader * hdr)
{
http_hdr_owner_type ho = hdr->owner;
assert(hdr);
ho = hdr->owner;
httpHeaderClean(hdr);
httpHeaderInit(hdr, ho);
return 0;
}
/*
* 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);
}
void
requestDestroy(request_t * req)
{
assert(req);
safe_free(req->body);
safe_free(req->canonical);
stringClean(&req->urlpath);
httpHeaderClean(&req->header);
if (req->cache_control)
httpHdrCcDestroy(req->cache_control);
if (req->range)
httpHdrRangeDestroy(req->range);
memFree(req, MEM_REQUEST_T);
}
void
requestDestroy(request_t * req)
{
assert(req);
if (req->body_connection)
clientAbortBody(req);
if (req->auth_user_request)
authenticateAuthUserRequestUnlock(req->auth_user_request);
safe_free(req->canonical);
safe_free(req->vary_headers);
stringClean(&req->urlpath);
httpHeaderClean(&req->header);
if (req->cache_control)
httpHdrCcDestroy(req->cache_control);
if (req->range)
httpHdrRangeDestroy(req->range);
memFree(req, MEM_REQUEST_T);
}
