GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * 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.
 *
 * HTTP1 Fetch Filters
 *
 * These filters are used for both req.body and beresp.body to handle
 * the HTTP/1 aspects (C-L/Chunked/EOF)
 *
 */

#include "config.h"

#include <inttypes.h>
#include <poll.h>

#include "cache/cache_int.h"
#ifndef TEST_DRIVER
# include "cache/cache_filter.h"
#endif
#include "cache_http1.h"

#include "vct.h"
#include "vtcp.h"

static const unsigned max_chunked_hdr = 32;     // adjust b00007.vtc if changed

#ifndef TEST_DRIVER
static ssize_t
v1f_rxbuf_init(struct http_conn *htc)
{

        AZ(htc->rxbuf_b);
        AZ(htc->rxbuf_e);

        htc->rxbuf_b = WS_Alloc(htc->ws, max_chunked_hdr);
        if (htc->rxbuf_b == NULL)
                return (-1);
        htc->rxbuf_e = htc->rxbuf_b + max_chunked_hdr;
        return (0);
}
#endif

/*
 * fill up rxbuf. If there is pipelined data, move it to the beginning and
 * continue reading after it
 */
static ssize_t
v1f_rxbuf_read(struct http_conn *htc)
{
        ssize_t i;
        size_t av, sz;
        char *p;

        if (htc->pipeline_b)
                AN(htc->pipeline_e);
        else
                AZ(htc->pipeline_e);
        AN(htc->rxbuf_b);
        AN(htc->rxbuf_e);

        sz = pdiff(htc->rxbuf_b, htc->rxbuf_e);

        if (htc->pipeline_b == NULL)
                p = htc->pipeline_b = htc->rxbuf_b;
        else {
                AN(htc->pipeline_e);
                av = pdiff(htc->pipeline_b, htc->pipeline_e);
                if (av >= sz) {
                        // VTCP_Check(): can not originate from read()
                        errno = ENOBUFS;
                        return (-1);
                }
                assert(av < sz);
                memmove(htc->rxbuf_b, htc->pipeline_b, av);
                htc->pipeline_b = htc->rxbuf_b;
                htc->pipeline_e = htc->rxbuf_b + av;
                p = htc->pipeline_e;
                sz -= av;
        }
        do {
                errno = 0;
                i = read(*htc->rfd, p, sz);
        } while (i < 0 && errno == EINTR);
        if (i < 0) {
                VTCP_Assert(i);
                return (i);
        }
        htc->pipeline_e = p + i;
        if (htc->pipeline_b == htc->pipeline_e)
                 htc->pipeline_b = htc->pipeline_e = NULL;
        return (i);
}

/*--------------------------------------------------------------------
 * Parse a chunk tail in the pipeline and return status as appropriate
 */
struct pct { const char *msg; };

static struct pct pct_more[]    = {{"tail more"}};
static struct pct pct_nonl[]    = {{"chunked tail no NL"}};

// the unused parameter is to simplify the macro calling different parsers
static struct pct *
v1f_parse_chunked_tail(char *b, const char *e, void *unused, char **nextp)
{
        AN(b);
        AN(e);
        (void)unused;
        AN(nextp);

        if (b == e)
                return (pct_more);
        if (*b == '\r')
                b++;
        if (b == e)
                return (pct_more);
        if (*b != '\n')
                return (pct_nonl);
        b++;

        *nextp = b;
        return (NULL);
}


/*--------------------------------------------------------------------
 * Parse a chunk header in the pipeline and return status as appropriate
 */

struct pch { const char *msg; };

static struct pch pch_more[]    = {{"more"}};
static struct pch pch_nonhex[]  = {{"chunked header non-hex"}};
static struct pch pch_nonl[]    = {{"chunked header no NL"}};
static struct pch pch_syntax[]  = {{"chunked header number syntax"}}; // can't happen?
static struct pch pch_large[]   = {{"bogusly large chunk size"}};
static struct pch pch_toolong[] = {{"chunked header too long"}};

static struct pch *
v1f_parse_chunked_hdr_i(char *b, const char *e, ssize_t *szp, char **nextp)
{
        char *hb, *he, *q, s;
        uintmax_t cll;
        ssize_t cl;

        AN(b);
        AN(e);
        AN(szp);
        AN(nextp);

        /* Skip leading whitespace - XXX rfc9112 does not specify this */
        while (b < e && vct_isows(*b))
                b++;
        if (b == e)
                return (pch_more);
        if (!vct_ishex(*b))
                return (pch_nonhex);
        /* Skip leading zeros */
        while (b < e - 1 && b[0] == '0' && b[1] == '0')
                b++;
        if (b == e)
                return (pch_more);
        hb = b;
        /* Collect hex digits */
        while (b < e && vct_ishex(*b))
                b++;
        if (b == e)
                return (pch_more);
        he = b;
        /* Skip trailing whitespace. XXX rfc9112 does not specify this
         * XXX extension support missing https://httpwg.org/specs/rfc9112.html#chunked.extension
         */
        while (b < e && vct_isows(*b))
                b++;
        if (b == e)
                return (pch_more);
        if (*b == '\r')
                b++;
        if (b == e)
                return (pch_more);
        if (*b != '\n')
                return (pch_nonl);
        b++;

        errno = 0;
        s = *he;
        *he = '\0';
        cll = strtoumax(hb, &q, 16);
        // restore original for debug-/testability
        *he = s;

        if (q == NULL || q != he)
                return (pch_syntax);

        cl = (ssize_t)cll;
        if (cl < 0 || (uintmax_t)cl != cll)
                return (pch_large);

        // for a number larger than ULLONG_MAX, strtoumax() returns
        // ULLONG_MAX and sets errno to ERANGE. We catch this with the above
        // check already, but assert that we really do
        AZ(errno);

        *szp = cl;
        *nextp = b;
        return (NULL);
}

