VED_Deliver(struct req *req, struct busyobj *bo, int wantbody)
{
int i;
struct ecx *ecx;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_ORNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);
if (wantbody == 0)
return;
req->res_mode |= RES_ESI_CHILD;
i = ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED);
if (ecx->isgzip && i && !(req->res_mode & RES_ESI)) {
ved_stripgzip(req, bo);
} else {
if (ecx->isgzip && !i)
VDP_push(req, ved_pretend_gzip, ecx, 1);
else
VDP_push(req, ved_vdp_bytes, ecx->preq, 1);
(void)VDP_DeliverObj(req);
}
VDP_close(req);
}
static void
cnt_vdp(struct req *req, struct busyobj *bo)
{
const char *r;
uint16_t status;
int wantbody;
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
req->res_mode = 0;
wantbody = 1;
status = http_GetStatus(req->resp);
if (!strcmp(req->http0->hd[HTTP_HDR_METHOD].b, "HEAD")) {
wantbody = 0;
} else if (status < 200 || status == 204) {
req->resp_len = 0;
http_Unset(req->resp, H_Content_Length);
wantbody = 0;
} else if (status == 304) {
http_Unset(req->resp, H_Content_Length);
wantbody = 0;
} else if (bo != NULL)
req->resp_len = http_GetContentLength(req->resp);
else
req->resp_len = ObjGetLen(req->wrk, req->objcore);
/*
* Determine ESI status first. Not dependent on wantbody, because
* we want ESI to supress C-L in HEAD too.
*/
if (!req->disable_esi && req->resp_len != 0 && wantbody &&
ObjGetattr(req->wrk, req->objcore, OA_ESIDATA, NULL) != NULL) {
req->res_mode |= RES_ESI;
RFC2616_Weaken_Etag(req->resp);
req->resp_len = -1;
VDP_push(req, VDP_ESI, NULL, 0);
}
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http)) {
req->res_mode |= RES_GUNZIP;
VDP_push(req, VDP_gunzip, NULL, 1);
}
/*
* Range comes after the others and pushes on bottom because
* it can (maybe) generate a correct C-L header.
*/
if (cache_param->http_range_support && http_IsStatus(req->resp, 200)) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (wantbody && http_GetHdr(req->http, H_Range, &r))
VRG_dorange(req, r);
}
req->transport->deliver(req, bo, wantbody);
}
V1D_Deliver(struct req *req, struct boc *boc, int sendbody)
{
int err = 0;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_ORNULL(boc, BOC_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
if (sendbody) {
if (http_GetHdr(req->resp, H_Content_Length, NULL))
req->res_mode |= RES_LEN;
else if (req->http->protover == 11) {
req->res_mode |= RES_CHUNKED;
http_SetHeader(req->resp, "Transfer-Encoding: chunked");
} else {
req->res_mode |= RES_EOF;
req->doclose = SC_TX_EOF;
}
}
VSLb(req->vsl, SLT_Debug, "RES_MODE %x", req->res_mode);
if (req->doclose) {
if (!http_HdrIs(req->resp, H_Connection, "close")) {
http_Unset(req->resp, H_Connection);
http_SetHeader(req->resp, "Connection: close");
}
} else if (!http_GetHdr(req->resp, H_Connection, NULL))
http_SetHeader(req->resp, "Connection: keep-alive");
if (sendbody && req->resp_len != 0)
VDP_push(req, v1d_bytes, NULL, 1);
AZ(req->wrk->v1l);
V1L_Reserve(req->wrk, req->ws, &req->sp->fd, req->vsl, req->t_prev);
if (WS_Overflowed(req->ws)) {
v1d_error(req, "workspace_client overflow");
AZ(req->wrk->v1l);
return;
}
req->acct.resp_hdrbytes += HTTP1_Write(req->wrk, req->resp, HTTP1_Resp);
if (DO_DEBUG(DBG_FLUSH_HEAD))
(void)V1L_Flush(req->wrk);
if (sendbody && req->resp_len != 0) {
if (req->res_mode & RES_CHUNKED)
V1L_Chunked(req->wrk);
err = VDP_DeliverObj(req);
if (!err && (req->res_mode & RES_CHUNKED))
V1L_EndChunk(req->wrk);
}
if ((V1L_FlushRelease(req->wrk) || err) && req->sp->fd >= 0)
SES_Close(req->sp, SC_REM_CLOSE);
AZ(req->wrk->v1l);
VDP_close(req);
}
VCL_VOID
vmod_resp(VRT_CTX, VCL_STRING val)
{
//thread check
if(ctx->req == NULL || ctx->req->magic != REQ_MAGIC){
VSLb(ctx->vsl, SLT_Error,"vmod-dump: dump.resp work only at client-thread.");
return;
}
VSLb(ctx->vsl, SLT_Debug,"%s-I: %s %d %s %d", VMOD_DUMP_PRE,
VRT_IP_string(ctx, VRT_r_client_ip(ctx)),
VSA_Port(VRT_r_client_ip(ctx)),
VRT_IP_string(ctx, VRT_r_server_ip(ctx)),
VSA_Port(VRT_r_server_ip(ctx))
);
VDP_push(ctx->req, VDP_dump, (void*)val, 1);
}
static enum req_fsm_nxt
cnt_transmit(struct worker *wrk, struct req *req)
{
struct boc *boc;
const char *r;
uint16_t status;
int sendbody;
intmax_t clval;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
/* Grab a ref to the bo if there is one */
boc = HSH_RefBoc(req->objcore);
clval = http_GetContentLength(req->resp);
if (boc != NULL)
req->resp_len = clval;
else
req->resp_len = ObjGetLen(req->wrk, req->objcore);
req->res_mode = 0;
/* RFC 7230, 3.3.3 */
status = http_GetStatus(req->resp);
if (!strcmp(req->http0->hd[HTTP_HDR_METHOD].b, "HEAD")) {
if (req->objcore->flags & OC_F_PASS)
sendbody = -1;
else
sendbody = 0;
} else if (status < 200 || status == 204 || status == 304) {
req->resp_len = -1;
sendbody = 0;
} else
sendbody = 1;
if (sendbody >= 0) {
if (!req->disable_esi && req->resp_len != 0 &&
ObjHasAttr(wrk, req->objcore, OA_ESIDATA))
VDP_push(req, VDP_ESI, NULL, 0, "ESI");
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http))
VDP_push(req, VDP_gunzip, NULL, 1, "GUZ");
if (cache_param->http_range_support &&
http_IsStatus(req->resp, 200)) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (sendbody && http_GetHdr(req->http, H_Range, &r))
VRG_dorange(req, r);
}
}
if (sendbody < 0) {
/* Don't touch pass+HEAD C-L */
sendbody = 0;
} else if (clval >= 0 && clval == req->resp_len) {
/* Reuse C-L header */
} else {
http_Unset(req->resp, H_Content_Length);
if (req->resp_len >= 0 && sendbody)
http_PrintfHeader(req->resp,
"Content-Length: %jd", req->resp_len);
}
req->transport->deliver(req, boc, sendbody);
VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
if (req->objcore->flags & (OC_F_PRIVATE | OC_F_PASS)) {
if (boc != NULL) {
HSH_Abandon(req->objcore);
ObjWaitState(req->objcore, BOS_FINISHED);
}
ObjSlim(wrk, req->objcore);
}
if (boc != NULL)
HSH_DerefBoc(wrk, req->objcore);
(void)HSH_DerefObjCore(wrk, &req->objcore);
http_Teardown(req->resp);
return (REQ_FSM_DONE);
}
h2_deliver(struct req *req, struct boc *boc, int sendbody)
{
ssize_t sz, sz1;
uint8_t *p;
unsigned u;
const char *r;
struct http *hp;
struct sess *sp;
struct h2_req *r2;
int i, err;
const struct hpack_static *hps;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_ORNULL(boc, BOC_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
CAST_OBJ_NOTNULL(r2, req->transport_priv, H2_REQ_MAGIC);
sp = req->sp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
(void)sendbody;
VSLb(req->vsl, SLT_Debug, "H2: Deliver");
(void)WS_Reserve(req->ws, 0);
p = (void*)req->ws->f;
switch (req->resp->status) {
case 200: *p++ = 0x80 | 8; break;
case 204: *p++ = 0x80 | 9; break;
case 206: *p++ = 0x80 | 10; break;
case 304: *p++ = 0x80 | 11; break;
case 400: *p++ = 0x80 | 12; break;
case 404: *p++ = 0x80 | 13; break;
case 500: *p++ = 0x80 | 14; break;
default:
*p++ = 0x18;
*p++ = 0x03;
(void)sprintf((char*)p, "%03d", req->resp->status);
p += 3;
break;
}
hp = req->resp;
for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
assert((char*)p < req->ws->e);
r = strchr(hp->hd[u].b, ':');
AN(r);
hps = hp_idx[tolower(*hp->hd[u].b)];
sz = 1 + r - hp->hd[u].b;
assert(sz > 0);
while (hps != NULL && hps->idx > 0) {
i = strncasecmp(hps->name, hp->hd[u].b, sz);
if (i < 0) {
hps++;
continue;
}
if (i > 0)
hps = NULL;
break;
}
if (hps != NULL) {
VSLb(req->vsl, SLT_Debug,
"HP {%d, \"%s\", \"%s\"} <%s>",
hps->idx, hps->name, hps->val, hp->hd[u].b);
if (hps->idx < 15) {
*p++ = 0x10 | hps->idx;
} else {
*p++ = 0x1f;
*p++ = hps->idx - 0x0f;
}
} else {
*p++ = 0x10;
sz--;
if (sz < 127) {
*p++ = (uint8_t)sz;
} else {
*p++ = 0x7f;
*p++ = (uint8_t)sz - 0x7f;
}
for(sz1 = 0; sz1 < sz; sz1++)
*p++ = (uint8_t)tolower(hp->hd[u].b[sz1]);
}
while(vct_islws(*++r))
continue;
sz = hp->hd[u].e - r;
assert(sz <= 254);
if (sz < 127) {
*p++ = (uint8_t)sz;
} else if (sz < 127 * 2) {
*p++ = 0x7f;
*p++ = (uint8_t)sz - 0x7f;
}
memcpy(p, r, sz);
p += sz;
assert((char*)p < req->ws->e);
}
sz = (char*)p - req->ws->f;
/* XXX: Optimize !sendbody case */
H2_Send(req->wrk, r2, 1, H2_FRAME_HEADERS, H2FF_HEADERS_END_HEADERS,
sz, req->ws->f);
WS_Release(req->ws, 0);
if (sendbody && req->resp_len != 0)
VDP_push(req, h2_bytes, NULL, 1, "H2");
AZ(req->wrk->v1l);
if (sendbody && req->resp_len != 0)
err = VDP_DeliverObj(req);
/*XXX*/(void)err;
H2_Send(req->wrk, r2, 1, H2_FRAME_DATA, H2FF_DATA_END_STREAM, 0, NULL);
AZ(req->wrk->v1l);
VDP_close(req);
}
void
V1D_Deliver(struct req *req, struct busyobj *bo)
{
const char *r;
enum objiter_status ois;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
req->res_mode = 0;
/*
* Determine ESI status first. Not dependent on wantbody, because
* we want ESI to supress C-L in HEAD too.
*/
if (!req->disable_esi &&
ObjGetattr(req->wrk, req->objcore, OA_ESIDATA, NULL) != NULL)
req->res_mode |= RES_ESI;
/*
* ESI-childen don't care about headers -> early escape
*/
if (req->esi_level > 0) {
ESI_DeliverChild(req, bo);
return;
}
if (req->res_mode & RES_ESI) {
RFC2616_Weaken_Etag(req->resp);
} else if (http_IsStatus(req->resp, 304)) {
http_Unset(req->resp, H_Content_Length);
req->wantbody = 0;
} else if (bo == NULL &&
!http_GetHdr(req->resp, H_Content_Length, NULL)) {
http_PrintfHeader(req->resp,
"Content-Length: %ju", (uintmax_t)ObjGetLen(
req->wrk, req->objcore));
}
if (cache_param->http_gzip_support &&
ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED) &&
!RFC2616_Req_Gzip(req->http)) {
/*
* We don't know what it uncompresses to
* XXX: we could cache that, but would still deliver
* XXX: with multiple writes because of the gunzip buffer
*/
req->res_mode |= RES_GUNZIP;
VDP_push(req, VDP_gunzip, NULL, 0);
}
if (req->res_mode & RES_ESI) {
/* Gunzip could have added back a C-L */
http_Unset(req->resp, H_Content_Length);
}
/*
* Range comes after the others and pushes on bottom because it
* can generate a correct C-L header.
*/
if (cache_param->http_range_support && http_IsStatus(req->resp, 200)) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (req->wantbody && http_GetHdr(req->http, H_Range, &r))
VRG_dorange(req, bo, r);
}
if (http_GetHdr(req->resp, H_Content_Length, NULL))
req->res_mode |= RES_LEN;
if (req->wantbody && !(req->res_mode & RES_LEN)) {
if (req->http->protover >= 11) {
req->res_mode |= RES_CHUNKED;
http_SetHeader(req->resp, "Transfer-Encoding: chunked");
} else {
req->res_mode |= RES_EOF;
req->doclose = SC_TX_EOF;
}
}
VSLb(req->vsl, SLT_Debug, "RES_MODE %x", req->res_mode);
if (req->doclose) {
if (!http_HdrIs(req->resp, H_Connection, "close")) {
http_Unset(req->resp, H_Connection);
http_SetHeader(req->resp, "Connection: close");
}
} else if (!http_GetHdr(req->resp, H_Connection, NULL))
http_SetHeader(req->resp, "Connection: keep-alive");
VDP_push(req, v1d_bytes, NULL, 1);
V1L_Reserve(req->wrk, req->ws, &req->sp->fd, req->vsl, req->t_prev);
req->acct.resp_hdrbytes += HTTP1_Write(req->wrk, req->resp, HTTP1_Resp);
if (DO_DEBUG(DBG_FLUSH_HEAD))
(void)V1L_Flush(req->wrk);
ois = OIS_DONE;
if (req->wantbody) {
if (req->res_mode & RES_CHUNKED)
V1L_Chunked(req->wrk);
ois = VDP_DeliverObj(req);
(void)VDP_bytes(req, VDP_FLUSH, NULL, 0);
if (ois == OIS_DONE && (req->res_mode & RES_CHUNKED))
V1L_EndChunk(req->wrk);
}
if ((V1L_FlushRelease(req->wrk) || ois != OIS_DONE) && req->sp->fd >= 0)
SES_Close(req->sp, SC_REM_CLOSE);
VDP_close(req);
}
static void
v1d_dorange(struct req *req, const char *r)
{
ssize_t low, high, has_low;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
assert(req->obj->response == 200);
if (strncmp(r, "bytes=", 6))
return;
r += 6;
/* The low end of range */
has_low = low = 0;
if (!vct_isdigit(*r) && *r != '-')
return;
while (vct_isdigit(*r)) {
has_low = 1;
low *= 10;
low += *r - '0';
r++;
}
if (low >= req->obj->len)
return;
if (*r != '-')
return;
r++;
/* The high end of range */
if (vct_isdigit(*r)) {
high = 0;
while (vct_isdigit(*r)) {
high *= 10;
high += *r - '0';
r++;
}
if (!has_low) {
low = req->obj->len - high;
if (low < 0)
low = 0;
high = req->obj->len - 1;
}
} else
high = req->obj->len - 1;
if (*r != '\0')
return;
if (high >= req->obj->len)
high = req->obj->len - 1;
if (low > high)
return;
http_PrintfHeader(req->resp, "Content-Range: bytes %jd-%jd/%jd",
(intmax_t)low, (intmax_t)high, (intmax_t)req->obj->len);
http_Unset(req->resp, H_Content_Length);
if (req->res_mode & RES_LEN)
http_PrintfHeader(req->resp, "Content-Length: %jd",
(intmax_t)(1 + high - low));
http_SetResp(req->resp, "HTTP/1.1", 206, "Partial Content");
req->range_off = 0;
req->range_low = low;
req->range_high = high + 1;
VDP_push(req, v1d_range_bytes);
}
void
V1D_Deliver(struct req *req)
{
char *r;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
CHECK_OBJ_NOTNULL(req->obj, OBJECT_MAGIC);
CHECK_OBJ_NOTNULL(req->obj->objcore, OBJCORE_MAGIC);
req->res_mode = 0;
if (!req->disable_esi && req->obj->esidata != NULL) {
/* In ESI mode, we can't know the aggregate length */
req->res_mode &= ~RES_LEN;
req->res_mode |= RES_ESI;
} else if (req->resp->status == 304) {
req->res_mode &= ~RES_LEN;
http_Unset(req->resp, H_Content_Length);
req->wantbody = 0;
} else if (req->obj->objcore->busyobj == NULL) {
/* XXX: Not happy with this convoluted test */
req->res_mode |= RES_LEN;
if (!(req->obj->objcore->flags & OC_F_PASS) ||
req->obj->len != 0) {
http_Unset(req->resp, H_Content_Length);
http_PrintfHeader(req->resp,
"Content-Length: %zd", req->obj->len);
}
}
if (req->esi_level > 0) {
/* Included ESI object, always CHUNKED or EOF */
req->res_mode &= ~RES_LEN;
req->res_mode |= RES_ESI_CHILD;
}
if (cache_param->http_gzip_support && req->obj->gziped &&
!RFC2616_Req_Gzip(req->http)) {
/*
* We don't know what it uncompresses to
* XXX: we could cache that, but would still deliver
* XXX: with multiple writes because of the gunzip buffer
*/
req->res_mode &= ~RES_LEN;
req->res_mode |= RES_GUNZIP;
}
if (!(req->res_mode & (RES_LEN|RES_CHUNKED|RES_EOF))) {
/* We havn't chosen yet, do so */
if (!req->wantbody) {
/* Nothing */
} else if (req->http->protover >= 11) {
req->res_mode |= RES_CHUNKED;
} else {
req->res_mode |= RES_EOF;
req->doclose = SC_TX_EOF;
}
}
VSLb(req->vsl, SLT_Debug, "RES_MODE %x", req->res_mode);
if (!(req->res_mode & RES_LEN))
http_Unset(req->resp, H_Content_Length);
if (req->res_mode & RES_GUNZIP)
http_Unset(req->resp, H_Content_Encoding);
if (req->res_mode & RES_CHUNKED)
http_SetHeader(req->resp, "Transfer-Encoding: chunked");
http_SetHeader(req->resp,
req->doclose ? "Connection: close" : "Connection: keep-alive");
req->vdps[0] = v1d_bytes;
req->vdp_nxt = 0;
if (
req->wantbody &&
!(req->res_mode & (RES_ESI|RES_ESI_CHILD)) &&
cache_param->http_range_support &&
req->obj->response == 200) {
http_SetHeader(req->resp, "Accept-Ranges: bytes");
if (http_GetHdr(req->http, H_Range, &r))
v1d_dorange(req, r);
}
if (req->res_mode & RES_ESI)
RFC2616_Weaken_Etag(req->resp);
WRW_Reserve(req->wrk, &req->sp->fd, req->vsl, req->t_resp);
/*
* Send HTTP protocol header, unless interior ESI object
*/
if (!(req->res_mode & RES_ESI_CHILD))
req->acct_req.hdrbytes += HTTP1_Write(req->wrk, req->resp, 1);
if (req->res_mode & RES_CHUNKED)
WRW_Chunked(req->wrk);
if (!req->wantbody) {
/* This was a HEAD or conditional request */
} else if (req->res_mode & RES_ESI) {
AZ(req->obj->objcore->busyobj);
ESI_Deliver(req);
} else if (req->res_mode & RES_ESI_CHILD && req->gzip_resp) {
while (req->obj->objcore->busyobj)
(void)usleep(10000);
ESI_DeliverChild(req);
} else if (req->res_mode & RES_GUNZIP ||
(req->res_mode & RES_ESI_CHILD &&
!req->gzip_resp && req->obj->gziped)) {
VDP_push(req, VDP_gunzip);
req->vgz = VGZ_NewUngzip(req->vsl, "U D -");
AZ(VGZ_WrwInit(req->vgz));
v1d_WriteDirObj(req);
(void)VGZ_Destroy(&req->vgz);
VDP_pop(req, VDP_gunzip);
} else {
v1d_WriteDirObj(req);
}
if (req->res_mode & RES_CHUNKED && !(req->res_mode & RES_ESI_CHILD))
WRW_EndChunk(req->wrk);
if (WRW_FlushRelease(req->wrk) && req->sp->fd >= 0)
SES_Close(req->sp, SC_REM_CLOSE);
}
