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 "vgz.h"
#include "vsha256.h"
#include "vtim.h"
#include "vcc_debug_if.h"

#include "vmod_debug.h"

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

static enum vfp_status v_matchproto_(vfp_pull_f)
xyzzy_vfp_rot13_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{
        enum vfp_status vp;
        char *q;
        ssize_t l;

        (void)vfe;
        vp = VFP_Suck(vc, p, lp);
        if (vp == VFP_ERROR)
                return (vp);
        q = p;
        for (l = 0; l < *lp; l++, q++) {
                if (*q >= 'A' && *q <= 'Z')
                        *q = (((*q - 'A') + 13) % 26) + 'A';
                if (*q >= 'a' && *q <= 'z')
                        *q = (((*q - 'a') + 13) % 26) + 'a';
        }
        return (vp);
}

static const struct vfp xyzzy_vfp_rot13 = {
        .name = "rot13",
        .pull = xyzzy_vfp_rot13_pull,
};

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

// deliberately fragmenting the stream to make testing more interesting
#define ROT13_BUFSZ 8

static int v_matchproto_(vdp_init_f)
xyzzy_vdp_rot13_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);

        AN(priv);

        *priv = malloc(ROT13_BUFSZ);
        if (*priv == NULL)
                return (-1);

        return (0);
}

static int v_matchproto_(vdp_bytes_f)
xyzzy_vdp_rot13_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        char *q;
        const char *pp;
        int i, j, retval = 0;

        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        AN(priv);
        AN(*priv);
        if (len <= 0)
                return (VDP_bytes(vdc, act, ptr, len));
        AN(ptr);
        if (act != VDP_END)
                act = VDP_FLUSH;
        q = *priv;
        pp = ptr;

        for (i = 0, j = 0; j < len; i++, j++) {
                if (pp[j] >= 'A' && pp[j] <= 'Z')
                        q[i] = (((pp[j] - 'A') + 13) % 26) + 'A';
                else if (pp[j] >= 'a' && pp[j] <= 'z')
                        q[i] = (((pp[j] - 'a') + 13) % 26) + 'a';
                else
                        q[i] = pp[j];
                if (i == ROT13_BUFSZ - 1 && j < len - 1) {
                        retval = VDP_bytes(vdc, VDP_FLUSH, q, ROT13_BUFSZ);
                        if (retval != 0)
                                return (retval);
                        i = -1;
                }
        }
        if (i >= 0)
                retval = VDP_bytes(vdc, act, q, i);
        return (retval);
}

static int v_matchproto_(vdp_fini_f)
xyzzy_vdp_rot13_fini(struct vdp_ctx *vdc, void **priv)
{
        (void)vdc;
        AN(priv);
        free(*priv);
        *priv = NULL;
        return (0);
}

static const struct vdp xyzzy_vdp_rot13 = {
        .name  = "rot13",
        .init  = xyzzy_vdp_rot13_init,
        .bytes = xyzzy_vdp_rot13_bytes,
        .fini  = xyzzy_vdp_rot13_fini,
};

VCL_VOID v_matchproto_(td_debug_rot104)
xyzzy_rot104(VRT_CTX)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        // This should fail
        AN(VRT_AddFilter(ctx, &xyzzy_vfp_rot13, &xyzzy_vdp_rot13));
}

/**********************************************************************
 * vdp debug_chunked: force http1 chunked encoding by removing the
 * Content-Length header
 *
 * this happens in a VDP because cnt_transmit() runs after VCL and
 * restores it
 */

static int v_matchproto_(vdp_init_f)
xyzzy_vdp_chunked_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        http_Unset(vdc->hp, H_Content_Length);
        *vdc->clen = -1;

        return (1);
}

static const struct vdp xyzzy_vdp_chunked = {
        .name  = "debug.chunked",
        .init  = xyzzy_vdp_chunked_init,
};

/**********************************************************************
 * pedantic tests of the VDP API:
 * - assert that we see a VDP_END
 * - assert that _fini gets called before the task ends
 *
 * note:
 * we could lookup our own vdpe in _fini and check for vdpe->end == VDP_END
 * yet that would cross the API
 */

enum vdp_state_e {
        VDPS_NULL = 0,
        VDPS_INIT,      // _init called
        VDPS_BYTES,     // _bytes called act != VDP_END
        VDPS_END,       // _bytes called act == VDP_END
        VDPS_FINI       // _fini called
};

struct vdp_state_s {
        unsigned                magic;
#define VDP_STATE_MAGIC 0x57c8d309
        enum vdp_state_e        state;
};