// length check outside the actual parser for clarity
static struct pch *
v1f_parse_chunked_hdr(char *b, const char *e, ssize_t *szp, char **nextp)
{
        struct pch *r;
        const char *ee;

        ee = vmin_t(const char *, e, b + max_chunked_hdr);

        r = v1f_parse_chunked_hdr_i(b, ee, szp, nextp);

        if (r == pch_more && e != ee)
                return (pch_toolong);

        return (r);
}

#ifdef TEST_DRIVER

#include <stdlib.h>
#include <stdio.h>

// positive test cases have three constituents, we permutate all of them
static const char *t_ok_pre[] = {
        "",
        " ",
        "\t",
        " \t0",
        "00"
};

static const uintmax_t t_ok_sz[] = {
        0,
        1,
        0xa,
        0x10,
        0xaffe,
        SSIZE_MAX
};

static const char *t_ok_post[] = {
        "\r\n",
        "\n",
        " \r\n",
        " \t\n",
};

static const char *t_ok_next[] = {
        "",
        "\r\n",
        "\n",
        "GET",
        "\r\n01234567",
};

struct pch_neg {
        struct pch *r;
        const char *hdr;
};

// negative tests
static struct pch_neg t_neg[] = {
        {pch_more, ""},
        {pch_more, "\t "},

        {pch_nonhex, "x"},
        {pch_nonhex, " x"},
        {pch_nonhex, "\n"},
        {pch_nonhex, "\r"},

        {pch_more, "000"},
        {pch_more, "affe"},
        {pch_more, " a\r"},

        {pch_nonl, " a\rx"},
        {pch_nonl, " ax"},

        {pch_large, "8000000000000000\r\n"},
        {pch_large, "800000000000000000000000\r\n"},
};

// tail
static const char *t_ok_tail[] = {
        "\r\n",
        "\n",
};

static const char *t_ok_tail_next[] = {
        "",
        "0123",
};

struct pct_neg {
        struct pct *r;
        const char *hdr;
};

static struct pct_neg t_neg_tail[] = {
        {pct_more, "\r"},
        {pct_nonl, "\rx"},
};


static void
t_parse_chunked_hdr(char *b, char *e,
    const struct pch *r_exp, ssize_t sz_exp, const char *next_exp)
{
        const struct pch *r;
        char *next = NULL;
        ssize_t sz = -1;
        r = v1f_parse_chunked_hdr(b, e, &sz, &next);
#ifdef DEBUG
        printf("r = %s, sz = 0x%zx, n = %s\n", r ? r->msg : "NULL", sz,
            next ? next : "NULL");
#endif
        assert(r == r_exp);
        assert(sz == sz_exp);
        assert(next == next_exp);
}

static void
t_parse_chunked_hdr_err(char *b, char *e, const struct pch *err)
{
        t_parse_chunked_hdr(b, e, err, -1, NULL);
}

static void
t_parse_chunked_hdr_ok(char *b, char *e,
    ssize_t sz_exp, const char *next_exp)
{
        t_parse_chunked_hdr(b, e, NULL, sz_exp, next_exp);
}

static void
t_parse_chunked_tail(char *b, char *e,
    const struct pct *r_exp, const char *next_exp)
{
        const struct pct *r;
        char *next = NULL;
        r = v1f_parse_chunked_tail(b, e, NULL, &next);
#ifdef DEBUG
        printf("r = %s, n = %s\n", r ? r->msg : "NULL",
            next ? next : "NULL");
#endif
        assert(r == r_exp);
        assert(next == next_exp);
}

void
VSLbs(struct vsl_log *vsl, enum VSL_tag_e tag, const struct strands *s)
{
        (void)vsl;
        (void)tag;
        (void)s;
}
/*
static ssize_t
v1f_rxbuf_read(struct http_conn *htc);
*/
static void
t_rxbuf_read(void) {
        struct http_conn htc[1];
        const char *data = "0123456789abcdef";
        char rxbuf[16];
        int fd[2], i, r;

        assert(strlen(data) == sizeof rxbuf);

        INIT_OBJ(htc, HTTP_CONN_MAGIC);
        // v1f_rxbuf_init without the workspace
        htc->rxbuf_b = rxbuf;
        htc->rxbuf_e = htc->rxbuf_b + sizeof rxbuf;

        AZ(pipe(fd));
        htc->rfd = &fd[0];

        for (i = 0; i < strlen(data); i++) {
                r = write(fd[1], data + i, 1);
                assert(r == 1);
                r = v1f_rxbuf_read(htc);
                assert(r == 1);
                size_t av = pdiff(htc->pipeline_b, htc->pipeline_e);
                assert(av == i + 1);
                AZ(memcmp(htc->pipeline_b, data, av));
                if (i % 2 == 0) {
                        // v1f_rxbuf_read moves pipelined data to the beginning
                        assert(htc->pipeline_b == htc->rxbuf_b);
                        memmove(htc->pipeline_b + 1, htc->pipeline_b, av);
                        htc->pipeline_b++;
                        htc->pipeline_e++;
                }

        }
        // buffer is now full
        r = v1f_rxbuf_read(htc);
        assert(r == -1);
        assert(errno == ENOBUFS);

        close(fd[0]);
        close(fd[1]);
}

