GCOV - Varnish Cache


/*-
 * Copyright (c) 2012-2019 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
 *
 * 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

#include "cache/cache_varnishd.h"
#include "cache/cache_filter.h"

#include "vsa.h"
#include "vss.h"
#include "vtcp.h"
#include "vtim.h"
#include "vcc_debug_if.h"
#include "VSC_debug.h"

#include "vmod_debug.h"

struct priv_vcl {
        unsigned                magic;
#define PRIV_VCL_MAGIC          0x8E62FA9D
        char                    *foo;
        uintptr_t               obj_cb;
        struct vclref           *vclref_discard;
        struct vclref           *vclref_cold;
        VCL_DURATION            vcl_discard_delay;
        VCL_BACKEND             be;
        unsigned                cold_be;
        unsigned                cooling_be;
        int                     tmpf;
};


static pthread_mutex_t vsc_mtx = PTHREAD_MUTEX_INITIALIZER;
static struct vsc_seg *vsc_seg = NULL;
static struct VSC_debug *vsc = NULL;
static int loads;
static const int store_ip_token = 0;
static const int fail_task_fini_token = 0;
extern void mylog(struct vsl_log *vsl, enum VSL_tag_e tag,
    const char *fmt, ...) v_printflike_(3,4);

/**********************************************************************/

VCL_STRING v_matchproto_(td_debug_author)
xyzzy_author(VRT_CTX, VCL_ENUM person, VCL_ENUM someone)
{
        (void)someone;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (person == VENUM(phk))
                return ("Poul-Henning");
        assert(strcmp(person, "phk"));
        if (person == VENUM(des))
                return ("Dag-Erling");
        assert(strcmp(person, "des"));
        if (person == VENUM(kristian))
                return ("Kristian");
        assert(strcmp(person, "kristian"));
        if (person == VENUM(mithrandir))
                return ("Tollef");
        assert(strcmp(person, "mithrandir"));
        WRONG("Illegal VMOD enum");
}

#define AN0(x) (void) 0
#define AN1(x) AN(x)
#define PRIV_FINI(name, assert)                                         \
static void v_matchproto_(vmod_priv_fini_f)                             \
priv_ ## name ## _fini(VRT_CTX, void *ptr)                              \
{                                                                       \
        const char * const fmt = "priv_" #name "_fini(%p)";             \
                                                                        \
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);                          \
        AN ## assert (ptr);                                             \
        mylog(ctx->vsl, SLT_Debug, fmt, (char *)ptr);                   \
        free(ptr);                                                      \
}                                                                       \
                                                                        \
static const struct vmod_priv_methods                                   \
xyzzy_test_priv_ ## name ## _methods[1] = {{                            \
        .magic = VMOD_PRIV_METHODS_MAGIC,                               \
        .type = "debug_test_priv_" #name,                               \
        .fini = priv_ ## name ## _fini                                  \
}};
PRIV_FINI(call, 0)
PRIV_FINI(task, 1)
PRIV_FINI(top, 1)
#undef PRIV_FINI
#undef AN0
#undef AN1

VCL_VOID v_matchproto_(td_debug_test_priv_call)
xyzzy_test_priv_call(VRT_CTX, struct vmod_priv *priv)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (priv->priv == NULL) {
                priv->priv = strdup("BAR");
                priv->methods = xyzzy_test_priv_call_methods;
        } else {
                assert(priv->methods == xyzzy_test_priv_call_methods);
                assert(!strcmp(priv->priv, "BAR"));
        }
}

VCL_VOID v_matchproto_(td_debug_test_priv_task_get)
xyzzy_test_priv_task_get(VRT_CTX)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AZ(VRT_priv_task_get(ctx, NULL));
}

VCL_STRING v_matchproto_(td_debug_test_priv_task)
xyzzy_test_priv_task(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (s == NULL || *s == '\0') {
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (exists)",
                    priv, priv->priv);
        } else if (priv->priv == NULL) {
                priv->priv = strdup(s);
                priv->methods = xyzzy_test_priv_task_methods;
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (new)",
                    priv, priv->priv);
        } else {
                char *n = realloc(priv->priv,
                    strlen(priv->priv) + strlen(s) + 2);
                if (n == NULL)
                        return (NULL);
                strcat(n, " ");
                strcat(n, s);
                priv->priv = n;
                mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (update)",
                    priv, priv->priv);
        }
        if (priv->priv != NULL)
                assert(priv->methods == xyzzy_test_priv_task_methods);
        return (priv->priv);
}

VCL_STRING v_matchproto_(td_debug_test_priv_top)
xyzzy_test_priv_top(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (priv->priv == NULL) {
                priv->priv = strdup(s);
                priv->methods = xyzzy_test_priv_top_methods;
        } else {
                assert(priv->methods == xyzzy_test_priv_top_methods);
        }
        return (priv->priv);
}

VCL_VOID v_matchproto_(td_debug_test_priv_vcl)
xyzzy_test_priv_vcl(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;
        char t[PATH_MAX];
        ssize_t l;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(priv);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);

        l = pread(priv_vcl->tmpf, t, sizeof t, 0);
        assert(l > 0);

        AN(priv_vcl->foo);
        assert(!strncmp(priv_vcl->foo, t, l));
}

VCL_VOID v_matchproto_(td_debug_rot52)
xyzzy_rot52(VRT_CTX, VCL_HTTP hp)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        http_PrintfHeader(hp, "Encrypted: ROT52");
}

VCL_STRING v_matchproto_(td_debug_argtest)
xyzzy_argtest(VRT_CTX, struct VARGS(argtest) *arg)
{
        char buf[100];

        AN(arg);
        bprintf(buf, "%s %g %s %s %jd %d %s",
            arg->one, arg->two, arg->three, arg->comma, (intmax_t)arg->four,
            arg->valid_string, arg->valid_string ? arg->string : "<undef>");
        return (WS_Copy(ctx->ws, buf, -1));
}

VCL_INT v_matchproto_(td_debug_vre_limit)
xyzzy_vre_limit(VRT_CTX)
{
        (void)ctx;
        return (cache_param->vre_limits.match);
}

static void v_matchproto_(obj_event_f)
obj_cb(struct worker *wrk, void *priv, struct objcore *oc, unsigned event)
{
        const struct priv_vcl *priv_vcl;
        const char *what;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
        switch (event) {
        case OEV_INSERT: what = "insert"; break;
        case OEV_EXPIRE: what = "expire"; break;
        default: WRONG("Wrong object event");
        }

        /* We cannot trust %p to be 0x... format as expected by m00021.vtc */
        VSL(SLT_Debug, NO_VXID, "Object Event: %s 0x%jx", what,
            (intmax_t)(uintptr_t)oc);
}

VCL_VOID v_matchproto_(td_debug_register_obj_events)
xyzzy_register_obj_events(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        AZ(priv_vcl->obj_cb);
        priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl,
                OEV_INSERT|OEV_EXPIRE);
        VSL(SLT_Debug, NO_VXID, "Subscribed to Object Events");
}