static void v_matchproto_(vmod_priv_fini_f)
priv_pedantic_fini(VRT_CTX, void *priv)
{
        struct vdp_state_s *vdps;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CAST_OBJ_NOTNULL(vdps, priv, VDP_STATE_MAGIC);

        assert(vdps->state == VDPS_FINI);
}

static const struct vmod_priv_methods priv_pedantic_methods[1] = {{
        .magic = VMOD_PRIV_METHODS_MAGIC,
        .type = "debug_vdp_pedantic",
        .fini = priv_pedantic_fini
}};

static int v_matchproto_(vdp_init_f)
xyzzy_pedantic_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct vdp_state_s *vdps;
        struct vmod_priv *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_STATE_MAGIC);
        if (vdps == NULL)
                return (-1);
        assert(vdps->state == VDPS_NULL);

        p = VRT_priv_task(ctx, (void *)vdc);
        if (p == NULL)
                return (-1);
        p->priv = vdps;
        p->methods = priv_pedantic_methods;

        *priv = vdps;

        vdps->state = VDPS_INIT;

        return (0);
}

static int v_matchproto_(vdp_bytes_f)
xyzzy_pedantic_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        struct vdp_state_s *vdps;

        CAST_OBJ_NOTNULL(vdps, *priv, VDP_STATE_MAGIC);
        assert(vdps->state >= VDPS_INIT);
        assert(vdps->state < VDPS_END);

        if (act == VDP_END)
                vdps->state = VDPS_END;
        else
                vdps->state = VDPS_BYTES;

        return (VDP_bytes(vdc, act, ptr, len));
}

static int v_matchproto_(vdp_fini_f)
xyzzy_pedantic_fini(struct vdp_ctx *vdc, void **priv)
{
        struct vdp_state_s *vdps;

        (void) vdc;
        AN(priv);
        if (*priv == NULL)
                return (0);
        TAKE_OBJ_NOTNULL(vdps, priv, VDP_STATE_MAGIC);
        assert(vdps->state == VDPS_INIT || vdps->state == VDPS_END);
        vdps->state = VDPS_FINI;

        return (0);
}

static const struct vdp xyzzy_vdp_pedantic = {
        .name  = "debug.pedantic",
        .init  = xyzzy_pedantic_init,
        .bytes = xyzzy_pedantic_bytes,
        .fini  = xyzzy_pedantic_fini,
};

/**********************************************************************
 *
 * this trivial copy/paste/edit filter (of rot13) was specifically made for
 * someone who added a DBG_SLOW_BEREQ debug flag. It should actually be turned
 * in a proper "bandwidth control" filter, but that exceeds an evening's work,
 * so it's kept for later
 */

static enum vfp_status v_matchproto_(vfp_pull_f)
xyzzy_vfp_slow_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{

        (void)vfe;
        VTIM_sleep(1.0);
        return (VFP_Suck(vc, p, lp));
}

static const struct vfp xyzzy_vfp_slow = {
        .name = "debug.slow",
        .pull = xyzzy_vfp_slow_pull,
};

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

static int v_matchproto_(vdp_bytes_f)
xyzzy_vdp_slow_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{

        (void)priv;
        VTIM_sleep(1.0);
        return (VDP_bytes(vdc, act, ptr, len));
}

static const struct vdp xyzzy_vdp_slow = {
        .name  = "debug.slow",
        .bytes = xyzzy_vdp_slow_bytes
};

/*
 * checksum VDP:
 * test that the stream of bytes has a certain checksum and either log
 * or panic
 *
 * The sha256 and crc32 variants are basically identical, but the amount of
 * code does not justify generalizing. (slink)
 */

enum vdp_chk_mode_e {
        //lint -esym(749, vdp_chk_mode_e::VDP_CHK_INVAL) deliberately not referenced
        VDP_CHK_INVAL = 0,
        VDP_CHK_LOG,
        VDP_CHK_PANIC,
        VDP_CHK_PANIC_UNLESS_ERROR
};

struct vdp_chksha256_cfg_s {
        unsigned                        magic;
#define VDP_CHKSHA256_CFG_MAGIC         0x624f5b32
        enum vdp_chk_mode_e             mode;
        unsigned char                   expected[VSHA256_DIGEST_LENGTH];
};

struct vdp_chkcrc32_cfg_s {
        unsigned                        magic;
#define VDP_CHKCRC32_CFG_MAGIC          0x5a7a835c
        enum vdp_chk_mode_e             mode;
        uint32_t                        expected;
};

struct vdp_chksha256_s {
        unsigned                        magic;
#define VDP_CHKSHA256_MAGIC             0x6856e913
        unsigned                        called;
        size_t                          bytes;
        struct VSHA256Context           cx[1];
        struct vdp_chksha256_cfg_s      *cfg;
};