int
main(int argc, char *argv[])
{
        (void) argc;
        (void) argv;

        printf("-- rxbuf_read\n");
        t_rxbuf_read();

        printf("-- head postitive test permutations\n");
        // avoid nested loops
        unsigned n_ok = vcountof(t_ok_pre) * vcountof(t_ok_sz) *
            vcountof(t_ok_post) * vcountof(t_ok_next);
        char buf[80];
        for (unsigned n = 0; n < n_ok; n++) {
                unsigned n_pre = n % vcountof(t_ok_pre);
                unsigned n_sz = n / vcountof(t_ok_pre);
                unsigned n_post = n_sz / vcountof(t_ok_sz);
                unsigned n_next = n_post / vcountof(t_ok_post);
                n_sz %= vcountof(t_ok_sz);
                n_post %= vcountof(t_ok_post);
                assert(n_next < vcountof(t_ok_next));

#ifdef DEBUG
                printf("n_next=%u n_post=%u n_sz=%u n_pre=%u\n",
                    n_next, n_post, n_sz, n_pre);
#endif
                bprintf(buf, "%s%jx%s%s", t_ok_pre[n_pre], t_ok_sz[n_sz],
                    t_ok_post[n_post], t_ok_next[n_next]);

                char *ee = buf + strlen(buf) - strlen(t_ok_next[n_next]);

                for (char *e = buf; e < ee; e++)
                        t_parse_chunked_hdr_err(buf, e, pch_more);

                t_parse_chunked_hdr_ok(buf, ee, t_ok_sz[n_sz], ee);
        }

        printf("-- head negative tests\n");
        for (struct pch_neg *neg = t_neg; neg < t_neg + vcountof(t_neg); neg++) {
                size_t l = strlen(neg->hdr);
                assert(l < sizeof buf);

                memcpy(buf, neg->hdr, l + 1);
                char *e = buf + l;

                t_parse_chunked_hdr_err(buf, e, neg->r);
        }

        printf("-- tail postitive test permutations\n");
        n_ok = vcountof(t_ok_tail) * vcountof(t_ok_tail_next);
        for (unsigned n = 0; n < n_ok; n++) {
                unsigned n_tail = n % vcountof(t_ok_tail);
                unsigned n_next = n / vcountof(t_ok_tail_next);
                assert(n_next < vcountof(t_ok_tail_next));

                bprintf(buf, "%s%s", t_ok_tail[n_tail], t_ok_tail_next[n_next]);
                char *ee = buf + strlen(buf) - strlen(t_ok_tail_next[n_next]);

                for (char *e = buf; e < ee; e++)
                        t_parse_chunked_tail(buf, e, pct_more, NULL);

                t_parse_chunked_tail(buf, ee, NULL, ee);
        }

        printf("-- tail negative tests\n");
        for (struct pct_neg *neg = t_neg_tail; neg < t_neg_tail + vcountof(t_neg_tail); neg++) {
                size_t l = strlen(neg->hdr);
                assert(l < sizeof buf);

                memcpy(buf, neg->hdr, l + 1);
                char *e = buf + l;

                t_parse_chunked_tail(buf, e, neg->r, NULL);
        }

        printf("OK\n");
        return (0);
}
#else

/*--------------------------------------------------------------------
 * Read up to len bytes, returning pipelined data first.
 */

enum ahead {
        NO_READ_AHEAD,
        READ_AHEAD
};

static ssize_t
v1f_readahead(struct http_conn *htc, char *p, ssize_t len)
{
        struct iovec iov[2];
        ssize_t i;

        AZ(htc->pipeline_b);
        if (htc->rxbuf_b == NULL && v1f_rxbuf_init(htc)) {
                errno = ENOMEM;
                return (-ENOMEM);
        }
        AN(htc->rxbuf_b);

        iov[0].iov_base = p;
        iov[0].iov_len = len;
        iov[1].iov_base = htc->rxbuf_b;
        iov[1].iov_len = pdiff(htc->rxbuf_b, htc->rxbuf_e);

        i = readv(*htc->rfd, iov, vcountof(iov));
        if (i <= len)
                return (i);
        i -= len;
        htc->pipeline_b = htc->rxbuf_b;
        htc->pipeline_e = htc->rxbuf_b + i;

        return (len);
}

