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_int.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_DURATION            cold_stall;
        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(vstrcmp(person, "phk"));
        if (person == VENUM(des))
                return ("Dag-Erling");
        assert(vstrcmp(person, "des"));
        if (person == VENUM(kristian))
                return ("Kristian");
        assert(vstrcmp(person, "kristian"));
        if (person == VENUM(mithrandir))
                return ("Tollef");
        assert(vstrcmp(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(!vstrcmp(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,
                    vstrlen(priv->priv) + vstrlen(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_default_bool)
xyzzy_test_default_bool(VRT_CTX, VCL_BOOL test)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        assert(test == 0 || test == 1);
}

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);
        closefd(&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, vstrlen(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[512];
        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));

        if (priv_vcl->cold_stall > 0.0)
                VTIM_sleep(priv_vcl->cold_stall);

        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_cold_stall)
xyzzy_cold_stall(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->cold_stall = 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 += vstrlen(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);
        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);
        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 {
                        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 && !vstrcmp(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,
                    vstrlen(p) > (unsigned)n ? "..." : "");
        }
}

const void * const priv_task_id_bp = &priv_task_id_bp;

VCL_VOID
xyzzy_body_prefix(VRT_CTX, VCL_STRING s)
{
        struct xyzzy_bp_string *bps;
        struct xyzzy_bp *bp;
        struct vmod_priv *task;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        task = VRT_priv_task(ctx, priv_task_id_bp);
        AN(task);
        bp = task->priv;
        if (bp == NULL) {
                bp = WS_Alloc(ctx->ws, (unsigned)sizeof *bp);
                AN(bp);
                task->priv = bp;
                INIT_OBJ(bp, XYZZY_BP_MAGIC);
                VSTAILQ_INIT(&bp->head);
        }
        CHECK_OBJ(bp, XYZZY_BP_MAGIC);

        bps = WS_Alloc(ctx->ws, (unsigned)sizeof *bps);
        AN(bps);
        bps->s = s;
        VSTAILQ_INSERT_TAIL(&bp->head, bps, list);
}

		vinyl-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_int.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_DURATION cold_stall;