struct vdp_chkcrc32_s {
        unsigned                        magic;
#define VDP_CHKCRC32_MAGIC              0x15c03d3c
        unsigned                        called;
        size_t                          bytes;
        uint32_t                        crc;
        struct vdp_chkcrc32_cfg_s       *cfg;
};

static const void * const chksha256_priv_id = &chksha256_priv_id;
static const void * const chkcrc32_priv_id = &chkcrc32_priv_id;

static int v_matchproto_(vdp_init_f)
xyzzy_chksha256_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct vdp_chksha256_s *vdps;
        struct vmod_priv *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_CHKSHA256_MAGIC);
        if (vdps == NULL)
                return (-1);
        VSHA256_Init(vdps->cx);

        p = VRT_priv_task_get(ctx, chksha256_priv_id);
        if (p == NULL)
                return (-1);

        assert(p->len == sizeof(struct vdp_chksha256_cfg_s));
        CAST_OBJ_NOTNULL(vdps->cfg, p->priv, VDP_CHKSHA256_CFG_MAGIC);
        *priv = vdps;

        return (0);
}

static int v_matchproto_(vdp_init_f)
xyzzy_chkcrc32_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct vdp_chkcrc32_s *vdps;
        struct vmod_priv *p;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_CHKCRC32_MAGIC);
        if (vdps == NULL)
                return (-1);
        vdps->crc = crc32(0L, Z_NULL, 0);

        p = VRT_priv_task_get(ctx, chkcrc32_priv_id);
        if (p == NULL)
                return (-1);

        assert(p->len == sizeof(struct vdp_chkcrc32_cfg_s));
        CAST_OBJ_NOTNULL(vdps->cfg, p->priv, VDP_CHKCRC32_CFG_MAGIC);
        *priv = vdps;

        return (0);
}

static int v_matchproto_(vdp_bytes_f)
xyzzy_chksha256_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        struct vdp_chksha256_s *vdps;

        CAST_OBJ_NOTNULL(vdps, *priv, VDP_CHKSHA256_MAGIC);
        if (len != 0)
                VSHA256_Update(vdps->cx, ptr, len);
        vdps->called++;
        vdps->bytes += len;
        return (VDP_bytes(vdc, act, ptr, len));
}

static int v_matchproto_(vdp_bytes_f)
xyzzy_chkcrc32_bytes(struct vdp_ctx *vdc, enum vdp_action act, void **priv,
    const void *ptr, ssize_t len)
{
        struct vdp_chkcrc32_s *vdps;

        CAST_OBJ_NOTNULL(vdps, *priv, VDP_CHKCRC32_MAGIC);
        if (len > 0)
                vdps->crc = crc32(vdps->crc, ptr, len);
        vdps->called++;
        vdps->bytes += len;
        return (VDP_bytes(vdc, act, ptr, len));
}

static int v_matchproto_(vdp_fini_f)
xyzzy_chksha256_fini(struct vdp_ctx *vdc, void **priv)
{
        unsigned char digest[VSHA256_DIGEST_LENGTH];
        enum vdp_chk_mode_e mode;
        struct vdp_chksha256_s *vdps;
        struct vsb *vsb;
        int r;

        (void) vdc;
        AN(priv);
        if (*priv == NULL)
                return (0);
        TAKE_OBJ_NOTNULL(vdps, priv, VDP_CHKSHA256_MAGIC);

        VSHA256_Final(digest, vdps->cx);
        r = memcmp(digest, vdps->cfg->expected, sizeof digest);
        if (r == 0)
                return (0);

        mode = vdps->cfg->mode;
        if (mode == VDP_CHK_PANIC_UNLESS_ERROR)
                mode = (vdps->called == 0 || vdc->retval != 0) ? VDP_CHK_LOG : VDP_CHK_PANIC;

        if (mode == VDP_CHK_LOG) {
                VSLb(vdc->vsl, SLT_Debug, "sha256 checksum mismatch");

                vsb = VSB_new_auto();
                AN(vsb);
                VSB_quote(vsb, digest, sizeof digest, VSB_QUOTE_HEX);
                AZ(VSB_finish(vsb));
                VSLb(vdc->vsl, SLT_Debug, "got: %s", VSB_data(vsb));

                VSB_clear(vsb);
                VSB_quote(vsb, vdps->cfg->expected, sizeof digest, VSB_QUOTE_HEX);
                AZ(VSB_finish(vsb));
                VSLb(vdc->vsl, SLT_Debug, "exp: %s", VSB_data(vsb));
                VSB_destroy(&vsb);
        }
        else if (mode == VDP_CHK_PANIC)
                WRONG("body checksum");
        else
                WRONG("mode");

        return (0);
}