VCL_VOID v_matchproto_(td_debug_fail)
xyzzy_fail(VRT_CTX)
{

        VRT_fail(ctx, "Forced failure");
}

VCL_BOOL v_matchproto_(td_debug_fail2)
xyzzy_fail2(VRT_CTX)
{

        VRT_fail(ctx, "Forced failure");
        return (1);
}

static void v_matchproto_(vmod_priv_fini_f)
priv_vcl_fini(VRT_CTX, void *priv)
{
        struct priv_vcl *priv_vcl;

        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
        AZ(close(priv_vcl->tmpf));
        AN(priv_vcl->foo);
        AZ(unlink(priv_vcl->foo));
        free(priv_vcl->foo);
        if (priv_vcl->obj_cb != 0) {
                ObjUnsubscribeEvents(&priv_vcl->obj_cb);
                VSLb(ctx->vsl, SLT_Debug, "Unsubscribed from Object Events");
        }
        AZ(priv_vcl->vclref_discard);
        AZ(priv_vcl->vclref_cold);
        FREE_OBJ(priv_vcl);
}

static const struct vmod_priv_methods priv_vcl_methods[1] = {{
        .magic = VMOD_PRIV_METHODS_MAGIC,
        .type = "debug_priv_vcl_fini",
        .fini = priv_vcl_fini
}};

static int
event_load(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;

        AN(ctx->msg);

        loads++;

        if (cache_param->nuke_limit == 42) {
                VSB_cat(ctx->msg, "nuke_limit is not the answer.");
                return (-1);
        }

        ALLOC_OBJ(priv_vcl, PRIV_VCL_MAGIC);
        AN(priv_vcl);
        priv_vcl->foo = strdup("worker_tmpdir/vmod_debug.XXXXXX");
        AN(priv_vcl->foo);
        priv_vcl->tmpf = mkstemp(priv_vcl->foo);
        assert(priv_vcl->tmpf >= 0);
        AN(write(priv_vcl->tmpf, priv_vcl->foo, strlen(priv_vcl->foo)));
        priv->priv = priv_vcl;
        priv->methods = priv_vcl_methods;

        debug_add_filters(ctx);
        debug_transport_reembarking_http1_init();
        debug_transport_vai_init();
        return (0);
}

VCL_VOID
xyzzy_vcl_prevent_cold(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;
        char buf[32];

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(priv);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        AZ(priv_vcl->vclref_cold);

        bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
        priv_vcl->vclref_cold = VRT_VCL_Prevent_Cold(ctx, buf);
}

VCL_VOID
xyzzy_vcl_allow_cold(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(priv);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        AN(priv_vcl->vclref_cold);
        VRT_VCL_Allow_Cold(&priv_vcl->vclref_cold);
}

VCL_VOID
xyzzy_cold_backend(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(priv);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        priv_vcl->cold_be = 1;
}

VCL_VOID
xyzzy_cooling_backend(VRT_CTX, struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(priv);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        priv_vcl->cooling_be = 1;
}

static const struct vdi_methods empty_methods[1] = {{
        .magic =        VDI_METHODS_MAGIC,
        .type = "debug.dummy"
}};

static int
event_warm(VRT_CTX, const struct vmod_priv *priv)
{
        struct priv_vcl *priv_vcl;
        char buf[32];
        const char *vcl_name = VCL_Name(ctx->vcl);

        // Using VSLs for coverage
        VSLs(SLT_Debug, NO_VXID, TOSTRANDS(2, vcl_name, ": VCL_EVENT_WARM"));

        AN(ctx->msg);
        if (cache_param->max_esi_depth == 42) {
                VSB_cat(ctx->msg, "max_esi_depth is not the answer.");
                return (-1);
        }

        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        AZ(priv_vcl->vclref_discard);

        if (!priv_vcl->cold_be) {
                /* NB: set up a COOLING step unless we want a COLD backend. */
                bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
                priv_vcl->vclref_discard = VRT_VCL_Prevent_Discard(ctx, buf);
        }

        AZ(priv_vcl->be);
        priv_vcl->be = VRT_AddDirector(ctx, empty_methods,
            NULL, "%s", "dir_warmcold");

        return (0);
}

static void*
cooldown_thread(void *priv)
{
        struct priv_vcl *priv_vcl;

        CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
        AN(priv_vcl->vclref_discard);

        VTIM_sleep(priv_vcl->vcl_discard_delay);
        VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
        return (NULL);
}

static VCL_BACKEND
create_cold_backend(VRT_CTX)
{
        struct vrt_endpoint vep[1];
        struct vrt_backend be[1];

        INIT_OBJ(vep, VRT_ENDPOINT_MAGIC);
        vep->uds_path = "/";
        INIT_OBJ(be, VRT_BACKEND_MAGIC);
        be->endpoint = vep;
        be->vcl_name = "doomed";
        return (VRT_new_backend(ctx, be, NULL));
}

static int
event_cold(VRT_CTX, const struct vmod_priv *priv)
{
        pthread_t thread;
        struct priv_vcl *priv_vcl;

        AZ(ctx->msg);

        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);

        VSL(SLT_Debug, NO_VXID, "%s: VCL_EVENT_COLD", VCL_Name(ctx->vcl));

        VRT_DelDirector(&priv_vcl->be);

        if (priv_vcl->cold_be) {
                AZ(priv_vcl->vclref_discard);
                priv_vcl->be = create_cold_backend(ctx);
                WRONG("unreachable");
        }

        if (priv_vcl->cooling_be) {
                AN(priv_vcl->vclref_discard);
                priv_vcl->be = create_cold_backend(ctx);
                AZ(priv_vcl->be);
        }

        if (priv_vcl->vcl_discard_delay == 0.0) {
                AN(priv_vcl->vclref_discard);
                VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
                return (0);
        }

        PTOK(pthread_create(&thread, NULL, cooldown_thread, priv_vcl));
        PTOK(pthread_detach(thread));
        return (0);
}

static int
event_discard(VRT_CTX, void *priv)
{

        (void)priv;

        AZ(ctx->msg);

        debug_remove_filters(ctx);

        if (--loads)
                return (0);

        /*
         * The vsc and vsc_seg variables are not per-VCL, they are
         * the same in all VCL's which import the same binary version
         * of this VMOD, so we should only carry out cleanup on the
         * last discard event.
         */
        PTOK(pthread_mutex_lock(&vsc_mtx));
        if (vsc != NULL) {
                VSC_debug_Destroy(&vsc_seg);
                vsc = NULL;
        }
        PTOK(pthread_mutex_unlock(&vsc_mtx));

        return (0);
}