59		VCL_BACKEND be;
60		unsigned cold_be;
61		unsigned cooling_be;
62		int tmpf;
63		};
64
65
66		static pthread_mutex_t vsc_mtx = PTHREAD_MUTEX_INITIALIZER;
67		static struct vsc_seg *vsc_seg = NULL;
68		static struct VSC_debug *vsc = NULL;
69		static int loads;
70		static const int store_ip_token = 0;
71		static const int fail_task_fini_token = 0;
72		extern void mylog(struct vsl_log *vsl, enum VSL_tag_e tag,
73		const char *fmt, ...) v_printflike_(3,4);
74
75		/**********************************************************************/
76
77		VCL_STRING v_matchproto_(td_debug_author)
78	105	xyzzy_author(VRT_CTX, VCL_ENUM person, VCL_ENUM someone)
79		{
80	105	(void)someone;
81
82	105	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
83	105	if (person == VENUM(phk))
84	42	return ("Poul-Henning");
85	63	assert(vstrcmp(person, "phk"));
86	63	if (person == VENUM(des))
87	21	return ("Dag-Erling");
88	42	assert(vstrcmp(person, "des"));
89	42	if (person == VENUM(kristian))
90	21	return ("Kristian");
91	21	assert(vstrcmp(person, "kristian"));
92	21	if (person == VENUM(mithrandir))
93	21	return ("Tollef");
94	0	assert(vstrcmp(person, "mithrandir"));
95	0	WRONG("Illegal VMOD enum");
96	105	}
97
98		#define AN0(x) (void) 0
99		#define AN1(x) AN(x)
100		#define PRIV_FINI(name, assert) \
101		static void v_matchproto_(vmod_priv_fini_f) \
102		priv_ ## name ## _fini(VRT_CTX, void *ptr) \
103		{ \
104		const char * const fmt = "priv_" #name "_fini(%p)"; \
105		\
106		CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC); \
107		AN ## assert (ptr); \
108		mylog(ctx->vsl, SLT_Debug, fmt, (char *)ptr); \
109		free(ptr); \
110		} \
111		\
112		static const struct vmod_priv_methods \
113		xyzzy_test_priv_ ## name ## _methods[1] = {{ \
114		.magic = VMOD_PRIV_METHODS_MAGIC, \
115		.type = "debug_test_priv_" #name, \
116		.fini = priv_ ## name ## _fini \
117		}};
118	42	PRIV_FINI(call, 0)
119	315	PRIV_FINI(task, 1)
120	63	PRIV_FINI(top, 1)
121		#undef PRIV_FINI
122		#undef AN0
123		#undef AN1
124
125		VCL_VOID v_matchproto_(td_debug_test_priv_call)
126	42	xyzzy_test_priv_call(VRT_CTX, struct vmod_priv *priv)
127		{
128
129	42	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
130	42	if (priv->priv == NULL) {
131	42	priv->priv = strdup("BAR");
132	42	priv->methods = xyzzy_test_priv_call_methods;
133	42	} else {
134	0	assert(priv->methods == xyzzy_test_priv_call_methods);
135	0	assert(!vstrcmp(priv->priv, "BAR"));
136		}
137	42	}
138
139		VCL_VOID v_matchproto_(td_debug_test_priv_task_get)
140	21	xyzzy_test_priv_task_get(VRT_CTX)
141		{
142
143	21	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
144	21	AZ(VRT_priv_task_get(ctx, NULL));
145	21	}
146
147		VCL_STRING v_matchproto_(td_debug_test_priv_task)
148	966	xyzzy_test_priv_task(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
149		{
150
151	966	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
152	966	if (s == NULL \|\| *s == '\0') {
153	882	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (exists)",
154	441	priv, priv->priv);
155	966	} else if (priv->priv == NULL) {
156	315	priv->priv = strdup(s);
157	315	priv->methods = xyzzy_test_priv_task_methods;
158	630	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (new)",
159	315	priv, priv->priv);
160	315	} else {
161	420	char *n = realloc(priv->priv,
162	210	vstrlen(priv->priv) + vstrlen(s) + 2);
163	210	if (n == NULL)
164	0	return (NULL);
165	210	strcat(n, " ");
166	210	strcat(n, s);
167	210	priv->priv = n;
168	420	mylog(ctx->vsl, SLT_Debug, "test_priv_task(%p) = %p (update)",
169	210	priv, priv->priv);
170		}
171	966	if (priv->priv != NULL)
172	945	assert(priv->methods == xyzzy_test_priv_task_methods);
173	966	return (priv->priv);
174	966	}
175
176		VCL_STRING v_matchproto_(td_debug_test_priv_top)
177	504	xyzzy_test_priv_top(VRT_CTX, struct vmod_priv *priv, VCL_STRING s)
178		{
179
180	504	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
181	504	if (priv->priv == NULL) {
182	63	priv->priv = strdup(s);
183	63	priv->methods = xyzzy_test_priv_top_methods;
184	63	} else {
185	441	assert(priv->methods == xyzzy_test_priv_top_methods);
186		}
187	504	return (priv->priv);
188		}
189
190		VCL_VOID v_matchproto_(td_debug_test_default_bool)
191	63	xyzzy_test_default_bool(VRT_CTX, VCL_BOOL test)
192		{
193
194	63	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
195	63	assert(test == 0 \|\| test == 1);
196	63	}
197
198		VCL_VOID v_matchproto_(td_debug_test_priv_vcl)
199	42	xyzzy_test_priv_vcl(VRT_CTX, struct vmod_priv *priv)
200		{
201		struct priv_vcl *priv_vcl;
202		char t[PATH_MAX];
203		ssize_t l;
204
205	42	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
206	42	AN(priv);
207	42	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
208
209	42	l = pread(priv_vcl->tmpf, t, sizeof t, 0);
210	42	assert(l > 0);
211
212	42	AN(priv_vcl->foo);
213	42	assert(!strncmp(priv_vcl->foo, t, l));
214	42	}
215
216		VCL_VOID v_matchproto_(td_debug_rot52)
217	42	xyzzy_rot52(VRT_CTX, VCL_HTTP hp)
218		{
219
220	42	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
221	42	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
222
223	42	http_PrintfHeader(hp, "Encrypted: ROT52");
224	42	}
225
226		VCL_STRING v_matchproto_(td_debug_argtest)
227	147	xyzzy_argtest(VRT_CTX, struct VARGS(argtest) *arg)
228		{
229		char buf[100];
230
231	147	AN(arg);
232	147	bprintf(buf, "%s %g %s %s %jd %d %s",
233		arg->one, arg->two, arg->three, arg->comma, (intmax_t)arg->four,
234		arg->valid_string, arg->valid_string ? arg->string : "<undef>");
235	147	return (WS_Copy(ctx->ws, buf, -1));
236		}
237
238		VCL_INT v_matchproto_(td_debug_vre_limit)
239	42	xyzzy_vre_limit(VRT_CTX)
240		{
241	42	(void)ctx;
242	42	return (cache_param->vre_limits.match);
243		}
244
245		static void v_matchproto_(obj_event_f)
246	42	obj_cb(struct worker wrk, void priv, struct objcore *oc, unsigned event)
247		{
248		const struct priv_vcl *priv_vcl;
249		const char *what;
250
251	42	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
252	42	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
253	42	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
254	42	switch (event) {
255	21	case OEV_INSERT: what = "insert"; break;
256	21	case OEV_EXPIRE: what = "expire"; break;
257	0	default: WRONG("Wrong object event");
258	0	}
259
260		/* We cannot trust %p to be 0x... format as expected by m00021.vtc */
261	84	VSL(SLT_Debug, NO_VXID, "Object Event: %s 0x%jx", what,
262	42	(intmax_t)(uintptr_t)oc);
263	42	}
264
265		VCL_VOID v_matchproto_(td_debug_register_obj_events)
266	21	xyzzy_register_obj_events(VRT_CTX, struct vmod_priv *priv)
267		{
268		struct priv_vcl *priv_vcl;
269
270	21	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
271	21	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
272	21	AZ(priv_vcl->obj_cb);
273	21	priv_vcl->obj_cb = ObjSubscribeEvents(obj_cb, priv_vcl,
274		OEV_INSERT\|OEV_EXPIRE);
275	21	VSL(SLT_Debug, NO_VXID, "Subscribed to Object Events");
276	21	}
277
278		VCL_VOID v_matchproto_(td_debug_fail)
279	336	xyzzy_fail(VRT_CTX)
280		{
281
282	336	VRT_fail(ctx, "Forced failure");
283	336	}
284
285		VCL_BOOL v_matchproto_(td_debug_fail2)
286	21	xyzzy_fail2(VRT_CTX)
287		{
288
289	21	VRT_fail(ctx, "Forced failure");
290	21	return (1);
291		}
292
293		static void v_matchproto_(vmod_priv_fini_f)
294	483	priv_vcl_fini(VRT_CTX, void *priv)
295		{
296		struct priv_vcl *priv_vcl;
297
298	483	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
299	483	closefd(&priv_vcl->tmpf);
300	483	AN(priv_vcl->foo);
301	483	AZ(unlink(priv_vcl->foo));
302	483	free(priv_vcl->foo);
303	483	if (priv_vcl->obj_cb != 0) {
304	21	ObjUnsubscribeEvents(&priv_vcl->obj_cb);
305	21	VSLb(ctx->vsl, SLT_Debug, "Unsubscribed from Object Events");
306	21	}
307	483	AZ(priv_vcl->vclref_discard);
308	483	AZ(priv_vcl->vclref_cold);
309	483	FREE_OBJ(priv_vcl);
310	483	}
311
312		static const struct vmod_priv_methods priv_vcl_methods[1] = {{
313		.magic = VMOD_PRIV_METHODS_MAGIC,
314		.type = "debug_priv_vcl_fini",
315		.fini = priv_vcl_fini
316		}};
317
318		static int
319	2226	event_load(VRT_CTX, struct vmod_priv *priv)
320		{
321		struct priv_vcl *priv_vcl;
322
323	2226	AN(ctx->msg);
324
325	2226	loads++;
326
327	2226	if (cache_param->nuke_limit == 42) {
328	21	VSB_cat(ctx->msg, "nuke_limit is not the answer.");
329	21	return (-1);
330		}
331
332	2205	ALLOC_OBJ(priv_vcl, PRIV_VCL_MAGIC);
333	2205	AN(priv_vcl);
334	2205	priv_vcl->foo = strdup("worker_tmpdir/vmod_debug.XXXXXX");
335	2205	AN(priv_vcl->foo);
336	2205	priv_vcl->tmpf = mkstemp(priv_vcl->foo);
337	2205	assert(priv_vcl->tmpf >= 0);
338	2205	AN(write(priv_vcl->tmpf, priv_vcl->foo, vstrlen(priv_vcl->foo)));
339	2205	priv->priv = priv_vcl;
340	2205	priv->methods = priv_vcl_methods;
341
342	2205	debug_add_filters(ctx);
343	2205	debug_transport_reembarking_http1_init();
344	2205	debug_transport_vai_init();
345	2205	return (0);
346	2226	}
347
348		VCL_VOID
349	21	xyzzy_vcl_prevent_cold(VRT_CTX, struct vmod_priv *priv)
350		{
351		struct priv_vcl *priv_vcl;
352		char buf[32];
353
354	21	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
355	21	AN(priv);
356	21	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
357	21	AZ(priv_vcl->vclref_cold);
358
359	21	bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
360	21	priv_vcl->vclref_cold = VRT_VCL_Prevent_Cold(ctx, buf);
361	21	}
362
363		VCL_VOID
364	21	xyzzy_vcl_allow_cold(VRT_CTX, struct vmod_priv *priv)
365		{
366		struct priv_vcl *priv_vcl;
367
368	21	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
369	21	AN(priv);
370	21	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
371	21	AN(priv_vcl->vclref_cold);
372	21	VRT_VCL_Allow_Cold(&priv_vcl->vclref_cold);
373	21	}
374
375		VCL_VOID
376	0	xyzzy_cold_backend(VRT_CTX, struct vmod_priv *priv)
377		{
378		struct priv_vcl *priv_vcl;
379
380	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
381	0	AN(priv);
382	0	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
383	0	priv_vcl->cold_be = 1;
384	0	}
385
386		VCL_VOID
387	0	xyzzy_cooling_backend(VRT_CTX, struct vmod_priv *priv)
388		{
389		struct priv_vcl *priv_vcl;
390
391	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
392	0	AN(priv);
393	0	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
394	0	priv_vcl->cooling_be = 1;
395	0	}
396
397		static const struct vdi_methods empty_methods[1] = {{
398		.magic = VDI_METHODS_MAGIC,
399		.type = "debug.dummy"
400		}};
401
402		static int
403	2016	event_warm(VRT_CTX, const struct vmod_priv *priv)
404		{
405		struct priv_vcl *priv_vcl;
406		char buf[512];
407	2016	const char *vcl_name = VCL_Name(ctx->vcl);
408
409		// Using VSLs for coverage
410	2016	VSLs(SLT_Debug, NO_VXID, TOSTRANDS(2, vcl_name, ": VCL_EVENT_WARM"));
411
412	2016	AN(ctx->msg);
413	2016	if (cache_param->max_esi_depth == 42) {
414	63	VSB_cat(ctx->msg, "max_esi_depth is not the answer.");
415	63	return (-1);
416		}
417
418	1953	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
419	1953	AZ(priv_vcl->vclref_discard);
420
421	1953	if (!priv_vcl->cold_be) {
422		/* NB: set up a COOLING step unless we want a COLD backend. */
423	1953	bprintf(buf, "vmod-debug ref on %s", VCL_Name(ctx->vcl));
424	1953	priv_vcl->vclref_discard = VRT_VCL_Prevent_Discard(ctx, buf);
425	1953	}
426
427	1953	AZ(priv_vcl->be);
428	1953	priv_vcl->be = VRT_AddDirector(ctx, empty_methods,
429		NULL, "%s", "dir_warmcold");
430
431	1953	return (0);
432	2016	}
433
434		static void*
435	21	cooldown_thread(void *priv)
436		{
437		struct priv_vcl *priv_vcl;
438
439	21	CAST_OBJ_NOTNULL(priv_vcl, priv, PRIV_VCL_MAGIC);
440	21	AN(priv_vcl->vclref_discard);
441
442	21	VTIM_sleep(priv_vcl->vcl_discard_delay);
443	21	VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
444	21	return (NULL);
445		}
446
447		static VCL_BACKEND
448	0	create_cold_backend(VRT_CTX)
449		{
450		struct vrt_endpoint vep[1];
451		struct vrt_backend be[1];
452
453	0	INIT_OBJ(vep, VRT_ENDPOINT_MAGIC);
454	0	vep->uds_path = "/";
455	0	INIT_OBJ(be, VRT_BACKEND_MAGIC);
456	0	be->endpoint = vep;
457	0	be->vcl_name = "doomed";
458	0	return (VRT_new_backend(ctx, be, NULL));
459		}
460
461		static int
462	294	event_cold(VRT_CTX, const struct vmod_priv *priv)
463		{
464		pthread_t thread;
465		struct priv_vcl *priv_vcl;
466
467	294	AZ(ctx->msg);
468
469	294	CAST_OBJ_NOTNULL(priv_vcl, priv->priv, PRIV_VCL_MAGIC);
470
471	294	VSL(SLT_Debug, NO_VXID, "%s: VCL_EVENT_COLD", VCL_Name(ctx->vcl));
472
473	294	if (priv_vcl->cold_stall > 0.0)
474	0	VTIM_sleep(priv_vcl->cold_stall);
475
476	294	VRT_DelDirector(&priv_vcl->be);
477
478	294	if (priv_vcl->cold_be) {
479	0	AZ(priv_vcl->vclref_discard);
480	0	priv_vcl->be = create_cold_backend(ctx);
481	0	WRONG("unreachable");
482	0	}
483
484	294	if (priv_vcl->cooling_be) {
485	0	AN(priv_vcl->vclref_discard);
486	0	priv_vcl->be = create_cold_backend(ctx);
487	0	AZ(priv_vcl->be);
488	0	}
489
490	294	if (priv_vcl->vcl_discard_delay == 0.0) {
491	273	AN(priv_vcl->vclref_discard);
492	273	VRT_VCL_Allow_Discard(&priv_vcl->vclref_discard);
493	273	return (0);
494		}
495
496	21	PTOK(pthread_create(&thread, NULL, cooldown_thread, priv_vcl));
497	21	PTOK(pthread_detach(thread));
498	21	return (0);
499	294	}