static int v_matchproto_(vdp_fini_f)
xyzzy_chkcrc32_fini(struct vdp_ctx *vdc, void **priv)
{
        enum vdp_chk_mode_e mode;
        struct vdp_chkcrc32_s *vdps;

        (void) vdc;
        AN(priv);
        if (*priv == NULL)
                return (0);
        TAKE_OBJ_NOTNULL(vdps, priv, VDP_CHKCRC32_MAGIC);

        if (vdps->crc == vdps->cfg->expected)
                return (0);

        mode = vdps->cfg->mode;
        if (mode == VDP_CHK_PANIC_UNLESS_ERROR)
                mode = (vdps->called == 0 || vdc->retval != 0) ? VDP_CHK_LOG : VDP_CHK_PANIC;

        if (mode == VDP_CHK_LOG) {
                VSLb(vdc->vsl, SLT_Debug, "crc32 checksum mismatch");
                VSLb(vdc->vsl, SLT_Debug, "got: %08x", vdps->crc);
                VSLb(vdc->vsl, SLT_Debug, "exp: %08x", vdps->cfg->expected);
        }
        else if (mode == VDP_CHK_PANIC)
                WRONG("body checksum");
        else
                WRONG("mode");

        return (0);
}

static const struct vdp xyzzy_vdp_chksha256 = {
        .name  = "debug.chksha256",
        .init  = xyzzy_chksha256_init,
        .bytes = xyzzy_chksha256_bytes,
        .fini  = xyzzy_chksha256_fini,
};

static const struct vdp xyzzy_vdp_chkcrc32 = {
        .name  = "debug.chkcrc32",
        .init  = xyzzy_chkcrc32_init,
        .bytes = xyzzy_chkcrc32_bytes,
        .fini  = xyzzy_chkcrc32_fini,
};

#define chkcfg(ws, cfg, magic, id, mode_e) do {                                                 \
        struct vmod_priv *p = VRT_priv_task(ctx, id);                                           \
                                                                                                \
        XXXAN(p);                                                                               \
        if (p->priv == NULL) {                                                                  \
                p->priv = WS_Alloc(ws, sizeof *cfg);                                            \
                p->len = sizeof *cfg;                                                           \
        }                                                                                       \
        AN(p->priv);                                                                            \
        cfg = p->priv;                                                                          \
        INIT_OBJ(cfg, magic);                                                                   \
        if (mode_e == VENUM(log))                                                               \
                cfg->mode = VDP_CHK_LOG;                                                        \
        else if (mode_e == VENUM(panic))                                                        \
                cfg->mode = VDP_CHK_PANIC;                                                      \
        else if (mode_e == VENUM(panic_unless_error))                                           \
                cfg->mode = VDP_CHK_PANIC_UNLESS_ERROR;                                         \
        else                                                                                    \
                WRONG("mode");                                                                  \
} while(0)

VCL_VOID v_matchproto_(td_xyzzy_debug_chksha256)
xyzzy_chksha256(VRT_CTX, VCL_BLOB blob, VCL_ENUM mode_e)
{
        struct vdp_chksha256_cfg_s *cfg;
        size_t l;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(blob);
        XXXAN(blob->blob);
        XXXAN(blob->len);

        chkcfg(ctx->ws, cfg, VDP_CHKSHA256_CFG_MAGIC, chksha256_priv_id, mode_e);

        l = blob->len;
        if (l > sizeof cfg->expected)
                l = sizeof cfg->expected;
        memcpy(cfg->expected, blob->blob, l);

}

VCL_VOID v_matchproto_(td_xyzzy_debug_chkcrc32)
xyzzy_chkcrc32(VRT_CTX, VCL_INT expected, VCL_ENUM mode_e)
{
        struct vdp_chkcrc32_cfg_s *cfg;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        chkcfg(ctx->ws, cfg, VDP_CHKCRC32_CFG_MAGIC, chkcrc32_priv_id, mode_e);

        if (expected < 0)
                expected = 0;
        cfg->expected = (uintmax_t)expected % UINT32_MAX;
}

/**********************************************************************
 * reserve thread_workspace
 */

static int v_matchproto_(vdp_init_f)
xyzzy_awshog_init(VRT_CTX, struct vdp_ctx *vdc, void **priv)
{
        struct ws *aws;
        unsigned u;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
        CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
        AN(vdc->clen);
        AN(priv);

        if (ctx->req != NULL)
                aws = ctx->req->wrk->aws;
        else if (ctx->bo != NULL)
                aws = ctx->bo->wrk->aws;
        else
                WRONG("neither req nor bo");

        u = WS_ReserveAll(aws);
        WS_Release(aws, 0);
        (void) WS_Alloc(aws, u);
        return (1);
}