int v_matchproto_(vmod_event_f)
xyzzy_event_function(VRT_CTX, struct vmod_priv *priv, enum vcl_event_e e)
{

        switch (e) {
        case VCL_EVENT_LOAD:    return (event_load(ctx, priv));
        case VCL_EVENT_WARM:    return (event_warm(ctx, priv));
        case VCL_EVENT_COLD:    return (event_cold(ctx, priv));
        case VCL_EVENT_DISCARD: return (event_discard(ctx, priv));
        default: WRONG("we should test all possible events");
        }
}

VCL_VOID v_matchproto_(td_debug_vcl_discard_delay)
xyzzy_vcl_discard_delay(VRT_CTX, struct vmod_priv *priv, VCL_DURATION delay)
{
        struct priv_vcl *priv_vcl;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
        assert(delay > 0.0);
        priv_vcl->vcl_discard_delay = delay;
}

VCL_VOID v_matchproto_(td_debug_test_probe)
xyzzy_test_probe(VRT_CTX, VCL_PROBE probe, VCL_PROBE same)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(probe, VRT_BACKEND_PROBE_MAGIC);
        CHECK_OBJ_ORNULL(same, VRT_BACKEND_PROBE_MAGIC);
        AZ(same == NULL || probe == same);
}

VCL_VOID
xyzzy_vsc_new(VRT_CTX)
{
        (void)ctx;
        PTOK(pthread_mutex_lock(&vsc_mtx));
        if (vsc == NULL) {
                AZ(vsc_seg);
                vsc = VSC_debug_New(NULL, &vsc_seg, "");
        }
        AN(vsc);
        AN(vsc_seg);
        PTOK(pthread_mutex_unlock(&vsc_mtx));
}

VCL_VOID
xyzzy_vsc_count(VRT_CTX, VCL_INT cnt)
{
        (void)ctx;
        PTOK(pthread_mutex_lock(&vsc_mtx));
        AN(vsc);
        vsc->count += cnt;
        PTOK(pthread_mutex_unlock(&vsc_mtx));
}

VCL_VOID
xyzzy_vsc_destroy(VRT_CTX)
{
        (void)ctx;
        PTOK(pthread_mutex_lock(&vsc_mtx));
        if (vsc != NULL) {
                AN(vsc_seg);
                VSC_debug_Destroy(&vsc_seg);
        }
        AZ(vsc_seg);
        vsc = NULL;
        PTOK(pthread_mutex_unlock(&vsc_mtx));
}

struct xyzzy_debug_concat {
        unsigned        magic;
#define CONCAT_MAGIC 0x6b746493
        VCL_STRING      s;
};

VCL_VOID
xyzzy_concat__init(VRT_CTX, struct xyzzy_debug_concat **concatp,
                   const char *vcl_name, VCL_STRANDS s)
{
        struct xyzzy_debug_concat *concat;
        size_t sz = 0;
        char *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(concatp);
        AZ(*concatp);
        AN(vcl_name);

        ALLOC_OBJ(concat, CONCAT_MAGIC);
        AN(concat);
        *concatp = concat;

        for (int i = 0; i < s->n; i++)
                if (s->p[i] != NULL)
                        sz += strlen(s->p[i]);
        p = malloc(sz + 1);
        AN(p);
        (void)VRT_Strands(p, sz + 1, s);
        concat->s = p;
}

VCL_VOID
xyzzy_concat__fini(struct xyzzy_debug_concat **concatp)
{
        struct xyzzy_debug_concat *concat;


        TAKE_OBJ_NOTNULL(concat, concatp, CONCAT_MAGIC);
        free(TRUST_ME(concat->s));
        FREE_OBJ(concat);
}

VCL_STRING
xyzzy_concat_get(VRT_CTX, struct xyzzy_debug_concat *concat)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(concat, CONCAT_MAGIC);
        return (concat->s);
}

VCL_STRING
xyzzy_concatenate(VRT_CTX, VCL_STRANDS s)
{
        VCL_STRING r;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        r = VRT_StrandsWS(ctx->ws, NULL, s);
        if (r != NULL && *r != '\0')
                AN(WS_Allocated(ctx->ws, r, strlen(r) + 1));
        return (r);
}

VCL_STRING
xyzzy_collect(VRT_CTX, VCL_STRANDS s)
{
        VCL_STRING r;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        r = VRT_STRANDS_string(ctx, s);
        if (r != NULL && *r != '\0')
                AN(WS_Allocated(ctx->ws, r, strlen(r) + 1));
        return (r);
}

/* cf. VRT_SetHdr() */
VCL_VOID
xyzzy_sethdr(VRT_CTX, VCL_HEADER hdr, VCL_STRANDS s)
{
        struct http *hp;
        const char *b;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (hdr == NULL) {
                VRT_fail(ctx, "debug.sethdr(): header argument is NULL");
                return;
        }
        hp = VRT_selecthttp(ctx, hdr->where);
        if (hp == NULL) {
                VRT_fail(ctx, "debug.sethdr(): header argument "
                    "cannot be used here");
                return;
        }
        AN(hdr->what);
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
        if (s->n == 0) {
                http_Unset(hp, hdr->what);
        } else {
                b = VRT_StrandsWS(hp->ws, hdr->what->str, s);
                if (b == NULL) {
                        VSLbs(ctx->vsl, SLT_LostHeader,
                            TOSTRAND(hdr->what->str));
                } else {
                        if (*b != '\0')
                                AN(WS_Allocated(hp->ws, b, strlen(b) + 1));
                        http_Unset(hp, hdr->what);
                        http_SetHeader(hp, b);
                }
        }
}

void
mylog(struct vsl_log *vsl, enum VSL_tag_e tag,  const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        if (vsl != NULL)
                VSLbv(vsl, tag, fmt, ap);
        else
                VSLv(tag, NO_VXID, fmt, ap);
        va_end(ap);
}

VCL_DURATION
xyzzy_priv_perf(VRT_CTX, VCL_INT size, VCL_INT rounds)
{
        vtim_mono t0, t1;
        vtim_dur d;
        struct vmod_priv *p;
        VCL_INT s, r;
        uintptr_t check = 0;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        for (s = 1; s <= size; s++) {
                p = VRT_priv_task(ctx, (void *)(uintptr_t)s);
                if (p == NULL) {
                        VRT_fail(ctx, "no priv task - out of ws?");
                        return (-1.0);
                }
                p->priv = NULL;
        }

        t0 = VTIM_mono();
        for (r = 0; r < rounds; r++) {
                for (s = 1; s <= size; s++) {
                        p = VRT_priv_task_get(ctx, (void *)(uintptr_t)s);
                        AN(p);
                        check += (uintptr_t)p->priv;
                        p->priv = (void *)(uintptr_t)(s * rounds + r);
                }
        }
        t1 = VTIM_mono();

        d = (t1 - t0) * 1e9 / ((double)size * (double)rounds);

        mylog(ctx->vsl, SLT_Debug,
             "perf size %jd rounds %jd time %.1fns check %jd",
             (intmax_t)size, (intmax_t)rounds, d, (uintmax_t)check);

        return (d);
}