static ssize_t
v1f_read(const struct vfp_ctx *vc, struct http_conn *htc, void *d, ssize_t len,
    enum ahead ahead)
{
        ssize_t l;
        char *p;
        ssize_t i;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
        assert(len > 0);
        l = 0;
        p = d;
        i = 0;
        if (htc->pipeline_b) {
                l = htc->pipeline_e - htc->pipeline_b;
                assert(l > 0);
                l = vmin(l, len);
                memcpy(p, htc->pipeline_b, l);
                p += l;
                len -= l;
                htc->pipeline_b += l;
                if (htc->pipeline_b == htc->pipeline_e)
                        htc->pipeline_b = htc->pipeline_e = NULL;
        }
        if (len > 0) {
                do {
                        errno = 0;
                        if (ahead == NO_READ_AHEAD)
                                i = read(*htc->rfd, p, len);
                        else if (ahead == READ_AHEAD)
                                i = v1f_readahead(htc, p, len);
                        else
                                WRONG("ahead");

                } while (i < 0 && errno == EINTR);
                if (i < 0) {
                        if (ahead == NO_READ_AHEAD || i != -ENOMEM)
                                VTCP_Assert(i);
                        VSLbs(vc->wrk->vsl, SLT_FetchError,
                            TOSTRAND(VAS_errtxt(errno)));
                        return (i);
                }
                assert(i <= len);
        }
        assert(i >= 0);
        assert(l >= 0);
        assert(i < SSIZE_MAX / 2);
        assert(l < SSIZE_MAX / 2);
        return (i + l);
}

static enum vfp_status
v1f_ok(struct http_conn *htc)
{
        if ((htc)->pipeline_b == (htc)->pipeline_e)
                (htc)->pipeline_b = (htc)->pipeline_e = NULL;
        return (VFP_OK);
}


/*--------------------------------------------------------------------
 * Call parser on pipeline:
 * - If pipeline filled, try to return a parse result without reading
 * - else read until either the rxbuf is filled, or we have a parse
 *
 * this is a macro because the code for calling the head and tail parser is
 * _almost_ (but not quite) identical
 */

#define CHUNKED_PARSER(vc, htc, func, func_arg, more, what)                     \
                                                                                \
        ssize_t sz;                                                             \
                                                                                \
        if ((htc)->pipeline_b) {                                                \
                r = func((htc)->pipeline_b, (htc)->pipeline_e,                  \
                        func_arg, &(htc)->pipeline_b);                          \
                if (r == NULL)                                                  \
                        return (v1f_ok(htc));                                   \
                if (r != more)                                                  \
                        return (VFP_Error(vc, "%s", r->msg));                   \
        }                                                                       \
        if ((htc)->rxbuf_b == NULL && v1f_rxbuf_init(htc) != 0)                 \
                return (VFP_Error(vc, "No workspace for rxbuf"));               \
        while ((sz = v1f_rxbuf_read(htc)) > 0) {                                \
                r = func((htc)->pipeline_b, (htc)->pipeline_e,                  \
                    func_arg, &(htc)->pipeline_b);                              \
                if (r == NULL)                                                  \
                        return (v1f_ok(htc));                                   \
                if (r == more)                                                  \
                        continue;                                               \
                VSLb((vc)->wrk->vsl, SLT_Debug, "%.*s",                         \
                    (int)pdiff((htc)->pipeline_b, (htc)->pipeline_e),           \
                    (htc)->pipeline_b);                                         \
                return (VFP_Error(vc, "%s", r->msg));                           \
        }                                                                       \
        if (sz == 0)                                                            \
                return (VFP_Error(vc, "chunked " what " EOF"));                 \
        assert(sz < 0);                                                         \
        VSLbs(vc->wrk->vsl, SLT_FetchError, TOSTRAND(VAS_errtxt(errno)));       \
        return (VFP_Error(vc, "^^^ error reading chunk " what));

/*--------------------------------------------------------------------
 * read (CR)?LF at the end of a chunk
 */

static enum vfp_status
v1f_chunk_end(struct vfp_ctx *vc, struct http_conn *htc)
{
        const struct pct *r;
        CHUNKED_PARSER(vc, htc, v1f_parse_chunked_tail, NULL, pct_more, "tail")
}

/*--------------------------------------------------------------------
 * Parse a chunk header and, for VFP_OK, return size in a pointer
 */

static enum vfp_status
v1f_chunked_hdr(struct vfp_ctx *vc, struct http_conn *htc, ssize_t *szp)
{
        const struct pch *r;
        CHUNKED_PARSER(vc, htc, v1f_parse_chunked_hdr, szp, pch_more, "header")
}

#undef CHUNKED_PARSER

/*--------------------------------------------------------------------
 * Read a chunked HTTP object.
 *
 */