static const struct vdp xyzzy_vdp_awshog = {
        .name  = "debug.awshog",
        .init  = xyzzy_awshog_init
};

void
debug_add_filters(VRT_CTX)
{
        AZ(VRT_AddFilter(ctx, &xyzzy_vfp_rot13, &xyzzy_vdp_rot13));
        AZ(VRT_AddFilter(ctx, NULL, &xyzzy_vdp_pedantic));
        AZ(VRT_AddFilter(ctx, NULL, &xyzzy_vdp_chunked));
        AZ(VRT_AddFilter(ctx, &xyzzy_vfp_slow, &xyzzy_vdp_slow));
        AZ(VRT_AddFilter(ctx, NULL, &xyzzy_vdp_chksha256));
        AZ(VRT_AddFilter(ctx, NULL, &xyzzy_vdp_chkcrc32));
        AZ(VRT_AddFilter(ctx, NULL, &xyzzy_vdp_awshog));
}

void
debug_remove_filters(VRT_CTX)
{
        VRT_RemoveFilter(ctx, &xyzzy_vfp_slow, &xyzzy_vdp_slow);
        VRT_RemoveFilter(ctx, &xyzzy_vfp_rot13, &xyzzy_vdp_rot13);
        VRT_RemoveFilter(ctx, NULL, &xyzzy_vdp_pedantic);
        VRT_RemoveFilter(ctx, NULL, &xyzzy_vdp_chunked);
        VRT_RemoveFilter(ctx, NULL, &xyzzy_vdp_chksha256);
        VRT_RemoveFilter(ctx, NULL, &xyzzy_vdp_chkcrc32);
        VRT_RemoveFilter(ctx, NULL, &xyzzy_vdp_awshog);
}

		varnish-cache/vmod/vmod_debug_filters.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 "vgz.h"