VCL_STRANDS
xyzzy_return_strands(VRT_CTX, VCL_STRANDS strand)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (ctx->vsl)
                VSLbs(ctx->vsl, SLT_Debug, strand);
        else
                VSLs(SLT_Debug, NO_VXID, strand);
        return (strand);
}

VCL_STRANDS
xyzzy_return_null_strands(VRT_CTX)
{
        (void)ctx;
        return (vrt_null_strands);
}

VCL_BOOL
xyzzy_is_null_strands(VRT_CTX, VCL_STRANDS s)
{
        (void)ctx;
        return (s == vrt_null_strands);
}

VCL_VOID
xyzzy_vsl_flush(VRT_CTX)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        VSL_Flush(ctx->vsl, 0);
}

/*---------------------------------------------------------------------*/

static const struct vcf_return * v_matchproto_(vcf_func_f)
xyzzy_catflap_simple(struct req *req, struct objcore **oc,
    struct objcore **oc_exp, int state)
{

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC);
        assert(req->vcf->func == xyzzy_catflap_simple);

        (void)oc;
        (void)oc_exp;
        if (state == 0) {
                if (req->vcf->priv == VENUM(first))
                        return (VCF_HIT);
                if (req->vcf->priv == VENUM(miss))
                        return (VCF_MISS);
                WRONG("Shouldn't get here");
        }
        return (VCF_DEFAULT);
}

static const struct vcf_return * v_matchproto_(vcf_func_f)
xyzzy_catflap_last(struct req *req, struct objcore **oc,
    struct objcore **oc_exp, int state)
{

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->vcf, VCF_MAGIC);
        assert(req->vcf->func == xyzzy_catflap_last);

        (void)oc_exp;
        if (state == 0) {
                AN(oc);
                CHECK_OBJ_NOTNULL(*oc, OBJCORE_MAGIC);
                req->vcf->priv = *oc;
                return (VCF_CONTINUE);
        }
        if (state == 1) {
                AN(oc);
                if (req->vcf->priv != NULL)
                        CAST_OBJ_NOTNULL(*oc, req->vcf->priv, OBJCORE_MAGIC);
                return (VCF_CONTINUE);
        }
        return (VCF_DEFAULT);
}

VCL_VOID
xyzzy_catflap(VRT_CTX, VCL_ENUM type)
{
        struct req *req;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        req = ctx->req;
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        XXXAZ(req->vcf);
        WS_TASK_ALLOC_OBJ(ctx, req->vcf, VCF_MAGIC);
        if (req->vcf == NULL)
                return;
        if (type == VENUM(first) || type == VENUM(miss)) {
                req->vcf->func = xyzzy_catflap_simple;
                req->vcf->priv = TRUST_ME(type);
        } else if (type == VENUM(last)) {
                req->vcf->func = xyzzy_catflap_last;
        } else {
                WRONG("Wrong VENUM");
        }
}

VCL_BYTES
xyzzy_stk(VRT_CTX)
{
        const VCL_BYTES max = 100 * 1024 * 1024;
        const char *a, *b;
        VCL_BYTES r;

        a = TRUST_ME(&b);
        b = TRUST_ME(ctx->req->wrk);
        b += sizeof(*ctx->req->wrk);

        if (b > a && (r = b - a) < max)
                return (r);
        if (a > b && (r = a - b) < max)
                return (r);

        return (0);
}

VCL_VOID
xyzzy_sndbuf(VRT_CTX, VCL_BYTES arg)
{
        int fd = -1, oldbuf, newbuf, buflen;
        socklen_t intlen = sizeof(int);

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        if (ctx->bo) {
                CHECK_OBJ(ctx->bo, BUSYOBJ_MAGIC);
                INCOMPL();
        }
        else if (ctx->req) {
                CHECK_OBJ(ctx->req, REQ_MAGIC);
                CHECK_OBJ(ctx->req->sp, SESS_MAGIC);
                fd = ctx->req->sp->fd;
        }
        else {
                VRT_fail(ctx, "debug.sndbuf() called outside a transaction.");
                return;
        }

        xxxassert(fd >= 0);

        if (arg > INT_MAX)
                buflen = INT_MAX;
        else if (arg <= 0)
                buflen = 0;
        else
                buflen = (int)arg;

        oldbuf = 0;
        AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &oldbuf, &intlen));

        newbuf = buflen;
        AZ(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, intlen));
        AZ(getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &newbuf, &intlen));

        AN(ctx->vsl);
        VSLb(ctx->vsl, SLT_Debug, "SO_SNDBUF fd=%d old=%d new=%d actual=%d",
            fd, oldbuf, buflen, newbuf);
}

VCL_VOID
xyzzy_store_ip(VRT_CTX, VCL_IP ip)
{
        struct vmod_priv *priv;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        priv = VRT_priv_task(ctx, &store_ip_token);
        if (priv == NULL) {
                VRT_fail(ctx, "no priv task - out of ws?");
                return;
        }

        AZ(priv->methods);
        assert(VSA_Sane(ip));
        priv->priv = TRUST_ME(ip);
}

VCL_IP
xyzzy_get_ip(VRT_CTX)
{
        struct vmod_priv *priv;
        VCL_IP ip;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        priv = VRT_priv_task_get(ctx, &store_ip_token);
        AN(priv);
        AZ(priv->methods);

        ip = priv->priv;
        assert(VSA_Sane(ip));
        return (ip);
}

/*---------------------------------------------------------------------*/

struct VPFX(debug_director) {
        unsigned                        magic;
#define VMOD_DEBUG_DIRECTOR_MAGIC       0x66b9ff3d
        VCL_BACKEND                     dir;
};

/* XXX more callbacks ? */
static vdi_healthy_f vmod_debug_director_healthy;
static vdi_resolve_f vmod_debug_director_resolve;

static const struct vdi_methods vmod_debug_director_methods[1] = {{
        .magic =        VDI_METHODS_MAGIC,
        .type =         "debug.director",
        .resolve =      vmod_debug_director_resolve,
        .healthy =      vmod_debug_director_healthy
}};

VCL_VOID v_matchproto_(td_xyzzy_debug_director__init)
xyzzy_director__init(VRT_CTX, struct VPFX(debug_director) **dp,
    const char *vcl_name)
{
        struct VPFX(debug_director) *d;

        AN(dp);
        AZ(*dp);
        ALLOC_OBJ(d, VMOD_DEBUG_DIRECTOR_MAGIC);
        AN(d);

        *dp = d;
        d->dir = VRT_AddDirector(ctx, vmod_debug_director_methods, d,
            "%s", vcl_name);
}

VCL_VOID v_matchproto_(td_xyzzy_debug_director__fini)
xyzzy_director__fini(struct VPFX(debug_director) **dp)
{
        struct VPFX(debug_director) *d;

        TAKE_OBJ_NOTNULL(d, dp, VMOD_DEBUG_DIRECTOR_MAGIC);
        VRT_DelDirector(&d->dir);
        FREE_OBJ(d);
}

