diff --git a/bin/varnishtest/tests/m00060.vtc b/bin/varnishtest/tests/m00060.vtc new file mode 100644 index 0000000000..072fadfbe9 --- /dev/null +++ b/bin/varnishtest/tests/m00060.vtc @@ -0,0 +1,39 @@ +varnishtest "VMOD debug reembarking transport" + +server s1 { + rxreq + txresp -bodylen 131072 +} -start + +varnish v1 \ + -vcl+backend { + import debug; + + sub vcl_hash { + hash_data(""); + return (lookup); + } + + sub vcl_deliver { + if (req.url == "/chunked") { + set resp.filters = "debug.chunked"; + } + debug.use_reembarking_http1(); + } +} -start + +varnish v1 -cliok "param.set debug +syncvsl" +varnish v1 -cliok "param.set debug +req_state" + +client c1 -repeat 16 -keepalive { + txreq + rxresp +} -start + +client c2 -repeat 16 -keepalive { + txreq -url "/chunked" + rxresp +} -start + +client c1 -wait +client c2 -wait diff --git a/vmod/automake_boilerplate_debug.am b/vmod/automake_boilerplate_debug.am index 51e632f663..2a70c5e8f7 100644 --- a/vmod/automake_boilerplate_debug.am +++ b/vmod/automake_boilerplate_debug.am @@ -12,7 +12,8 @@ libvmod_debug_la_SOURCES = \ vmod_debug_acl.c \ vmod_debug_dyn.c \ vmod_debug_filters.c \ - vmod_debug_obj.c + vmod_debug_obj.c \ + vmod_debug_transports.c libvmod_debug_la_CFLAGS = diff --git a/vmod/vmod_debug.c b/vmod/vmod_debug.c index 7e399f7b70..a5a097163f 100644 --- a/vmod/vmod_debug.c +++ b/vmod/vmod_debug.c @@ -332,6 +332,7 @@ event_load(VRT_CTX, struct vmod_priv *priv) priv->methods = priv_vcl_methods; debug_add_filters(ctx); + debug_transport_init(); return (0); } @@ -1281,3 +1282,9 @@ xyzzy_resolve_range(VRT_CTX, struct VARGS(resolve_range) *args) *(p.errp)); return (WS_VSB_finish(p.vsb, ctx->ws, NULL)); } + +VCL_VOID +xyzzy_use_reembarking_http1(VRT_CTX) +{ + debug_transport_use_reembarking_http1(ctx); +} diff --git a/vmod/vmod_debug.h b/vmod/vmod_debug.h index 05093be076..ddff80dc83 100644 --- a/vmod/vmod_debug.h +++ b/vmod/vmod_debug.h @@ -33,3 +33,9 @@ void debug_add_filters(VRT_CTX); void debug_remove_filters(VRT_CTX); + +/* vmod_debug_transports.c */ +void +debug_transport_use_reembarking_http1(VRT_CTX); +void +debug_transport_init(void); diff --git a/vmod/vmod_debug.vcc b/vmod/vmod_debug.vcc index 8e9a25c3ed..3d791a6c8f 100644 --- a/vmod/vmod_debug.vcc +++ b/vmod/vmod_debug.vcc @@ -440,6 +440,13 @@ be hanged to zero. Any larger value will be taken modulo UINT32_MAX. The *mode* argument behaves as for `debug.chksha256()`_. +$Function VOID use_reembarking_http1() + +$Restrict vcl_deliver + +Switch to the reembarking http1 debug transport. Calling it from any other +transport than http1 results in VCL failure. + DEPRECATED ========== diff --git a/vmod/vmod_debug_transports.c b/vmod/vmod_debug_transports.c new file mode 100644 index 0000000000..696ae5295c --- /dev/null +++ b/vmod/vmod_debug_transports.c @@ -0,0 +1,217 @@ +/*- + * Copyright (c) 2006 Verdens Gang AS + * Copyright (c) 2006-2015 Varnish Software AS + * Copyright 2024 UPLEX - Nils Goroll Systemoptimierung + * All rights reserved. + * + * Authors: Poul-Henning Kamp + * Nils Goroll + * + * SPDX-License-Identifier: BSD-2-Clause + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include "config.h" + +#include "cache/cache_varnishd.h" + +#include "cache/cache_filter.h" +#include "cache/cache_transport.h" +#include "http1/cache_http1.h" + +#include "vmod_debug.h" + +static void +dbg_error(struct req *req, const char *msg) +{ + + (void)req; + (void)msg; + INCOMPL(); +} + +static void dbg_deliver_finish(struct req *req, int err); +static void dbg_sendbody(struct worker *wrk, void *arg); + +static task_func_t *hack_http1_req = NULL; + +// copied from cache_http_deliver.c, then split & modified +static enum vtr_deliver_e v_matchproto_(vtr_deliver_f) +dbg_deliver(struct req *req, int sendbody) +{ + struct vrt_ctx ctx[1]; + + CHECK_OBJ_NOTNULL(req, REQ_MAGIC); + CHECK_OBJ_ORNULL(req->boc, BOC_MAGIC); + CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC); + + if (req->doclose == SC_NULL && + http_HdrIs(req->resp, H_Connection, "close")) { + req->doclose = SC_RESP_CLOSE; + } else if (req->doclose != SC_NULL) { + 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) { + if (!http_GetHdr(req->resp, H_Content_Length, NULL)) { + if (req->http->protover == 11) { + http_SetHeader(req->resp, + "Transfer-Encoding: chunked"); + } else { + req->doclose = SC_TX_EOF; + } + } + INIT_OBJ(ctx, VRT_CTX_MAGIC); + VCL_Req2Ctx(ctx, req); + if (VDP_Push(ctx, req->vdc, req->ws, VDP_v1l, NULL)) { + dbg_error(req, "Failure to push v1d processor"); + return (VTR_D_DONE); + } + } + + if (WS_Overflowed(req->ws)) { + dbg_error(req, "workspace_client overflow"); + return (VTR_D_DONE); + } + + if (WS_Overflowed(req->sp->ws)) { + dbg_error(req, "workspace_session overflow"); + return (VTR_D_DONE); + } + + V1L_Open(req->wrk, req->wrk->aws, &req->sp->fd, req->vsl, + req->t_prev + SESS_TMO(req->sp, send_timeout), + cache_param->http1_iovs); + + if (WS_Overflowed(req->wrk->aws)) { + dbg_error(req, "workspace_thread overflow"); + return (VTR_D_DONE); + } + + req->acct.resp_hdrbytes += HTTP1_Write(req->wrk, req->resp, HTTP1_Resp); + + if (! sendbody) { + dbg_deliver_finish(req, 0); + return (VTR_D_DONE); + } + + (void)V1L_Flush(req->wrk); + + if (hack_http1_req == NULL) + hack_http1_req = req->task->func; + AN(hack_http1_req); + + VSLb(req->vsl, SLT_Debug, "w=%p scheduling dbg_sendbody", req->wrk); + + req->task->func = dbg_sendbody; + req->task->priv = req; + + req->transport_priv = req->wrk->v1l; + req->wrk->v1l = NULL; + req->wrk = NULL; + req->vdc->wrk = NULL; + + AZ(Pool_Task(req->sp->pool, req->task, TASK_QUEUE_RUSH)); + return (VTR_D_DISEMBARK); +} + +static void v_matchproto_(task_func_t) +dbg_sendbody(struct worker *wrk, void *arg) +{ + struct req *req; + const char *p; + int err, chunked; + + CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC); + CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC); + + THR_SetRequest(req); + VSLb(req->vsl, SLT_Debug, "w=%p enter dbg_sendbody", wrk); + AZ(req->wrk); + AZ(wrk->v1l); + CNT_Embark(wrk, req); + req->vdc->wrk = wrk; // move to CNT_Embark? + wrk->v1l = req->transport_priv; + req->transport_priv = NULL; + AN(wrk->v1l); + + chunked = http_GetHdr(req->resp, H_Transfer_Encoding, &p) && strcmp(p, "chunked") == 0; + if (chunked) + V1L_Chunked(req->wrk); + err = VDP_DeliverObj(req->vdc, req->objcore); + if (!err && chunked) + V1L_EndChunk(req->wrk); + dbg_deliver_finish(req, err); + + VSLb(req->vsl, SLT_Debug, "w=%p resuming http1_req", wrk); + wrk->task->func = hack_http1_req; + wrk->task->priv = req; +} + +static void +dbg_deliver_finish(struct req *req, int err) +{ + stream_close_t sc; + uint64_t bytes; + + sc = V1L_Close(req->wrk, &bytes); + AZ(req->wrk->v1l); + + req->acct.resp_bodybytes += VDP_Close(req->vdc, req->objcore, req->boc); + + if (sc == SC_NULL && err && req->sp->fd >= 0) + sc = SC_REM_CLOSE; + if (sc != SC_NULL) + Req_Fail(req, sc); +} + +struct transport DBG_transport; + +void +debug_transport_init(void) +{ + DBG_transport = HTTP1_transport; + DBG_transport.name = "DBG"; + DBG_transport.deliver = dbg_deliver; +} + +void +debug_transport_use_reembarking_http1(VRT_CTX) +{ + struct req *req; + + CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); + req = ctx->req; + CHECK_OBJ_NOTNULL(req, REQ_MAGIC); + + if (req->transport != &HTTP1_transport) { + VRT_fail(ctx, "Only works on built-in http1 transport"); + return; + } + AZ(req->transport_priv); + req->transport = &DBG_transport; +}