42		#include "vsha256.h"
43		#include "vtim.h"
44		#include "vcc_debug_if.h"
45
46		#include "vmod_debug.h"
47
48		/**********************************************************************/
49
50		static enum vfp_status v_matchproto_(vfp_pull_f)
51	360	xyzzy_vfp_rot13_pull(struct vfp_ctx vc, struct vfp_entry vfe, void *p,
52		ssize_t *lp)
53		{
54		enum vfp_status vp;
55		char *q;
56		ssize_t l;
57
58	360	(void)vfe;
59	360	vp = VFP_Suck(vc, p, lp);
60	360	if (vp == VFP_ERROR)
61	0	return (vp);
62	360	q = p;
63	10440	for (l = 0; l < *lp; l++, q++) {
64	10080	if (q >= 'A' && q <= 'Z')
65	1440	q = (((q - 'A') + 13) % 26) + 'A';
66	10080	if (q >= 'a' && q <= 'z')
67	6840	q = (((q - 'a') + 13) % 26) + 'a';
68	10080	}
69	360	return (vp);
70	360	}
71
72		static const struct vfp xyzzy_vfp_rot13 = {
73		.name = "rot13",
74		.pull = xyzzy_vfp_rot13_pull,
75		};
76
77		/**********************************************************************/
78
79		// deliberately fragmenting the stream to make testing more interesting
80		#define ROT13_BUFSZ 8
81
82		static int v_matchproto_(vdp_init_f)
83	560	xyzzy_vdp_rot13_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
84		{
85
86	560	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
87	560	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
88	560	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
89	560	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
90	560	AN(vdc->clen);
91
92	560	AN(priv);
93
94	560	*priv = malloc(ROT13_BUFSZ);
95	560	if (*priv == NULL)
96	0	return (-1);
97
98	560	return (0);
99	560	}
100
101		static int v_matchproto_(vdp_bytes_f)
102	1080	xyzzy_vdp_rot13_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
103		const void *ptr, ssize_t len)
104		{
105		char *q;
106		const char *pp;
107	1080	int i, j, retval = 0;
108
109	1080	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
110	1080	AN(priv);
111	1080	AN(*priv);
112	1080	if (len <= 0)
113	240	return (VDP_bytes(vdc, act, ptr, len));
114	840	AN(ptr);
115	840	if (act != VDP_END)
116	400	act = VDP_FLUSH;
117	840	q = *priv;
118	840	pp = ptr;
119
120	22120	for (i = 0, j = 0; j < len; i++, j++) {
121	21280	if (pp[j] >= 'A' && pp[j] <= 'Z')
122	1840	q[i] = (((pp[j] - 'A') + 13) % 26) + 'A';
123	19440	else if (pp[j] >= 'a' && pp[j] <= 'z')
124	13320	q[i] = (((pp[j] - 'a') + 13) % 26) + 'a';
125		else
126	6120	q[i] = pp[j];
127	21280	if (i == ROT13_BUFSZ - 1 && j < len - 1) {
128	2200	retval = VDP_bytes(vdc, VDP_FLUSH, q, ROT13_BUFSZ);
129	2200	if (retval != 0)
130	0	return (retval);
131	2200	i = -1;
132	2200	}
133	21280	}
134	840	if (i >= 0)
135	840	retval = VDP_bytes(vdc, act, q, i);
136	840	return (retval);
137	1080	}
138
139		static int v_matchproto_(vdp_fini_f)
140	560	xyzzy_vdp_rot13_fini(struct vdp_ctx vdc, void *priv)
141		{
142	560	(void)vdc;
143	560	AN(priv);
144	560	free(*priv);
145	560	*priv = NULL;
146	560	return (0);
147		}
148
149		static const struct vdp xyzzy_vdp_rot13 = {
150		.name = "rot13",
151		.init = xyzzy_vdp_rot13_init,
152		.bytes = xyzzy_vdp_rot13_bytes,
153		.fini = xyzzy_vdp_rot13_fini,
154		};
155
156		VCL_VOID v_matchproto_(td_debug_rot104)
157	40	xyzzy_rot104(VRT_CTX)
158		{
159
160	40	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
161		// This should fail
162	40	AN(VRT_AddFilter(ctx, &xyzzy_vfp_rot13, &xyzzy_vdp_rot13));
163	40	}
164
165		/**********************************************************************
166		* vdp debug_chunked: force http1 chunked encoding by removing the
167		* Content-Length header
168		*
169		* this happens in a VDP because cnt_transmit() runs after VCL and
170		* restores it
171		*/
172
173		static int v_matchproto_(vdp_init_f)
174	720	xyzzy_vdp_chunked_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
175		{
176
177	720	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
178	720	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
179	720	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
180	720	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
181	720	AN(vdc->clen);
182	720	AN(priv);
183
184	720	http_Unset(vdc->hp, H_Content_Length);
185	720	*vdc->clen = -1;
186
187	720	return (1);
188		}
189
190		static const struct vdp xyzzy_vdp_chunked = {
191		.name = "debug.chunked",
192		.init = xyzzy_vdp_chunked_init,
193		};
194
195		/**********************************************************************
196		* pedantic tests of the VDP API:
197		* - assert that we see a VDP_END
198		* - assert that _fini gets called before the task ends
199		*
200		* note:
201		* we could lookup our own vdpe in _fini and check for vdpe->end == VDP_END
202		* yet that would cross the API
203		*/
204
205		enum vdp_state_e {
206		VDPS_NULL = 0,
207		VDPS_INIT, // _init called
208		VDPS_BYTES, // _bytes called act != VDP_END
209		VDPS_END, // _bytes called act == VDP_END
210		VDPS_FINI // _fini called
211		};
212
213		struct vdp_state_s {
214		unsigned magic;
215		#define VDP_STATE_MAGIC 0x57c8d309
216		enum vdp_state_e state;
217		};
218
219		static void v_matchproto_(vmod_priv_fini_f)
220	7560	priv_pedantic_fini(VRT_CTX, void *priv)
221		{
222		struct vdp_state_s *vdps;
223
224	7560	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
225	7560	CAST_OBJ_NOTNULL(vdps, priv, VDP_STATE_MAGIC);
226
227	7560	assert(vdps->state == VDPS_FINI);
228	7560	}
229
230		static const struct vmod_priv_methods priv_pedantic_methods[1] = {{
231		.magic = VMOD_PRIV_METHODS_MAGIC,
232		.type = "debug_vdp_pedantic",
233		.fini = priv_pedantic_fini
234		}};
235
236		static int v_matchproto_(vdp_init_f)
237	7880	xyzzy_pedantic_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
238		{
239		struct vdp_state_s *vdps;
240		struct vmod_priv *p;
241
242	7880	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
243	7880	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
244	7880	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
245	7880	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
246	7880	AN(vdc->clen);
247	7880	AN(priv);
248
249	15440	WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_STATE_MAGIC);
250	7880	if (vdps == NULL)
251	320	return (-1);
252	7560	assert(vdps->state == VDPS_NULL);
253
254	7560	p = VRT_priv_task(ctx, (void *)vdc);
255	7560	if (p == NULL)
256	0	return (-1);
257	7560	p->priv = vdps;
258	7560	p->methods = priv_pedantic_methods;
259
260	7560	*priv = vdps;
261
262	7560	vdps->state = VDPS_INIT;
263
264	7560	return (0);
265	7880	}
266
267		static int v_matchproto_(vdp_bytes_f)
268	9398	xyzzy_pedantic_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
269		const void *ptr, ssize_t len)
270		{
271		struct vdp_state_s *vdps;
272
273	9398	CAST_OBJ_NOTNULL(vdps, *priv, VDP_STATE_MAGIC);
274	9398	assert(vdps->state >= VDPS_INIT);
275	9398	assert(vdps->state < VDPS_END);
276
277	9398	if (act == VDP_END)
278	2440	vdps->state = VDPS_END;
279		else
280	6958	vdps->state = VDPS_BYTES;
281
282	9398	return (VDP_bytes(vdc, act, ptr, len));
283		}
284
285		static int v_matchproto_(vdp_fini_f)
286	7879	xyzzy_pedantic_fini(struct vdp_ctx vdc, void *priv)
287		{
288		struct vdp_state_s *vdps;
289
290	7879	(void) vdc;
291	7879	AN(priv);
292	7879	if (*priv == NULL)
293	320	return (0);
294	7559	TAKE_OBJ_NOTNULL(vdps, priv, VDP_STATE_MAGIC);
295	7559	assert(vdps->state == VDPS_INIT \|\| vdps->state == VDPS_END);
296	7559	vdps->state = VDPS_FINI;
297
298	7559	return (0);
299	7879	}
300
301		static const struct vdp xyzzy_vdp_pedantic = {
302		.name = "debug.pedantic",
303		.init = xyzzy_pedantic_init,
304		.bytes = xyzzy_pedantic_bytes,
305		.fini = xyzzy_pedantic_fini,
306		};
307
308		/**********************************************************************
309		*
310		* this trivial copy/paste/edit filter (of rot13) was specifically made for
311		* someone who added a DBG_SLOW_BEREQ debug flag. It should actually be turned
312		* in a proper "bandwidth control" filter, but that exceeds an evening's work,
313		* so it's kept for later
314		*/
315
316		static enum vfp_status v_matchproto_(vfp_pull_f)
317	0	xyzzy_vfp_slow_pull(struct vfp_ctx vc, struct vfp_entry vfe, void *p,
318		ssize_t *lp)
319		{
320
321	0	(void)vfe;
322	0	VTIM_sleep(1.0);
323	0	return (VFP_Suck(vc, p, lp));
324		}
325
326		static const struct vfp xyzzy_vfp_slow = {
327		.name = "debug.slow",
328		.pull = xyzzy_vfp_slow_pull,
329		};
330
331		/**********************************************************************/
332
333		static int v_matchproto_(vdp_bytes_f)
334	160	xyzzy_vdp_slow_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
335		const void *ptr, ssize_t len)
336		{
337
338	160	(void)priv;
339	160	VTIM_sleep(1.0);
340	160	return (VDP_bytes(vdc, act, ptr, len));
341		}
342
343		static const struct vdp xyzzy_vdp_slow = {
344		.name = "debug.slow",
345		.bytes = xyzzy_vdp_slow_bytes
346		};
347
348		/*
349		* checksum VDP:
350		* test that the stream of bytes has a certain checksum and either log
351		* or panic
352		*
353		* The sha256 and crc32 variants are basically identical, but the amount of
354		* code does not justify generalizing. (slink)
355		*/
356
357		enum vdp_chk_mode_e {
358		//lint -esym(749, vdp_chk_mode_e::VDP_CHK_INVAL) deliberately not referenced
359		VDP_CHK_INVAL = 0,
360		VDP_CHK_LOG,
361		VDP_CHK_PANIC,
362		VDP_CHK_PANIC_UNLESS_ERROR
363		};
364
365		struct vdp_chksha256_cfg_s {
366		unsigned magic;
367		#define VDP_CHKSHA256_CFG_MAGIC 0x624f5b32
368		enum vdp_chk_mode_e mode;
369		unsigned char expected[VSHA256_DIGEST_LENGTH];
370		};
371
372		struct vdp_chkcrc32_cfg_s {
373		unsigned magic;
374		#define VDP_CHKCRC32_CFG_MAGIC 0x5a7a835c
375		enum vdp_chk_mode_e mode;
376		uint32_t expected;
377		};
378
379		struct vdp_chksha256_s {
380		unsigned magic;
381		#define VDP_CHKSHA256_MAGIC 0x6856e913
382		unsigned called;
383		size_t bytes;
384		struct VSHA256Context cx[1];
385		struct vdp_chksha256_cfg_s *cfg;
386		};
387
388		struct vdp_chkcrc32_s {
389		unsigned magic;
390		#define VDP_CHKCRC32_MAGIC 0x15c03d3c
391		unsigned called;
392		size_t bytes;
393		uint32_t crc;
394		struct vdp_chkcrc32_cfg_s *cfg;
395		};
396
397		static const void * const chksha256_priv_id = &chksha256_priv_id;
398		static const void * const chkcrc32_priv_id = &chkcrc32_priv_id;
399
400		static int v_matchproto_(vdp_init_f)
401	0	xyzzy_chksha256_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
402		{
403		struct vdp_chksha256_s *vdps;
404		struct vmod_priv *p;
405
406	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
407	0	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
408	0	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
409	0	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
410	0	AN(vdc->clen);
411	0	AN(priv);
412
413	0	WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_CHKSHA256_MAGIC);
414	0	if (vdps == NULL)
415	0	return (-1);
416	0	VSHA256_Init(vdps->cx);
417
418	0	p = VRT_priv_task_get(ctx, chksha256_priv_id);
419	0	if (p == NULL)
420	0	return (-1);
421
422	0	assert(p->len == sizeof(struct vdp_chksha256_cfg_s));
423	0	CAST_OBJ_NOTNULL(vdps->cfg, p->priv, VDP_CHKSHA256_CFG_MAGIC);
424	0	*priv = vdps;
425
426	0	return (0);
427	0	}
428
429		static int v_matchproto_(vdp_init_f)
430	0	xyzzy_chkcrc32_init(VRT_CTX, struct vdp_ctx vdc, void *priv)
431		{
432		struct vdp_chkcrc32_s *vdps;
433		struct vmod_priv *p;
434
435	0	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
436	0	CHECK_OBJ_NOTNULL(vdc, VDP_CTX_MAGIC);
437	0	CHECK_OBJ_ORNULL(vdc->oc, OBJCORE_MAGIC);
438	0	CHECK_OBJ_NOTNULL(vdc->hp, HTTP_MAGIC);
439	0	AN(vdc->clen);
440	0	AN(priv);
441
442	0	WS_TASK_ALLOC_OBJ(ctx, vdps, VDP_CHKCRC32_MAGIC);
443	0	if (vdps == NULL)
444	0	return (-1);
445	0	vdps->crc = crc32(0L, Z_NULL, 0);
446
447	0	p = VRT_priv_task_get(ctx, chkcrc32_priv_id);
448	0	if (p == NULL)
449	0	return (-1);
450
451	0	assert(p->len == sizeof(struct vdp_chkcrc32_cfg_s));
452	0	CAST_OBJ_NOTNULL(vdps->cfg, p->priv, VDP_CHKCRC32_CFG_MAGIC);
453	0	*priv = vdps;
454
455	0	return (0);
456	0	}
457
458		static int v_matchproto_(vdp_bytes_f)
459	0	xyzzy_chksha256_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
460		const void *ptr, ssize_t len)
461		{
462		struct vdp_chksha256_s *vdps;
463
464	0	CAST_OBJ_NOTNULL(vdps, *priv, VDP_CHKSHA256_MAGIC);
465	0	if (len != 0)
466	0	VSHA256_Update(vdps->cx, ptr, len);
467	0	vdps->called++;
468	0	vdps->bytes += len;
469	0	return (VDP_bytes(vdc, act, ptr, len));
470		}
471
472		static int v_matchproto_(vdp_bytes_f)
473	0	xyzzy_chkcrc32_bytes(struct vdp_ctx vdc, enum vdp_action act, void *priv,
474		const void *ptr, ssize_t len)
475		{
476		struct vdp_chkcrc32_s *vdps;
477
478	0	CAST_OBJ_NOTNULL(vdps, *priv, VDP_CHKCRC32_MAGIC);
479	0	if (len > 0)
480	0	vdps->crc = crc32(vdps->crc, ptr, len);
481	0	vdps->called++;
482	0	vdps->bytes += len;
483	0	return (VDP_bytes(vdc, act, ptr, len));
484		}
485
486		static int v_matchproto_(vdp_fini_f)
487	0	xyzzy_chksha256_fini(struct vdp_ctx vdc, void *priv)
488		{
489		unsigned char digest[VSHA256_DIGEST_LENGTH];
490		enum vdp_chk_mode_e mode;
491		struct vdp_chksha256_s *vdps;
492		struct vsb *vsb;
493		int r;
494
495	0	(void) vdc;
496	0	AN(priv);
497	0	if (*priv == NULL)
498	0	return (0);
499	0	TAKE_OBJ_NOTNULL(vdps, priv, VDP_CHKSHA256_MAGIC);