VCL_BACKEND v_matchproto_(td_xyzzy_debug_director_fail)
xyzzy_director_fail(VRT_CTX, struct VPFX(debug_director) *d)
{
        CHECK_OBJ_NOTNULL(d, VMOD_DEBUG_DIRECTOR_MAGIC);
        (void) ctx;

        return (d->dir);
}

static VCL_BOOL v_matchproto_(vdi_healthy_f)
vmod_debug_director_healthy(VRT_CTX, VCL_BACKEND dir, VCL_TIME *changed)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        (void) dir;
        (void) changed;

        VRT_fail(ctx, "fail");
        return (1);
}

static VCL_BACKEND v_matchproto_(vdi_resolve_f)
vmod_debug_director_resolve(VRT_CTX, VCL_BACKEND dir)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        (void) dir;

        VRT_fail(ctx, "fail");
        return (NULL);
}

VCL_STRING v_matchproto_(td_xyzzy_debug_client_ip)
xyzzy_client_ip(VRT_CTX)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_IP));
}

VCL_STRING v_matchproto_(td_xyzzy_debug_client_port)
xyzzy_client_port(VRT_CTX)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        return (SES_Get_String_Attr(ctx->sp, SA_CLIENT_PORT));
}

static void * fail_magic = &fail_magic;

static void
fail_f(VRT_CTX, void *priv)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        assert(priv == fail_magic);

        VRT_fail(ctx, "thou shalt not fini");
}

static const struct vmod_priv_methods xyzzy_fail_task_fini_methods[1] = {{
        .magic = VMOD_PRIV_METHODS_MAGIC,
        .type = "debug_fail_task_fini",
        .fini = fail_f
}};

VCL_VOID v_matchproto_(td_xyzzy_debug_fail_task_fini)
xyzzy_fail_task_fini(VRT_CTX)
{
        struct vmod_priv *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        p = VRT_priv_task(ctx, &fail_task_fini_token);
        if (p == NULL) {
                VRT_fail(ctx, "no priv task - out of ws?");
                return;
        }

        if (p->priv != NULL) {
                assert(p->priv == fail_magic);
                assert(p->methods == xyzzy_fail_task_fini_methods);
                return;
        }

        p->priv = fail_magic;
        p->methods = xyzzy_fail_task_fini_methods;
}

VCL_VOID v_matchproto_(td_xyzzy_debug_ok_task_fini)
xyzzy_ok_task_fini(VRT_CTX)
{
        struct vmod_priv *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        p = VRT_priv_task(ctx, &fail_task_fini_token);
        if (p == NULL) {
                VRT_fail(ctx, "no priv task - out of ws?");
                return;
        }

        p->priv = NULL;
        p->methods = NULL;
}

VCL_STRING v_matchproto_(td_xyzzy_debug_re_quote)
xyzzy_re_quote(VRT_CTX, VCL_STRING s)
{
        struct vsb vsb[1];
        char *q;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
        WS_VSB_new(vsb, ctx->ws);
        VRE_quote(vsb, s);
        q = WS_VSB_finish(vsb, ctx->ws, NULL);
        if (q == NULL)
                WS_MarkOverflow(ctx->ws);
        return (q);
}

VCL_STRING v_matchproto_(td_xyzzy_priv_task_with_option)
xyzzy_priv_task_with_option(VRT_CTX, struct VARGS(priv_task_with_option) *args)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(args->priv);
        if (args->priv->priv == NULL && args->valid_opt)
                args->priv->priv = WS_Copy(ctx->ws, args->opt, -1);
        return (args->priv->priv);
}

VCL_BOOL v_matchproto_(td_xyzzy_validhdr)
xyzzy_validhdr(VRT_CTX, VCL_STRANDS s)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        return (VRT_ValidHdr(ctx, s));
}

VCL_REGEX v_matchproto_(td_xyzzy_regex)
xyzzy_just_return_regex(VRT_CTX, VCL_REGEX r)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(r);
        return (r);
}

/*---------------------------------------------------------------------*/

VCL_VOID v_matchproto_(td_xyzzy_call)
xyzzy_call(VRT_CTX, VCL_SUB sub)
{
        VRT_call(ctx, sub);
}

VCL_STRING v_matchproto_(td_xyzzy_check_call)
xyzzy_check_call(VRT_CTX, VCL_SUB sub)
{
        return (VRT_check_call(ctx, sub));
}

/* the next two are to test WRONG vmod behavior:
 * holding a VCL_SUB reference across vcls
 */

static VCL_SUB wrong = NULL;

VCL_VOID v_matchproto_(td_xyzzy_bad_memory)
xyzzy_bad_memory(VRT_CTX, VCL_SUB sub)
{
        (void) ctx;

        wrong = sub;
}

VCL_SUB v_matchproto_(td_xyzzy_total_recall)
xyzzy_total_recall(VRT_CTX)
{
        (void) ctx;

        return (wrong);
}

/*---------------------------------------------------------------------*/

struct VPFX(debug_caller) {
       unsigned        magic;
#define DEBUG_CALLER_MAGIC 0xb47f3449
       VCL_SUB         sub;
};

VCL_VOID v_matchproto_(td_xyzzy_debug_caller__init)
xyzzy_caller__init(VRT_CTX, struct VPFX(debug_caller) **callerp,
    const char *name, VCL_SUB sub)
{
        struct VPFX(debug_caller) *caller;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(callerp);
        AZ(*callerp);
        AN(name);
        AN(sub);

        ALLOC_OBJ(caller, DEBUG_CALLER_MAGIC);
        AN(caller);
        *callerp = caller;
        caller->sub = sub;
}

VCL_VOID v_matchproto_(td_xyzzy_debug_caller__fini)
xyzzy_caller__fini(struct VPFX(debug_caller) **callerp)
{
        struct VPFX(debug_caller) *caller;

        if (callerp == NULL || *callerp == NULL)
                return;
        TAKE_OBJ_NOTNULL(caller, callerp, DEBUG_CALLER_MAGIC);
        FREE_OBJ(caller);
}

VCL_VOID v_matchproto_(td_xyzzy_debug_caller_call)
xyzzy_caller_call(VRT_CTX, struct VPFX(debug_caller) *caller)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC);
        AN(caller->sub);

        VRT_call(ctx, caller->sub);
}

VCL_SUB v_matchproto_(td_xyzzy_debug_caller_sub)
xyzzy_caller_xsub(VRT_CTX, struct VPFX(debug_caller) *caller)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(caller, DEBUG_CALLER_MAGIC);
        AN(caller->sub);

        return (caller->sub);
}

struct resolve_priv {
        struct vsb vsb[1];
        const char *fail_port;
        const char *errp[1];
};