static enum vfp_status v_matchproto_(vfp_pull_f)
v1f_chunked_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *ptr,
    ssize_t *lp)
{
        enum vfp_status vfps;
        struct http_conn *htc;
        ssize_t l, lr;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(htc, vfe->priv1, HTTP_CONN_MAGIC);
        AN(ptr);
        AN(lp);

        l = *lp;
        *lp = 0;
        if (vfe->priv2 == -1) {
                vfps = v1f_chunked_hdr(vc, htc, &vfe->priv2);
                if (vfps != VFP_OK)
                        return (vfps);
        }
        if (vfe->priv2 > 0) {
                if (vfe->priv2 <= l) {
                        l = vfe->priv2;
                        lr = v1f_read(vc, htc, ptr, l, READ_AHEAD);
                } else
                        lr = v1f_read(vc, htc, ptr, l, NO_READ_AHEAD);
                if (lr <= 0)
                        return (VFP_Error(vc, "chunked insufficient bytes"));
                *lp = lr;
                vfe->priv2 -= lr;
                if (vfe->priv2 != 0)
                        return (VFP_OK);

                vfe->priv2 = -1;

                vfps = v1f_chunk_end(vc, htc);
                if (vfps != VFP_OK)
                        return (vfps);

                /* opportunistically check for next chunk header read ahead */
                if (! htc->pipeline_b)
                        return (VFP_OK);

                const struct pch *r = v1f_parse_chunked_hdr(
                    htc->pipeline_b, htc->pipeline_e,
                    &vfe->priv2, &htc->pipeline_b);
                if (r == pch_more)
                        return (VFP_OK);
                if (r != NULL)
                        return (VFP_Error(vc, "%s", r->msg));
                if (vfe->priv2 != 0)
                        return (VFP_OK);
        }
        AZ(vfe->priv2);
        vfps = v1f_chunk_end(vc, htc);
        return (vfps == VFP_OK ? VFP_END : vfps);
}

static const struct vfp v1f_chunked = {
        .name = "V1F_CHUNKED",
        .pull = v1f_chunked_pull,
};


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

static enum vfp_status v_matchproto_(vfp_pull_f)
v1f_straight_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p,
    ssize_t *lp)
{
        ssize_t l, lr;
        struct http_conn *htc;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(htc, vfe->priv1, HTTP_CONN_MAGIC);
        AN(p);
        AN(lp);

        l = *lp;
        *lp = 0;

        if (vfe->priv2 == 0) // XXX: Optimize Content-Len: 0 out earlier
                return (VFP_END);
        l = vmin(l, vfe->priv2);
        lr = v1f_read(vc, htc, p, l, NO_READ_AHEAD);
        if (lr <= 0)
                return (VFP_Error(vc, "straight insufficient bytes"));
        *lp = lr;
        vfe->priv2 -= lr;
        if (vfe->priv2 == 0)
                return (VFP_END);
        return (VFP_OK);
}

static const struct vfp v1f_straight = {
        .name = "V1F_STRAIGHT",
        .pull = v1f_straight_pull,
};

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

static enum vfp_status v_matchproto_(vfp_pull_f)
v1f_eof_pull(struct vfp_ctx *vc, struct vfp_entry *vfe, void *p, ssize_t *lp)
{
        ssize_t l, lr;
        struct http_conn *htc;

        CHECK_OBJ_NOTNULL(vc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
        CAST_OBJ_NOTNULL(htc, vfe->priv1, HTTP_CONN_MAGIC);
        AN(p);

        AN(lp);

        l = *lp;
        *lp = 0;
        lr = v1f_read(vc, htc, p, l, NO_READ_AHEAD);
        if (lr < 0)
                return (VFP_Error(vc, "eof socket fail"));
        if (lr == 0) {
                htc->doclose = SC_RESP_CLOSE;
                return (VFP_END);
        }
        *lp = lr;
        return (VFP_OK);
}

static const struct vfp v1f_eof = {
        .name = "V1F_EOF",
        .pull = v1f_eof_pull,
};

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

int
V1F_Setup_Fetch(struct vfp_ctx *vfc, struct http_conn *htc)
{
        struct vfp_entry *vfe;

        CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);

        AN(htc->ws);
        AZ(htc->ws->r);

        AZ(htc->rxbuf_b);
        AZ(htc->rxbuf_e);

        if (htc->body_status == BS_EOF) {
                assert(htc->content_length == -1);
                vfe = VFP_Push(vfc, &v1f_eof);
                if (vfe == NULL)
                        return (ENOSPC);
                vfe->priv2 = 0;
        } else if (htc->body_status == BS_LENGTH) {
                assert(htc->content_length > 0);
                vfe = VFP_Push(vfc, &v1f_straight);
                if (vfe == NULL)
                        return (ENOSPC);
                vfe->priv2 = htc->content_length;
        } else if (htc->body_status == BS_CHUNKED) {
                assert(htc->content_length == -1);
                vfe = VFP_Push(vfc, &v1f_chunked);
                if (vfe == NULL)
                        return (ENOSPC);
                vfe->priv2 = -1;
        } else {
                WRONG("Wrong body_status");
        }
        vfe->priv1 = htc;
        return (0);
}
#endif

		vinyl-cache/bin/vinyld/http1/cache_http1_vfp.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		* HTTP1 Fetch Filters