static int v_matchproto_(vus_resolved_f)
resolve_cb(void *priv, const struct suckaddr *sa)
{
        struct resolve_priv *p;
        char abuf[VTCP_ADDRBUFSIZE], pbuf[VTCP_PORTBUFSIZE];

        p = (struct resolve_priv *)priv;
        CHECK_OBJ_NOTNULL(p->vsb, VSB_MAGIC);
        AN(sa);
        VTCP_name(sa, abuf, sizeof abuf, pbuf, sizeof pbuf);
        if (p->fail_port != NULL && !strcmp(p->fail_port, pbuf)) {
                *(p->errp) = "bad port";
                return (-1);
        }
        VSB_printf(p->vsb, "%s%s:%s", VSB_len(p->vsb) ? ", " : "", abuf, pbuf);
        return (0);
}

VCL_STRING
xyzzy_resolve_range(VRT_CTX, struct VARGS(resolve_range) *args)
{
        struct resolve_priv p;
        const char *def_port;
        int ret;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (args->addr == NULL)
                return ("vmod-debug: s was NULL");
        memset(&p, 0, sizeof p);
        WS_VSB_new(p.vsb, ctx->ws);
        p.fail_port = args->valid_fail_port ? args->fail_port : NULL;
        def_port = args->valid_def_port ? args->def_port : NULL;
        ret = VSS_resolver_range(args->addr, def_port, resolve_cb, &p, p.errp);
        if (ret)
                VSB_printf(p.vsb, "%s%s", VSB_len(p.vsb) ? ", " : "Failed: ",
                    *(p.errp));
        return (WS_VSB_finish(p.vsb, ctx->ws, NULL));
}

VCL_VOID
xyzzy_use_reembarking_http1(VRT_CTX)
{
        debug_transport_reembarking_http1_use(ctx);
}

VCL_VOID
xyzzy_use_vai_http1(VRT_CTX)
{
        debug_transport_vai_use(ctx);
}

static int
in_oc(struct worker *wrk, struct objcore *oc, const char *p)
{
        const char *hdrs;
        ssize_t len = 0;

        if (oc == NULL)
                return (0);
        hdrs = ObjGetAttr(wrk, oc, OA_HEADERS, &len);
        if (hdrs == NULL)
                return (0);
        if (p < hdrs)
                return (0);
        if (p > hdrs + len)
                return (0);
        return (1);
}

static const char *
ptr_where(VRT_CTX, const char *p)
{
        struct ws *ws = ctx->ws;
        struct ws *aws;
        struct worker *wrk;
        struct objcore *oc, *stale_oc;

        if (ctx->req != NULL) {
                wrk = ctx->req->wrk;
                oc = ctx->req->objcore;
                stale_oc = ctx->req->stale_oc;
        }
        else if (ctx->bo != NULL) {
                wrk = ctx->bo->wrk;
                oc = ctx->bo->fetch_objcore;
                stale_oc = ctx->bo->stale_oc;
        }
        else
                WRONG("ctx");

        AN(wrk);
        aws = wrk->aws;

        if (WS_Allocated(ws, p, -1))
                return ("ws");
        if (WS_Allocated(aws, p, -1))
                return ("aws");
        if (in_oc(wrk, oc, p))
                return ("oc");
        if (in_oc(wrk, stale_oc, p))
                return ("stale_oc");
        return ("?");
}

VCL_VOID
xyzzy_log_strands(VRT_CTX, VCL_STRING prefix, VCL_STRANDS subject, VCL_INT nn)
{
        int i, n;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (prefix == NULL)
                prefix = "";
        AN(subject);
        if (nn > INT_MAX)
                n = INT_MAX;
        else if (nn < 0)
                n = 0;
        else
                n = nn;

        CHECK_OBJ_NOTNULL(subject, STRANDS_MAGIC);
        for (i = 0; i < subject->n; i++) {
                const char *p = subject->p[i];
                mylog(ctx->vsl, SLT_Debug, "%s[%d]: (%s) %p %.*s%s", prefix, i,
                    ptr_where(ctx, p), p, n, p, strlen(p) > (unsigned)n ? "..." : "");
        }
}

		varnish-cache/vmod/vmod_debug.c
0		/*-
1		* Copyright (c) 2012-2019 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@FreeBSD.org>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29
30		#include "config.h"
31
32		#include <stdlib.h>
33		#include <stdio.h>
34		#include <string.h>
35		#include <sys/socket.h>
36		#include <unistd.h>
37
38		#include "cache/cache_varnishd.h"
39		#include "cache/cache_filter.h"
40
41		#include "vsa.h"
42		#include "vss.h"
43		#include "vtcp.h"
44		#include "vtim.h"
45		#include "vcc_debug_if.h"
46		#include "VSC_debug.h"
47
48		#include "vmod_debug.h"
49
50		struct priv_vcl {
51		unsigned magic;
52		#define PRIV_VCL_MAGIC 0x8E62FA9D
53		char *foo;
54		uintptr_t obj_cb;
55		struct vclref *vclref_discard;
56		struct vclref *vclref_cold;
57		VCL_DURATION vcl_discard_delay;
58		VCL_BACKEND be;
59		unsigned cold_be;
60		unsigned cooling_be;
61		int tmpf;
62		};
63
64
65		static pthread_mutex_t vsc_mtx = PTHREAD_MUTEX_INITIALIZER;
66		static struct vsc_seg *vsc_seg = NULL;
67		static struct VSC_debug *vsc = NULL;
68		static int loads;
69		static const int store_ip_token = 0;
70		static const int fail_task_fini_token = 0;
71		extern void mylog(struct vsl_log *vsl, enum VSL_tag_e tag,
72		const char *fmt, ...) v_printflike_(3,4);
73
74		/**********************************************************************/
75
76		VCL_STRING v_matchproto_(td_debug_author)
77	5	xyzzy_author(VRT_CTX, VCL_ENUM person, VCL_ENUM someone)
78		{
79	5	(void)someone;
80
81	5	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
82	5	if (person == VENUM(phk))
83	2	return ("Poul-Henning");
84	3	assert(strcmp(person, "phk"));
85	3	if (person == VENUM(des))
86	1	return ("Dag-Erling");
87	2	assert(strcmp(person, "des"));
88	2	if (person == VENUM(kristian))
89	1	return ("Kristian");
90	1	assert(strcmp(person, "kristian"));
91	1	if (person == VENUM(mithrandir))
92	1	return ("Tollef");
93	0	assert(strcmp(person, "mithrandir"));
94	0	WRONG("Illegal VMOD enum");
95	5	}
96
97		#define AN0(x) (void) 0
98		#define AN1(x) AN(x)
99		#define PRIV_FINI(name, assert) \
100		static void v_matchproto_(vmod_priv_fini_f) \
101		priv_ ## name ## _fini(VRT_CTX, void *ptr) \
102		{ \
103		const char * const fmt = "priv_" #name "_fini(%p)"; \
104		\
105		CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); \
106		AN ## assert (ptr); \
107		mylog(ctx->vsl, SLT_Debug, fmt, (char *)ptr); \
108		free(ptr); \
109		} \
110		\
111		static const struct vmod_priv_methods \
112		xyzzy_test_priv_ ## name ## _methods[1] = {{ \
113		.magic = VMOD_PRIV_METHODS_MAGIC, \
114		.type = "debug_test_priv_" #name, \
115		.fini = priv_ ## name ## _fini \
116		}};
117	2	PRIV_FINI(call, 0)
118	15	PRIV_FINI(task, 1)
119	3	PRIV_FINI(top, 1)
120		#undef PRIV_FINI
121		#undef AN0
122		#undef AN1
123
124		VCL_VOID v_matchproto_(td_debug_test_priv_call)
125	2	xyzzy_test_priv_call(VRT_CTX, struct vmod_priv *priv)
126		{
127
128	2	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
129	2	if (priv->priv == NULL) {
130	2	priv->priv = strdup("BAR");
131	2	priv->methods = xyzzy_test_priv_call_methods;
132	2	} else {
133	0	assert(priv->methods == xyzzy_test_priv_call_methods);
134	0	assert(!strcmp(priv->priv, "BAR"));
135		}
136	2	}
137
138		VCL_VOID v_matchproto_(td_debug_test_priv_task_get)
139	1	xyzzy_test_priv_task_get(VRT_CTX)
140		{
141
142	1	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
143	1	AZ(VRT_priv_task_get(ctx, NULL));
144	1	}
145
146		VCL_STRING v_matchproto_(td_debug_test_priv_task)
147	46	xyzzy_test_priv_task(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
148		{
149
150	46	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
151	46	if (s == NULL \|\| *s == '\0') {
152	42	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (exists)",
153	21	priv, priv->priv);
154	46	} else if (priv->priv == NULL) {
155	15	priv->priv = strdup(s);
156	15	priv->methods = xyzzy_test_priv_task_methods;
157	30	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (new)",
158	15	priv, priv->priv);
159	15	} else {
160	20	char *n = realloc(priv->priv,
161	10	strlen(priv->priv) + strlen(s) + 2);
162	10	if (n == NULL)
163	0	return (NULL);
164	10	strcat(n, " ");
165	10	strcat(n, s);
166	10	priv->priv = n;
167	20	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (update)",
168	10	priv, priv->priv);
169		}
170	46	if (priv->priv != NULL)
171	45	assert(priv->methods == xyzzy_test_priv_task_methods);
172	46	return (priv->priv);
173	46	}
174
175		VCL_STRING v_matchproto_(td_debug_test_priv_top)
176	24	xyzzy_test_priv_top(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
177		{
178
179	24	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
180	24	if (priv->priv == NULL) {
181	3	priv->priv = strdup(s);
182	3	priv->methods = xyzzy_test_priv_top_methods;
183	3	} else {
184	21	assert(priv->methods == xyzzy_test_priv_top_methods);
185		}
186	24	return (priv->priv);
187		}
188
189		VCL_VOID v_matchproto_(td_debug_test_priv_vcl)
190	2	xyzzy_test_priv_vcl(VRT_CTX, struct vmod_priv *priv)
191		{
192		struct priv_vcl *priv_vcl;
193		char t[PATH_MAX];
194		ssize_t l;
195
196	2	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
197	2	AN(priv);
198	2	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
199
200	2	l = pread(priv_vcl->tmpf, t, sizeof t, 0);
201	2	assert(l > 0);
202
203	2	AN(priv_vcl->foo);
204	2	assert(!strncmp(priv_vcl->foo, t, l));
205	2	}
206
207		VCL_VOID v_matchproto_(td_debug_rot52)
208	2	xyzzy_rot52(VRT_CTX, VCL_HTTP hp)
209		{
210
211	2	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
212	2	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
213
214	2	http_PrintfHeader(hp, "Encrypted: ROT52");
215	2	}
216
217		VCL_STRING v_matchproto_(td_debug_argtest)
218	7	xyzzy_argtest(VRT_CTX, struct VARGS(argtest) *arg)
219		{
220		char buf[100];
221
222	7	AN(arg);
223	7	bprintf(buf, "%s %g %s %s %jd %d %s",
224		arg->one, arg->two, arg->three, arg->comma, (intmax_t)arg->four,
225		arg->valid_string, arg->valid_string ? arg->string : "<undef>");
226	7	return (WS_Copy(ctx->ws, buf, -1));
227		}
228
229		VCL_INT v_matchproto_(td_debug_vre_limit)
230	2	xyzzy_vre_limit(VRT_CTX)
231		{
232	2	(void)ctx;
233	2	return (cache_param->vre_limits.match);
234		}
235
236		static void v_matchproto_(obj_event_f)
237	2	obj_cb(struct worker wrk, void priv, struct objcore *oc, unsigned event)
238		{
239		const struct priv_vcl *priv_vcl;
240		const char *what;
241
242	2	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
243	2	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
244	2	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
245	2	switch (event) {
246	1	case OEV_INSERT: what = "insert"; break;
247	1	case OEV_EXPIRE: what = "expire"; break;
248	0	default: WRONG("Wrong object event");
249	0	}
250
251		/* We cannot trust %p to be 0x... format as expected by m00021.vtc */
252	4	VSL(SLT_Debug, NO_VXID, "Object Event: %s 0x%jx", what,
253	2	(intmax_t)(uintptr_t)oc);
254	2	}
255
256		VCL_VOID v_matchproto_(td_debug_register_obj_events)
257	1	xyzzy_register_obj_events(VRT_CTX, struct vmod_priv *priv)
258		{
259		struct priv_vcl *priv_vcl;
260
261	1	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
262	1	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
263	1	AZ(priv_vcl->obj_cb);
264	1	priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl,
265		OEV_INSERT\|OEV_EXPIRE);
266	1	VSL(SLT_Debug, NO_VXID, "Subscribed to Object Events");
267	1	}
268
269		VCL_VOID v_matchproto_(td_debug_fail)
270	16	xyzzy_fail(VRT_CTX)
271		{
272
273	16	VRT_fail(ctx, "Forced failure");
274	16	}
275
276		VCL_BOOL v_matchproto_(td_debug_fail2)
277	1	xyzzy_fail2(VRT_CTX)
278		{
279
280	1	VRT_fail(ctx, "Forced failure");
281	1	return (1);
282		}
283
284		static void v_matchproto_(vmod_priv_fini_f)
285	23	priv_vcl_fini(VRT_CTX, void *priv)
286		{
287		struct priv_vcl *priv_vcl;
288
289	23	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
290	23	AZ(close(priv_vcl->tmpf));
291	23	AN(priv_vcl->foo);
292	23	AZ(unlink(priv_vcl->foo));
293	23	free(priv_vcl->foo);
294	23	if (priv_vcl->obj_cb != 0) {
295	1	ObjUnsubscribeEvents(&priv_vcl->obj_cb);
296	1	VSLb(ctx->vsl, SLT_Debug, "Unsubscribed from Object Events");
297	1	}
298	23	AZ(priv_vcl->vclref_discard);
299	23	AZ(priv_vcl->vclref_cold);
300	23	FREE_OBJ(priv_vcl);
301	23	}
302
303		static const struct vmod_priv_methods priv_vcl_methods[1] = {{
304		.magic = VMOD_PRIV_METHODS_MAGIC,
305		.type = "debug_priv_vcl_fini",
306		.fini = priv_vcl_fini
307		}};
308
309		static int
310	102	event_load(VRT_CTX, struct vmod_priv *priv)
311		{
312		struct priv_vcl *priv_vcl;
313
314	102	AN(ctx->msg);
315
316	102	loads++;
317
318	102	if (cache_param->nuke_limit == 42) {
319	1	VSB_cat(ctx->msg, "nuke_limit is not the answer.");
320	1	return (-1);
321		}
322
323	101	ALLOC_OBJ(priv_vcl, PRIV_VCL_MAGIC);
324	101	AN(priv_vcl);
325	101	priv_vcl->foo = strdup("worker_tmpdir/vmod_debug.XXXXXX");
326	101	AN(priv_vcl->foo);
327	101	priv_vcl->tmpf = mkstemp(priv_vcl->foo);
328	101	assert(priv_vcl->tmpf >= 0);
329	101	AN(write(priv_vcl->tmpf, priv_vcl->foo, strlen(priv_vcl->foo)));
330	101	priv->priv = priv_vcl;
331	101	priv->methods = priv_vcl_methods;
332
333	101	debug_add_filters(ctx);
334	101	debug_transport_reembarking_http1_init();
335	101	debug_transport_vai_init();
336	101	return (0);
337	102	}
338
339		VCL_VOID
340	1	xyzzy_vcl_prevent_cold(VRT_CTX, struct vmod_priv *priv)
341		{
342		struct priv_vcl *priv_vcl;
343		char buf[32];
344
345	1	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
346	1	AN(priv);
347	1	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
348	1	AZ(priv_vcl->vclref_cold);
349
350	1	bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
351	1	priv_vcl->vclref_cold = VRT_VCL_Prevent_Cold(ctx, buf);
352	1	}
353
354		VCL_VOID
355	1	xyzzy_vcl_allow_cold(VRT_CTX, struct vmod_priv *priv)
356		{
357		struct priv_vcl *priv_vcl;
358
359	1	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
360	1	AN(priv);
361	1	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
362	1	AN(priv_vcl->vclref_cold);
363	1	VRT_VCL_Allow_Cold(&priv_vcl->vclref_cold);
364	1	}
365
366		VCL_VOID
367	0	xyzzy_cold_backend(VRT_CTX, struct vmod_priv *priv)
368		{
369		struct priv_vcl *priv_vcl;
370
371	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
372	0	AN(priv);
373	0	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
374	0	priv_vcl->cold_be = 1;
375	0	}
376
377		VCL_VOID
378	0	xyzzy_cooling_backend(VRT_CTX, struct vmod_priv *priv)
379		{
380		struct priv_vcl *priv_vcl;
381
382	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
383	0	AN(priv);
384	0	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
385	0	priv_vcl->cooling_be = 1;
386	0	}
387
388		static const struct vdi_methods empty_methods[1] = {{
389		.magic = VDI_METHODS_MAGIC,
390		.type = "debug.dummy"
391		}};
392
393		static int
394	92	event_warm(VRT_CTX, const struct vmod_priv *priv)
395		{
396		struct priv_vcl *priv_vcl;
397		char buf[32];
398	92	const char *vcl_name = VCL_Name(ctx->vcl);
399
400		// Using VSLs for coverage
401	92	VSLs(SLT_Debug, NO_VXID, TOSTRANDS(2, vcl_name, ": VCL_EVENT_WARM"));
402
403	92	AN(ctx->msg);
404	92	if (cache_param->max_esi_depth == 42) {
405	3	VSB_cat(ctx->msg, "max_esi_depth is not the answer.");
406	3	return (-1);
407		}
408
409	89	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
410	89	AZ(priv_vcl->vclref_discard);
411
412	89	if (!priv_vcl->cold_be) {
413		/* NB: set up a COOLING step unless we want a COLD backend. */
414	89	bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
415	89	priv_vcl->vclref_discard = VRT_VCL_Prevent_Discard(ctx, buf);
416	89	}
417
418	89	AZ(priv_vcl->be);
419	89	priv_vcl->be = VRT_AddDirector(ctx, empty_methods,
420		NULL, "%s", "dir_warmcold");
421
422	89	return (0);
423	92	}
424
425		static void*
426	1	cooldown_thread(void *priv)
427		{
428		struct priv_vcl *priv_vcl;
429
430	1	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
431	1	AN(priv_vcl->vclref_discard);
432
433	1	VTIM_sleep(priv_vcl->vcl_discard_delay);
434	1	VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
435	1	return (NULL);
436		}
437
438		static VCL_BACKEND
439	0	create_cold_backend(VRT_CTX)
440		{
441		struct vrt_endpoint vep[1];
442		struct vrt_backend be[1];
443
444	0	INIT_OBJ(vep, VRT_ENDPOINT_MAGIC);
445	0	vep->uds_path = "/";
446	0	INIT_OBJ(be, VRT_BACKEND_MAGIC);
447	0	be->endpoint = vep;
448	0	be->vcl_name = "doomed";
449	0	return (VRT_new_backend(ctx, be, NULL));
450		}
451
452		static int
453	14	event_cold(VRT_CTX, const struct vmod_priv *priv)
454		{
455		pthread_t thread;
456		struct priv_vcl *priv_vcl;
457
458	14	AZ(ctx->msg);
459
460	14	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
461
462	14	VSL(SLT_Debug, NO_VXID, "%s: VCL_EVENT_COLD", VCL_Name(ctx->vcl));
463
464	14	VRT_DelDirector(&priv_vcl->be);
465
466	14	if (priv_vcl->cold_be) {
467	0	AZ(priv_vcl->vclref_discard);
468	0	priv_vcl->be = create_cold_backend(ctx);
469	0	WRONG("unreachable");
470	0	}
471
472	14	if (priv_vcl->cooling_be) {
473	0	AN(priv_vcl->vclref_discard);
474	0	priv_vcl->be = create_cold_backend(ctx);
475	0	AZ(priv_vcl->be);
476	0	}
477
478	14	if (priv_vcl->vcl_discard_delay == 0.0) {
479	13	AN(priv_vcl->vclref_discard);
480	13	VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
481	13	return (0);
482		}
483
484	1	PTOK(pthread_create(&thread, NULL, cooldown_thread, priv_vcl));
485	1	PTOK(pthread_detach(thread));
486	1	return (0);
487	14	}
488
489		static int
490	23	event_discard(VRT_CTX, void *priv)
491		{
492
493	23	(void)priv;
494
495	23	AZ(ctx->msg);
496
497	23	debug_remove_filters(ctx);
498
499	23	if (--loads)