31		*
32		* These filters are used for both req.body and beresp.body to handle
33		* the HTTP/1 aspects (C-L/Chunked/EOF)
34		*
35		*/
36
37		#include "config.h"
38
39		#include <inttypes.h>
40		#include <poll.h>
41
42		#include "cache/cache_int.h"
43		#ifndef TEST_DRIVER
44		# include "cache/cache_filter.h"
45		#endif
46		#include "cache_http1.h"
47
48		#include "vct.h"
49		#include "vtcp.h"
50
51		static const unsigned max_chunked_hdr = 32; // adjust b00007.vtc if changed
52
53		#ifndef TEST_DRIVER
54		static ssize_t
55	369	v1f_rxbuf_init(struct http_conn *htc)
56		{
57
58	369	AZ(htc->rxbuf_b);
59	369	AZ(htc->rxbuf_e);
60
61	369	htc->rxbuf_b = WS_Alloc(htc->ws, max_chunked_hdr);
62	369	if (htc->rxbuf_b == NULL)
63	0	return (-1);
64	369	htc->rxbuf_e = htc->rxbuf_b + max_chunked_hdr;
65	369	return (0);
66	369	}
67		#endif
68
69		/*
70		* fill up rxbuf. If there is pipelined data, move it to the beginning and
71		* continue reading after it
72		*/
73		static ssize_t
74	723	v1f_rxbuf_read(struct http_conn *htc)
75		{
76		ssize_t i;
77		size_t av, sz;
78		char *p;
79
80	723	if (htc->pipeline_b)
81	149	AN(htc->pipeline_e);
82		else
83	574	AZ(htc->pipeline_e);
84	723	AN(htc->rxbuf_b);
85	723	AN(htc->rxbuf_e);
86
87	723	sz = pdiff(htc->rxbuf_b, htc->rxbuf_e);
88
89	723	if (htc->pipeline_b == NULL)
90	574	p = htc->pipeline_b = htc->rxbuf_b;
91		else {
92	149	AN(htc->pipeline_e);
93	149	av = pdiff(htc->pipeline_b, htc->pipeline_e);
94	149	if (av >= sz) {
95		// VTCP_Check(): can not originate from read()
96	8	errno = ENOBUFS;
97	8	return (-1);
98		}
99	141	assert(av < sz);
100	141	memmove(htc->rxbuf_b, htc->pipeline_b, av);
101	141	htc->pipeline_b = htc->rxbuf_b;
102	141	htc->pipeline_e = htc->rxbuf_b + av;
103	141	p = htc->pipeline_e;
104	141	sz -= av;
105		}
106	715	do {
107	715	errno = 0;
108	715	i = read(*htc->rfd, p, sz);
109	715	} while (i < 0 && errno == EINTR);
110	715	if (i < 0) {
111	0	VTCP_Assert(i);
112	0	return (i);
113		}
114	715	htc->pipeline_e = p + i;
115	715	if (htc->pipeline_b == htc->pipeline_e)
116	20	htc->pipeline_b = htc->pipeline_e = NULL;
117	715	return (i);
118	723	}
119
120		/*--------------------------------------------------------------------
121		* Parse a chunk tail in the pipeline and return status as appropriate
122		*/
123		struct pct { const char *msg; };
124
125		static struct pct pct_more[] = {{"tail more"}};
126		static struct pct pct_nonl[] = {{"chunked tail no NL"}};
127
128		// the unused parameter is to simplify the macro calling different parsers
129		static struct pct *
130	10014	v1f_parse_chunked_tail(char b, const char e, void unused, char *nextp)
131		{
132	10014	AN(b);
133	10014	AN(e);
134	10014	(void)unused;
135	10014	AN(nextp);
136
137	10014	if (b == e)
138	16	return (pct_more);
139	9998	if (*b == '\r')
140	9798	b++;
141	9998	if (b == e)
142	12	return (pct_more);
143	9986	if (*b != '\n')
144	16	return (pct_nonl);
145	9970	b++;
146
147	9970	*nextp = b;
148	9970	return (NULL);
149	10014	}
150
151
152		/*--------------------------------------------------------------------
153		* Parse a chunk header in the pipeline and return status as appropriate
154		*/
155
156		struct pch { const char *msg; };
157
158		static struct pch pch_more[] = {{"more"}};
159		static struct pch pch_nonhex[] = {{"chunked header non-hex"}};
160		static struct pch pch_nonl[] = {{"chunked header no NL"}};
161		static struct pch pch_syntax[] = {{"chunked header number syntax"}}; // can't happen?
162		static struct pch pch_large[] = {{"bogusly large chunk size"}};
163		static struct pch pch_toolong[] = {{"chunked header too long"}};
164
165		static struct pch *
166	31380	v1f_parse_chunked_hdr_i(char b, const char e, ssize_t szp, char *nextp)
167		{
168		char hb, he, *q, s;
169		uintmax_t cll;
170		ssize_t cl;
171
172	31380	AN(b);
173	31380	AN(e);
174	31380	AN(szp);
175	31380	AN(nextp);
176
177		/* Skip leading whitespace - XXX rfc9112 does not specify this */
178	47084	while (b < e && vct_isows(*b))
179	15704	b++;
180	31380	if (b == e)
181	4328	return (pch_more);
182	27052	if (!vct_ishex(*b))
183	24	return (pch_nonhex);
184		/* Skip leading zeros */
185	34740	while (b < e - 1 && b[0] == '0' && b[1] == '0')
186	7712	b++;
187	27028	if (b == e)
188	0	return (pch_more);
189	27028	hb = b;
190		/* Collect hex digits */
191	137384	while (b < e && vct_ishex(*b))
192	110356	b++;
193	27028	if (b == e)
194	11480	return (pch_more);
195	15548	he = b;
196		/* Skip trailing whitespace. XXX rfc9112 does not specify this
197		* XXX extension support missing https://httpwg.org/specs/rfc9112.html#chunked.extension
198		*/
199	20348	while (b < e && vct_isows(*b))
200	4800	b++;
201	15544	if (b == e)
202	1800	return (pch_more);
203	13744	if (*b == '\r')
204	12530	b++;
205	13744	if (b == e)
206	1342	return (pch_more);
207	12402	if (*b != '\n')
208	8	return (pch_nonl);
209	12394	b++;
210
211	12394	errno = 0;
212	12394	s = *he;
213	12394	*he = '\0';
214	12394	cll = strtoumax(hb, &q, 16);
215		// restore original for debug-/testability
216	12394	*he = s;
217
218	12394	if (q == NULL \|\| q != he)
219	6	return (pch_syntax);
220
221	12388	cl = (ssize_t)cll;
222	12388	if (cl < 0 \|\| (uintmax_t)cl != cll)
223	16	return (pch_large);
224
225		// for a number larger than ULLONG_MAX, strtoumax() returns
226		// ULLONG_MAX and sets errno to ERANGE. We catch this with the above
227		// check already, but assert that we really do
228	12372	AZ(errno);
229
230	12372	*szp = cl;
231	12372	*nextp = b;
232	12372	return (NULL);
233	31370	}
234
235		// length check outside the actual parser for clarity
236		static struct pch *
237	31374	v1f_parse_chunked_hdr(char b, const char e, ssize_t szp, char *nextp)
238		{
239		struct pch *r;
240		const char *ee;
241
242	31374	ee = vmin_t(const char *, e, b + max_chunked_hdr);
243
244	31374	r = v1f_parse_chunked_hdr_i(b, ee, szp, nextp);
245
246	31374	if (r == pch_more && e != ee)
247	4	return (pch_toolong);
248
249	31370	return (r);
250	31374	}
251
252		#ifdef TEST_DRIVER
253
254		#include <stdlib.h>
255		#include <stdio.h>
256
257		// positive test cases have three constituents, we permutate all of them
258		static const char *t_ok_pre[] = {
259		"",
260		" ",
261		"\t",
262		" \t0",
263		"00"
264		};
265
266		static const uintmax_t t_ok_sz[] = {
267		0,
268		1,
269		0xa,
270		0x10,
271		0xaffe,
272		SSIZE_MAX
273		};
274
275		static const char *t_ok_post[] = {
276		"\r\n",
277		"\n",
278		" \r\n",
279		" \t\n",
280		};
281
282		static const char *t_ok_next[] = {
283		"",
284		"\r\n",
285		"\n",
286		"GET",
287		"\r\n01234567",
288		};
289
290		struct pch_neg {
291		struct pch *r;
292		const char *hdr;
293		};
294
295		// negative tests
296		static struct pch_neg t_neg[] = {
297		{pch_more, ""},
298		{pch_more, "\t "},
299
300		{pch_nonhex, "x"},
301		{pch_nonhex, " x"},
302		{pch_nonhex, "\n"},
303		{pch_nonhex, "\r"},
304
305		{pch_more, "000"},
306		{pch_more, "affe"},
307		{pch_more, " a\r"},
308
309		{pch_nonl, " a\rx"},
310		{pch_nonl, " ax"},
311
312		{pch_large, "8000000000000000\r\n"},
313		{pch_large, "800000000000000000000000\r\n"},
314		};
315
316		// tail
317		static const char *t_ok_tail[] = {
318		"\r\n",
319		"\n",
320		};
321
322		static const char *t_ok_tail_next[] = {
323		"",
324		"0123",
325		};
326
327		struct pct_neg {
328		struct pct *r;
329		const char *hdr;
330		};
331
332		static struct pct_neg t_neg_tail[] = {
333		{pct_more, "\r"},
334		{pct_nonl, "\rx"},
335		};
336
337
338		static void
339	21212	t_parse_chunked_hdr(char b, char e,
340		const struct pch r_exp, ssize_t sz_exp, const char next_exp)
341		{
342		const struct pch *r;
343	21212	char *next = NULL;
344	21212	ssize_t sz = -1;
345	21212	r = v1f_parse_chunked_hdr(b, e, &sz, &next);
346		#ifdef DEBUG
347		printf("r = %s, sz = 0x%zx, n = %s\n", r ? r->msg : "NULL", sz,
348		next ? next : "NULL");
349		#endif
350	21212	assert(r == r_exp);
351	21212	assert(sz == sz_exp);
352	21212	assert(next == next_exp);
353	21212	}
354
355		static void
356	18812	t_parse_chunked_hdr_err(char b, char e, const struct pch *err)
357		{
358	18812	t_parse_chunked_hdr(b, e, err, -1, NULL);
359	18812	}
360
361		static void
362	2400	t_parse_chunked_hdr_ok(char b, char e,
363		ssize_t sz_exp, const char *next_exp)
364		{
365	2400	t_parse_chunked_hdr(b, e, NULL, sz_exp, next_exp);
366	2400	}
367
368		static void
369	48	t_parse_chunked_tail(char b, char e,
370		const struct pct r_exp, const char next_exp)
371		{
372		const struct pct *r;
373	48	char *next = NULL;
374	48	r = v1f_parse_chunked_tail(b, e, NULL, &next);
375		#ifdef DEBUG
376		printf("r = %s, n = %s\n", r ? r->msg : "NULL",
377		next ? next : "NULL");
378		#endif
379	48	assert(r == r_exp);
380	48	assert(next == next_exp);
381	48	}
382
383		void
384	0	VSLbs(struct vsl_log vsl, enum VSL_tag_e tag, const struct strands s)
385		{
386	0	(void)vsl;
387	0	(void)tag;
388	0	(void)s;
389	0	}
390		/*
391		static ssize_t
392		v1f_rxbuf_read(struct http_conn *htc);
393		*/
394		static void
395	4	t_rxbuf_read(void) {
396		struct http_conn htc[1];
397	4	const char *data = "0123456789abcdef";
398		char rxbuf[16];
399		int fd[2], i, r;
400
401	4	assert(strlen(data) == sizeof rxbuf);
402
403	4	INIT_OBJ(htc, HTTP_CONN_MAGIC);
404		// v1f_rxbuf_init without the workspace
405	4	htc->rxbuf_b = rxbuf;
406	4	htc->rxbuf_e = htc->rxbuf_b + sizeof rxbuf;
407
408	4	AZ(pipe(fd));
409	4	htc->rfd = &fd[0];
410
411	68	for (i = 0; i < strlen(data); i++) {
412	64	r = write(fd[1], data + i, 1);
413	64	assert(r == 1);
414	64	r = v1f_rxbuf_read(htc);
415	64	assert(r == 1);
416	64	size_t av = pdiff(htc->pipeline_b, htc->pipeline_e);
417	64	assert(av == i + 1);
418	64	AZ(memcmp(htc->pipeline_b, data, av));
419	64	if (i % 2 == 0) {
420		// v1f_rxbuf_read moves pipelined data to the beginning
421	32	assert(htc->pipeline_b == htc->rxbuf_b);
422	32	memmove(htc->pipeline_b + 1, htc->pipeline_b, av);
423	32	htc->pipeline_b++;
424	32	htc->pipeline_e++;
425	32	}
426
427	64	}
428		// buffer is now full
429	4	r = v1f_rxbuf_read(htc);
430	4	assert(r == -1);
431	4	assert(errno == ENOBUFS);
432
433	4	close(fd[0]);
434	4	close(fd[1]);
435	4	}
436
437		int
438	4	main(int argc, char *argv[])
439		{
440	4	(void) argc;
441	4	(void) argv;
442
443	4	printf("-- rxbuf_read\n");
444	4	t_rxbuf_read();
445
446	4	printf("-- head postitive test permutations\n");
447		// avoid nested loops
448	4	unsigned n_ok = vcountof(t_ok_pre) * vcountof(t_ok_sz) *
449		vcountof(t_ok_post) * vcountof(t_ok_next);
450		char buf[80];
451	2404	for (unsigned n = 0; n < n_ok; n++) {
452	2400	unsigned n_pre = n % vcountof(t_ok_pre);
453	2400	unsigned n_sz = n / vcountof(t_ok_pre);
454	2400	unsigned n_post = n_sz / vcountof(t_ok_sz);
455	2400	unsigned n_next = n_post / vcountof(t_ok_post);
456	2400	n_sz %= vcountof(t_ok_sz);
457	2400	n_post %= vcountof(t_ok_post);
458	2400	assert(n_next < vcountof(t_ok_next));
459
460		#ifdef DEBUG
461		printf("n_next=%u n_post=%u n_sz=%u n_pre=%u\n",
462		n_next, n_post, n_sz, n_pre);
463		#endif
464	2400	bprintf(buf, "%s%jx%s%s", t_ok_pre[n_pre], t_ok_sz[n_sz],
465		t_ok_post[n_post], t_ok_next[n_next]);
466
467	2400	char *ee = buf + strlen(buf) - strlen(t_ok_next[n_next]);
468
469	21160	for (char *e = buf; e < ee; e++)
470	18760	t_parse_chunked_hdr_err(buf, e, pch_more);
471
472	2400	t_parse_chunked_hdr_ok(buf, ee, t_ok_sz[n_sz], ee);
473	2400	}
474
475	4	printf("-- head negative tests\n");
476	56	for (struct pch_neg *neg = t_neg; neg < t_neg + vcountof(t_neg); neg++) {
477	52	size_t l = strlen(neg->hdr);
478	52	assert(l < sizeof buf);
479
480	52	memcpy(buf, neg->hdr, l + 1);
481	52	char *e = buf + l;
482
483	52	t_parse_chunked_hdr_err(buf, e, neg->r);
484	52	}
485
486	4	printf("-- tail postitive test permutations\n");
487	4	n_ok = vcountof(t_ok_tail) * vcountof(t_ok_tail_next);
488	20	for (unsigned n = 0; n < n_ok; n++) {
489	16	unsigned n_tail = n % vcountof(t_ok_tail);
490	16	unsigned n_next = n / vcountof(t_ok_tail_next);
491	16	assert(n_next < vcountof(t_ok_tail_next));
492
493	16	bprintf(buf, "%s%s", t_ok_tail[n_tail], t_ok_tail_next[n_next]);
494	16	char *ee = buf + strlen(buf) - strlen(t_ok_tail_next[n_next]);
495
496	40	for (char *e = buf; e < ee; e++)
497	24	t_parse_chunked_tail(buf, e, pct_more, NULL);
498
499	16	t_parse_chunked_tail(buf, ee, NULL, ee);