GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2017 Varnish Software AS
 * Copyright 2026 UPLEX - Nils Goroll Systemoptimierung
 * 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.
 *
 * HTTP request storage and manipulation
 */

#include "config.h"

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

#include "common/heritage.h"

#include "vct.h"
#include "vend.h"
#include "vnum.h"
#include "vtim.h"

#define BODYSTATUS(U, l, n, a, k)                               \
        const struct body_status BS_##U[1] = {{                 \
                .name = #l,                                     \
                .nbr = n,                                       \
                .avail = a,                                     \
                .length_known = k                               \
        }};
#include "tbl/body_status.h"


#define HTTPH(a, b, c) hdr_t b = HDR(a);
#include "tbl/http_headers.h"

hdr_t H__Status = HDR(":status");
hdr_t H__Proto  = HDR(":proto");
hdr_t H__Reason = HDR(":reason");

static char * via_hdr;

/*--------------------------------------------------------------------
 * Perfect hash to rapidly recognize headers from tbl/http_headers.h
 * which have non-zero flags.
 *
 * A suitable algorithm can be found with `gperf`:
 *
 *      tr '" ,' '   ' < include/tbl/http_headers.h |
 *              awk '$1 == "H(" {print $2}' |
 *              gperf --ignore-case
 *
 */

#define GPERF_MIN_WORD_LENGTH 2
#define GPERF_MAX_WORD_LENGTH 19
#define GPERF_MAX_HASH_VALUE 79

static const unsigned char http_asso_values[256] = {
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80,  0, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80,  5, 80, 20,  0,  0,
        5, 10,  5,  5, 80,  0, 15,  0, 20, 80,
        40, 80,  0, 35, 10, 20, 55, 45,  0,  0,
        80, 80, 80, 80, 80, 80, 80,  5, 80, 20,
        0,  0,  5, 10,  5,  5, 80,  0, 15,  0,
        20, 80, 40, 80,  0, 35, 10, 20, 55, 45,
        0,  0, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
        80, 80, 80, 80, 80, 80
};

static struct http_hdrflg {
        hdr_t           *hdr;
        unsigned        flag;
} http_hdrflg[GPERF_MAX_HASH_VALUE + 1] = {
        { NULL }, { NULL }, { NULL }, { NULL },
        { &H_Date },
        { &H_Range },
        { NULL },
        { &H_Referer },
        { &H_Age },
        { &H_From },
        { &H_Keep_Alive },
        { &H_Retry_After },
        { &H_TE },
        { &H_If_Range },
        { &H_ETag },
        { &H_X_Forwarded_For },
        { &H_Expect },
        { &H_Trailer },
        { &H_If_Match },
        { &H_Host },
        { &H_Accept_Language },
        { &H_Accept },
        { &H_If_Modified_Since },
        { &H_If_None_Match },
        { &H_If_Unmodified_Since },
        { NULL },
        { &H_Cookie },
        { &H_Upgrade },
        { &H_Last_Modified },
        { &H_Accept_Charset },
        { &H_Accept_Encoding },
        { &H_Content_MD5 },
        { &H_Content_Type },
        { &H_Content_Range },
        { NULL }, { NULL },
        { &H_Content_Language },
        { &H_Transfer_Encoding },
        { &H_Authorization },
        { &H_Content_Length },
        { &H_User_Agent },
        { &H_Server },
        { &H_Expires },
        { &H_Location },
        { NULL },
        { &H_Set_Cookie },
        { &H_Content_Encoding },
        { &H_Max_Forwards },
        { &H_Cache_Control },
        { NULL },
        { &H_Connection },
        { &H_Pragma },
        { NULL },
        { &H_Accept_Ranges },
        { &H_HTTP2_Settings },
        { &H_Allow },
        { &H_Content_Location },
        { NULL },
        { &H_Proxy_Authenticate },
        { &H_Vary },
        { NULL },
        { &H_WWW_Authenticate },
        { &H_Warning },
        { &H_Via },
        { NULL }, { NULL }, { NULL }, { NULL },
        { NULL }, { NULL }, { NULL }, { NULL },
        { NULL }, { NULL }, { NULL }, { NULL },
        { NULL }, { NULL }, { NULL },
        { &H_Proxy_Authorization }
};

static struct http_hdrflg *
http_hdr_flags(const char *b, const char *e)
{
        unsigned u;
        struct http_hdrflg *retval;

        if (b == NULL || e == NULL)
                return (NULL);
        u = pdiff(b, e);
        if (u < GPERF_MIN_WORD_LENGTH || u > GPERF_MAX_WORD_LENGTH)
                return (NULL);
        u += http_asso_values[(uint8_t)(e[-1])] +
             http_asso_values[(uint8_t)(b[0])];
        if (u > GPERF_MAX_HASH_VALUE)
                return (NULL);
        retval = &http_hdrflg[u];
        if (retval->hdr == NULL)
                return (NULL);
        AN(*retval->hdr);
        if (!http_hdr_at(*retval->hdr + 1, b, e - b))
                return (NULL);
        return (retval);
}

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

static void
http_init_hdr(hdr_t hdr, int flg)
{
        struct http_hdrflg *f;

        f = http_hdr_flags(hdr->str, hdr->str + hdr->len - 1);
        AN(f);
        assert(*f->hdr == hdr);
        f->flag = flg;
}

void
HTTP_Init(void)
{
        struct vsb *vsb;

#define HTTPH(a, b, c) http_init_hdr(b, c);
#include "tbl/http_headers.h"

        vsb = VSB_new_auto();
        AN(vsb);
        VSB_printf(vsb, "1.1 %s (Vinyl-Cache/" PACKAGE_BRANCH ")",
            heritage.identity);
        AZ(VSB_finish(vsb));
        REPLACE(via_hdr, VSB_data(vsb));
        VSB_destroy(&vsb);
}

/*--------------------------------------------------------------------
 * These two functions are in an incestuous relationship with the
 * order of macros in include/tbl/vsl_tags_http.h
 *
 * The http->logtag is the SLT_*Method enum, and we add to that, to
 * get the SLT_ to use.
 */

static void
http_VSLH(const struct http *hp, unsigned hdr)
{
        int i;

        if (hp->vsl != NULL) {
                assert(VXID_TAG(hp->vsl->wid));
                i = hdr;
                if (i > HTTP_HDR_FIRST)
                        i = HTTP_HDR_FIRST;
                i += hp->logtag;
                VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
        }
}

static void
http_VSLH_del(const struct http *hp, unsigned hdr)
{
        int i;

        if (hp->vsl != NULL) {
                /* We don't support unsetting stuff in the first line */
                assert (hdr >= HTTP_HDR_FIRST);
                assert(VXID_TAG(hp->vsl->wid));
                i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
                i += hp->logtag;
                VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
        }
}

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

void
http_VSL_log(const struct http *hp)
{
        unsigned u;

        for (u = 0; u < hp->nhd; u++)
                if (hp->hd[u].b != NULL)
                        http_VSLH(hp, u);
}

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

static void
http_fail(const struct http *hp)
{
        char id[WS_ID_SIZE];

        VSC_C_main->losthdr++;
        WS_Id(hp->ws, id);
        VSLb(hp->vsl, SLT_Error, "out of workspace (%s)", id);
        WS_MarkOverflow(hp->ws);
}

/*--------------------------------------------------------------------
 * List of canonical HTTP response code names from RFC2616
 */

static struct http_msg {
        unsigned        nbr;
        const char      *status;
        const char      *txt;
} http_msg[] = {
#define HTTP_RESP(n, t) { n, #n, t},
#include "tbl/http_response.h"
        { 0, "0", NULL }
};

const char *
http_Status2Reason(unsigned status, const char **sstr)
{
        struct http_msg *mp;

        status %= 1000;
        assert(status >= 100);
        for (mp = http_msg; mp->nbr != 0 && mp->nbr <= status; mp++)
                if (mp->nbr == status) {
                        if (sstr)
                                *sstr = mp->status;
                        return (mp->txt);
                }
        return ("Unknown HTTP Status");
}

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

unsigned
HTTP_estimate(unsigned nhttp)
{

        /* XXX: We trust the structs to size-aligned as necessary */
        return (PRNDUP(sizeof(struct http) + sizeof(txt) * nhttp + nhttp));
}

struct http *
HTTP_create(void *p, uint16_t nhttp, unsigned len)
{
        struct http *hp;

        hp = p;
        hp->magic = HTTP_MAGIC;
        hp->hd = (void*)(hp + 1);
        hp->shd = nhttp;
        hp->hdf = (void*)(hp->hd + nhttp);
        assert((unsigned char*)p + len == hp->hdf + PRNDUP(nhttp));
        return (hp);
}

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

void
HTTP_Setup(struct http *hp, struct ws *ws, struct vsl_log *vsl,
    enum VSL_tag_e  whence)
{
        http_Teardown(hp);
        hp->nhd = HTTP_HDR_FIRST;
        hp->logtag = whence;
        hp->ws = ws;
        hp->vsl = vsl;
        hp->wkm = WKM_UNKNOWN;
}

/*--------------------------------------------------------------------
 * http_Teardown() is a safety feature, we use it to zap all http
 * structs once we're done with them, to minimize the risk that
 * old stale pointers exist to no longer valid stuff.
 */

void
http_Teardown(struct http *hp)
{

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        AN(hp->shd);
        memset(&hp->nhd, 0, sizeof *hp - offsetof(struct http, nhd));
        memset(hp->hd, 0, sizeof *hp->hd * hp->shd);
        memset(hp->hdf, 0, sizeof *hp->hdf * hp->shd);
}

/*--------------------------------------------------------------------
 * Duplicate the http content into another http
 * We cannot just memcpy the struct because the hd & hdf are private
 * storage to the struct http.
 */

void
HTTP_Dup(struct http *to, const struct http * fm)
{

        assert(fm->nhd <= to->shd);
        vmemcpy(to->hd, fm->hd, fm->nhd * sizeof *to->hd);
        vmemcpy(to->hdf, fm->hdf, fm->nhd * sizeof *to->hdf);
        to->nhd = fm->nhd;
        to->logtag = fm->logtag;
        to->status = fm->status;
        to->protover = fm->protover;
        to->wkm = fm->wkm;
}


/*--------------------------------------------------------------------
 * Clone the entire http structure, including vsl & ws
 */

void
HTTP_Clone(struct http *to, const struct http * const fm)
{

        HTTP_Dup(to, fm);
        to->vsl = fm->vsl;
        to->ws = fm->ws;
}

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

void
http_Proto(struct http *to)
{
        const char *fm;

        fm = to->hd[HTTP_HDR_PROTO].b;

        if (fm != NULL &&
            (fm[0] == 'H' || fm[0] == 'h') &&
            (fm[1] == 'T' || fm[1] == 't') &&
            (fm[2] == 'T' || fm[2] == 't') &&
            (fm[3] == 'P' || fm[3] == 'p') &&
            fm[4] == '/' &&
            vct_isdigit(fm[5]) &&
            fm[6] == '.' &&
            vct_isdigit(fm[7]) &&
            fm[8] == '\0') {
                to->protover = 10 * (fm[5] - '0') + (fm[7] - '0');
        } else {
                to->protover = 0;
        }
}

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

void
http_SetH(struct http *to, unsigned n, const char *header)
{

        assert(n < to->nhd);
        AN(header);
        to->hd[n].b = TRUST_ME(header);
        to->hd[n].e = strchr(to->hd[n].b, '\0');
        to->hdf[n] = 0;
        http_VSLH(to, n);
        if (n == HTTP_HDR_PROTO)
                http_Proto(to);
        if (n == HTTP_HDR_METHOD)
                http_SetWellKnownMethod(to);
}

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

static void
http_PutField(struct http *to, int field, const char *string)
{
        const char *p;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        p = WS_Copy(to->ws, string, -1);
        if (p == NULL) {
                http_fail(to);
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(string));
                return;
        }
        http_SetH(to, field, p);
}

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

int
http_IsHdr(const txt *hh, hdr_t hdr)
{

        Tcheck(*hh);
        CHECK_HDR(hdr);
        return (http_hdr_at(hdr->str, hh->b, hdr->len));
}

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

static unsigned
http_findhdr(const struct http *hp, unsigned l, const char *hdr)
{
        unsigned u;

        for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (hp->hd[u].e < hp->hd[u].b + l + 1)
                        continue;
                if (hp->hd[u].b[l] != ':')
                        continue;
                if (!http_hdr_at(hdr, hp->hd[u].b, l))
                        continue;
                return (u);
        }
        return (0);
}

/*--------------------------------------------------------------------
 * Count how many instances we have of this header
 */

unsigned
http_CountHdr(const struct http *hp, hdr_t hdr)
{
        unsigned retval = 0;
        unsigned u;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (http_IsHdr(&hp->hd[u], hdr))
                        retval++;
        }
        return (retval);
}

/*--------------------------------------------------------------------
 * This function collapses multiple header lines of the same name.
 * The lines are joined with a comma, according to [rfc2616, 4.2bot, p32]
 *
 * XXX Collection of issues / open questions with the CollectHdr family of
 * functions
 * - should know which header is list-type, attempting collect on singleton
 *   should fail (in particular Host)
 *   - For list type, consider "value, containing, comma" vs v1, v2
 *   - but no complete list exists
 * - should offer to keep uniqe values only (Content-Length)
 * - should skip h2 pseudo headers (starting with :)
 * - check for empty elements (",   ,")
 *
 * Worthwile historic reading: 653d3912245c4010a3e0fb4c3c376fb2cd816c04
 */

void
http_CollectHdr(struct http *hp, hdr_t hdr)
{

        http_CollectHdrSep(hp, hdr, NULL);
}

/*--------------------------------------------------------------------
 * You may prefer to collapse header fields using a different separator.
 * For Cookie headers, the separator is "; " for example. That's probably
 * the only example too.
 */

static int
http_CollectHdrSepFrom(struct http *hp, unsigned char hdl, const char *hds,
    const char *sep, unsigned lsep, unsigned f);

void
http_CollectHdrSep(struct http *hp, hdr_t hdr, const char *sep)
{
        unsigned lsep, f;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        CHECK_HDR(hdr);

        if (WS_Overflowed(hp->ws))
                return;

        if (sep == NULL || *sep == '\0')
                sep = ", ";
        lsep = vstrlen(sep);

        f = http_findhdr(hp, hdr->len - 1, hdr->str);
        if (f == 0)
                return;

        (void)http_CollectHdrSepFrom(hp, hdr->len, hdr->str, sep, lsep, f);
}

/*
 * implements the actual collection from header index f
 *
 * returns 1 if collected, 0 if not and -1 for error
 */

static int
http_CollectHdrSepFrom(struct http *hp, unsigned char hdl, const char *hds,
    const char *sep, unsigned lsep, unsigned f)
{
        unsigned u, ml, x, d;
        char *b = NULL, *e = NULL;
        const char *v;
        for (d = u = f + 1; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (! http_hdr_at(hds, hp->hd[u].b, hdl)) {
                        if (d != u) {
                                hp->hd[d] = hp->hd[u];
                                hp->hdf[d] = hp->hdf[u];
                        }
                        d++;
                        continue;
                }
                if (b == NULL) {
                        http_VSLH_del(hp, f);
                        /* Found second header, start our collection */
                        ml = WS_ReserveAll(hp->ws);
                        b = WS_Reservation(hp->ws);
                        e = b + ml;
                        x = Tlen(hp->hd[f]);
                        if (b + x >= e) {
                                http_fail(hp);
                                VSLbs(hp->vsl, SLT_LostHeader,
                                    TOSTRAND(hds));
                                WS_Release(hp->ws, 0);
                                return (-1);
                        }
                        vmemcpy(b, hp->hd[f].b, x);
                        b += x;
                }
                http_VSLH_del(hp, u);

                AN(b);
                AN(e);

                /* Append the Nth header we found */
                x = Tlen(hp->hd[u]) - hdl;

                v = hp->hd[u].b + hdl;
                while (vct_issp(*v)) {
                        v++;
                        x--;
                }

                if (b + lsep + x >= e) {
                        http_fail(hp);
                        VSLbs(hp->vsl, SLT_LostHeader, TOSTRAND(hds));
                        WS_Release(hp->ws, 0);
                        return (-1);
                }
                vmemcpy(b, sep, lsep);
                b += lsep;
                vmemcpy(b, v, x);
                b += x;
        }
        if (b == NULL)
                return (0);
        hp->nhd = (uint16_t)d;
        AN(e);
        *b = '\0';
        hp->hd[f].b = WS_Reservation(hp->ws);
        hp->hd[f].e = b;
        http_VSLH(hp, f);
        WS_ReleaseP(hp->ws, b + 1);
        return (1);
}

/*
 * this respects the two exceptions for combining field values: Cookie, which
 * uses "; ", and Set-Cookie, which can not be combined.
 *
 * All other cases need to be catered for in VCL (e.g. by copying again from
 * req0)
 */
void
http_CollectAllHdrs(struct http *hp)
{
        const unsigned lsep = 2;
        unsigned f;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        for (f = HTTP_HDR_FIRST; f < hp->nhd; f++) {
                Tcheck(hp->hd[f]);
                if (http_IsHdr(&hp->hd[f], H_Set_Cookie))
                        continue;
                const char *sep = http_IsHdr(&hp->hd[f], H_Cookie) ?
                        "; " : ", ";
                assert(vstrlen(sep) == lsep);

                const char *e = strchr(hp->hd[f].b, ':');
                // XXX bad, how to handle?
                if (e == NULL)
                        continue;

                e++;
                size_t l = e - hp->hd[f].b;
                assert(l <= UCHAR_MAX);

                int i = http_CollectHdrSepFrom(hp, (unsigned char)l,
                    hp->hd[f].b, sep, lsep, f);
                if (i < 0)
                        return;
        }
}

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

int
http_GetHdr(const struct http *hp, hdr_t hdr, const char **ptr)
{
        unsigned u;
        const char *p;

        CHECK_HDR(hdr);
        u = http_findhdr(hp, hdr->len - 1, hdr->str);
        if (u == 0) {
                if (ptr != NULL)
                        *ptr = NULL;
                return (0);
        }
        if (ptr != NULL) {
                p = hp->hd[u].b + hdr->len;
                while (vct_issp(*p))
                        p++;
                *ptr = p;
        }
        return (1);
}

/*-----------------------------------------------------------------------------
 * Split source string at any of the separators, return pointer to first
 * and last+1 char of substrings, with whitespace trimmed at both ends.
 * If sep being an empty string is shorthand for VCT::SP
 * If stop is NULL, src is NUL terminated.
 */

static int
http_split(const char **src, const char *stop, const char *sep,
    const char **b, const char **e)
{
        const char *p, *q;

        AN(src);
        AN(*src);
        AN(sep);
        AN(b);
        AN(e);

        if (stop == NULL)
                stop = strchr(*src, '\0');

        for (p = *src; p < stop && (vct_issp(*p) || strchr(sep, *p)); p++)
                continue;

        if (p >= stop) {
                *b = NULL;
                *e = NULL;
                return (0);
        }

        *b = p;
        if (*sep == '\0') {
                for (q = p + 1; q < stop && !vct_issp(*q); q++)
                        continue;
                *e = q;
                *src = q;
                return (1);
        }
        for (q = p + 1; q < stop && !strchr(sep, *q); q++)
                continue;
        *src = q;
        while (q > p && vct_issp(q[-1]))
                q--;
        *e = q;
        return (1);
}

/*-----------------------------------------------------------------------------
 * Comparison rule for tokens:
 *      if target string starts with '"', we use memcmp() and expect closing
 *      double quote as well
 *      otherwise we use http_tok_at()
 *
 * On match we increment *bp past the token name.
 */

static int
http_istoken(const char **bp, const char *e, const char *token)
{
        int fl = vstrlen(token);
        const char *b;

        AN(bp);
        AN(e);
        AN(token);

        b = *bp;

        if (b + fl + 2 <= e && *b == '"' &&
            !vmemcmp(b + 1, token, fl) && b[fl + 1] == '"') {
                *bp += fl + 2;
                return (1);
        }
        if (b + fl <= e && http_tok_at(b, token, fl) &&
            (b + fl == e || !vct_istchar(b[fl]))) {
                *bp += fl;
                return (1);
        }
        return (0);
}

/*-----------------------------------------------------------------------------
 * Find a given data element (token) in a header according to RFC2616's #rule
 * (section 2.1, p15)
 *
 * On case sensitivity:
 *
 * Section 4.2 (Messages Headers) defines field (header) name as case
 * insensitive, but the field (header) value/content may be case-sensitive.
 *
 * http_GetHdrToken looks up a token in a header value and the rfc does not say
 * explicitly if tokens are to be compared with or without respect to case.
 *
 * But all examples and specific statements regarding tokens follow the rule
 * that unquoted tokens are to be matched case-insensitively and quoted tokens
 * case-sensitively.
 *
 * The optional pb and pe arguments will point to the token content start and
 * end+1, white space trimmed on both sides.
 */

int
http_GetHdrToken(const struct http *hp, hdr_t hdr,
    const char *token, const char **pb, const char **pe)
{
        const char *h, *b, *e;

        if (pb != NULL)
                *pb = NULL;
        if (pe != NULL)
                *pe = NULL;
        if (!http_GetHdr(hp, hdr, &h))
                return (0);
        AN(h);

        while (http_split(&h, NULL, ",", &b, &e))
                if (http_istoken(&b, e, token))
                        break;
        if (b == NULL)
                return (0);
        if (pb != NULL) {
                for (; vct_islws(*b); b++)
                        continue;
                if (b == e) {
                        b = NULL;
                        e = NULL;
                }
                *pb = b;
                if (pe != NULL)
                        *pe = e;
        }
        return (1);
}

/*--------------------------------------------------------------------
 * Find a given header field's quality value (qvalue).
 */

double
http_GetHdrQ(const struct http *hp, hdr_t hdr, const char *field)
{
        const char *hb, *he, *b, *e;
        int i;
        double a, f;

        i = http_GetHdrToken(hp, hdr, field, &hb, &he);
        if (!i)
                return (0.);

        if (hb == NULL)
                return (1.);
        while (http_split(&hb, he, ";", &b, &e)) {
                if (*b != 'q')
                        continue;
                for (b++; b < e && vct_issp(*b); b++)
                        continue;
                if (b == e || *b != '=')
                        continue;
                break;
        }
        if (b == NULL)
                return (1.);
        for (b++; b < e && vct_issp(*b); b++)
                continue;
        if (b == e || (*b != '.' && !vct_isdigit(*b)))
                return (0.);
        a = 0;
        while (b < e && vct_isdigit(*b)) {
                a *= 10.;
                a += *b - '0';
                b++;
        }
        if (b == e || *b++ != '.')
                return (a);
        f = .1;
        while (b < e && vct_isdigit(*b)) {
                a += f * (*b - '0');
                f *= .1;
                b++;
        }
        return (a);
}

/*--------------------------------------------------------------------
 * Find a given header field's value.
 */

int
http_GetHdrField(const struct http *hp, hdr_t hdr,
    const char *field, const char **ptr)
{
        const char *h;
        int i;

        if (ptr != NULL)
                *ptr = NULL;

        h = NULL;
        i = http_GetHdrToken(hp, hdr, field, &h, NULL);
        if (!i)
                return (i);

        if (ptr != NULL && h != NULL) {
                /* Skip whitespace, looking for '=' */
                while (*h && vct_issp(*h))
                        h++;
                if (*h == '=') {
                        h++;
                        while (*h && vct_issp(*h))
                                h++;
                        *ptr = h;
                }
        }
        return (i);
}

/*--------------------------------------------------------------------
 * Return the content length if all Content-Length headers are well formed and
 * agree. Remove agreeing duplicates. Normalize to no leading zeroes.
 *
 * Returns -1 for no content length, -2 for malformed.
 *
 * The surviving C-L header is normalized to not contain leading zeroes in order
 * to support vcl like if (req.http.Content-Length ~ "^\d{3}"). If all headers
 * had leading zeroes or list values, we generate a new one
 */

ssize_t
http_GetContentLength(struct http *hp)
{
        txt first = { NULL, NULL };
        ssize_t cl = -1;        // default no length
        uint16_t u, v;
        int need = 1;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        // basically the same outer loop as http_Unset
        for (v = u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (http_IsHdr(&hp->hd[u], H_Content_Length)) {
                        const char *b = hp->hd[u].b + H_Content_Length->len;

                        while (vct_issp(*b))
                                b++;

                        // leading zeroes are not canonical
                        int noncanon = (pdiff(b, hp->hd[u].e) > 1 && b[0] == '0');

                        ssize_t l = VNUM_uint(b, NULL, &b);
                        ssize_t ll = l;

                        for (;;) {
                                // malformed numbers and mismatches to previous
                                // are hard errors
                                if (l < 0 || ll != l) {
                                        l = -2;
                                        break;
                                }

                                while (vct_isows(*b))
                                        b++;
                                if (*b == '\0')
                                        break;
                                if (*b != ',') {
                                        l = -2;
                                        break;
                                }
                                b++;

                                // list values are not canonical
                                noncanon = 1;
                                while (vct_issp(*b))
                                        b++;
                                if (*b == '\0')
                                        break;
                                ll = l;
                                l = VNUM_uint(b, NULL, &b);
                        }

                        assert(l == -2 || l >= 0);
                        assert(cl >= -2);

                        // note good cl or log errors
                        if (l == -2) {
                                cl = -2;
                                VSLb(hp->vsl, SLT_HttpGarbage, "%.*s",
                                    (int)pdiff(hp->hd[u].b, hp->hd[u].e), hp->hd[u].b);
                        } else if (cl == -1)
                                cl = l;
                        else if (l != cl) {
                                cl = -2;

                                AN(first.b);
                                VSLb(hp->vsl, SLT_HttpGarbage, "mismatch: %.*s",
                                    (int)pdiff(hp->hd[u].b, hp->hd[u].e), hp->hd[u].b);
                                VSLb(hp->vsl, SLT_HttpGarbage, "first   : %.*s",
                                    (int)pdiff(first.b, first.e), first.b);
                        }

                        // Return early if wrong and all headers kept
                        if (cl == -2 && v == u)
                                return (cl);

                        // track for logging, by value because the
                        // compaction below can move this slot
                        if (first.b == NULL)
                                first = hp->hd[u];

                        // decide if to keep header
                        if (cl >= 0 && need && !noncanon) {
                                need = 0;
                        } else if (cl >= 0) {
                                http_VSLH_del(hp, u);
                                continue;
                        }
                }

                if (v != u) {
                        vmemcpy(&hp->hd[v], &hp->hd[u], sizeof *hp->hd);
                        vmemcpy(&hp->hdf[v], &hp->hdf[u], sizeof *hp->hdf);
                }
                v++;
        }
        hp->nhd = v;

        if (cl >= 0 && need) {
                // we have deleted all headers above
                http_PrintfHeader(hp, "Content-Length: %zd", cl);
        }

        return (cl);
}

ssize_t
http_GetContentRange(const struct http *hp, ssize_t *lo, ssize_t *hi)
{
        ssize_t tmp, cl;
        const char *b, *t;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        if (lo == NULL)
                lo = &tmp;
        if (hi == NULL)
                hi = &tmp;

        *lo = *hi = -1;

        if (!http_GetHdr(hp, H_Content_Range, &b))
                return (-1);

        t = strchr(b, ' ');
        if (t == NULL)
                return (-2);            // Missing space after range unit

        if (!http_range_at(b, bytes, t - b))
                return (-1);            // Unknown range unit, ignore
        b = t + 1;

        if (*b == '*') {                // Content-Range: bytes */123
                *lo = *hi = -1;
                b++;
        } else {                        // Content-Range: bytes 1-2/3
                *lo = VNUM_uint(b, NULL, &b);
                if (*lo < 0)
                        return (-2);
                if (*b != '-')
                        return (-2);
                *hi = VNUM_uint(b + 1, NULL, &b);
                if (*hi < 0)
                        return (-2);
        }
        if (*b != '/')
                return (-2);
        if (b[1] == '*') {              // Content-Range: bytes 1-2/*
                cl = -1;
                b += 2;
        } else {
                cl = VNUM_uint(b + 1, NULL, &b);
                if (cl <= 0)
                        return (-2);
        }
        while (vct_isows(*b))
                b++;
        if (*b != '\0')
                return (-2);
        if (*lo > *hi)
                return (-2);
        assert(cl >= -1);
        if (*lo >= cl || *hi >= cl)
                return (-2);
        AN(cl);
        return (cl);
}

const char *
http_GetRange(const struct http *hp, ssize_t *lo, ssize_t *hi, ssize_t len)
{
        ssize_t tmp_lo, tmp_hi;
        const char *b, *t;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        if (lo == NULL)
                lo = &tmp_lo;
        if (hi == NULL)
                hi = &tmp_hi;

        *lo = *hi = -1;

        if (!http_GetHdr(hp, H_Range, &b))
                return (NULL);

        // rfc9110,l,6481,6484
        if (!http_method_eq(hp->wkm, WKM_GET))
                return (NULL);

        t = strchr(b, '=');
        if (t == NULL)
                return ("Missing '='");

        if (!http_range_at(b, bytes, t - b))
                return ("Not Bytes");
        b = t + 1;

        *lo = VNUM_uint(b, NULL, &b);
        if (*lo == -2)
                return ("Low number too big");
        if (*b++ != '-')
                return ("Missing hyphen");

        *hi = VNUM_uint(b, NULL, &b);
        if (*hi == -2)
                return ("High number too big");
        if (*lo == -1 && *hi == -1)
                return ("Neither high nor low");
        if (*lo == -1 && *hi == 0)
                return ("No low, high is zero");
        if (*hi >= 0 && *hi < *lo)
                return ("high smaller than low");

        while (vct_isows(*b))
                b++;
        if (*b != '\0')
                return ("Trailing stuff");

        assert(*lo >= -1);
        assert(*hi >= -1);

        if (*lo < 0) {
                assert(*hi > 0);
                *lo = len - *hi;
                if (*lo < 0)
                        *lo = 0;
                *hi = len - 1;
        } else if (len >= 0 && (*hi >= len || *hi < 0)) {
                *hi = len - 1;
        }

        if (len <= 0)
                return (NULL);                  // Allow 200 response

        if (*lo >= len)
                return ("low range beyond object");

        return (NULL);
}

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

stream_close_t
http_DoConnection(struct http *hp, stream_close_t sc_close)
{
        const char *h, *b, *e;
        stream_close_t retval;
        unsigned u, v;
        struct http_hdrflg *f;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        assert(sc_close == SC_REQ_CLOSE || sc_close == SC_RESP_CLOSE);

        if (hp->protover == 10)
                retval = SC_REQ_HTTP10;
        else
                retval = SC_NULL;

        http_CollectHdr(hp, H_Connection);
        if (!http_GetHdr(hp, H_Connection, &h))
                return (retval);
        AN(h);
        while (http_split(&h, NULL, ",", &b, &e)) {
                u = pdiff(b, e);
                if (u == 5 && http_hdr_at(b, "close", u))
                        retval = sc_close;
                if (u == 10 && http_hdr_at(b, "keep-alive", u))
                        retval = SC_NULL;

                /* Refuse removal of well-known-headers if they would pass. */
                f = http_hdr_flags(b, e);
                if (f != NULL && !(f->flag & HTTPH_R_PASS))
                        return (SC_RX_BAD);

                for (v = HTTP_HDR_FIRST; v < hp->nhd; v++) {
                        Tcheck(hp->hd[v]);
                        if (hp->hd[v].e < hp->hd[v].b + u + 1)
                                continue;
                        if (hp->hd[v].b[u] != ':')
                                continue;
                        if (!http_hdr_at(b, hp->hd[v].b, u))
                                continue;
                        hp->hdf[v] |= HDF_FILTER;
                }
        }
        CHECK_OBJ_NOTNULL(retval, STREAM_CLOSE_MAGIC);
        return (retval);
}

// Set the correct Connection header for closing or not
// Existing Connection: close has precedence
stream_close_t
http_EnsureConnection(struct http *hp, stream_close_t sc_close)
{
        const char *h, *b, *e;
        struct vsb vsb[1];
        unsigned has_keep = 0, has_close = 0;
        unsigned u, n = 0;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        http_CollectHdr(hp, H_Connection);
        if (!http_GetHdr(hp, H_Connection, &h)) {
                if (sc_close == SC_NULL)
                        http_SetHeader(hp, "Connection: keep-alive");
                else
                        http_SetHeader(hp, "Connection: close");
                return (sc_close);
        }

        WS_VSB_new(vsb, hp->ws);
        AN(h);
        while (http_split(&h, NULL, ",", &b, &e)) {
                u = pdiff(b, e);
                if (u == 5 && http_hdr_at(b, "close", u)) {
                        has_close = 1;
                        continue;
                }
                if (u == 10 && http_hdr_at(b, "keep-alive", u)) {
                        has_keep = 1;
                        continue;
                }
                if (n++ == 0)
                        VSB_cat(vsb, "Connection: ");
                else
                        VSB_cat(vsb, ", ");
                VSB_bcat(vsb, b, u);
        }
        if (sc_close == SC_NULL && has_close)
                sc_close = SC_RESP_CLOSE;
        //lint -e{731} Boolean argument to equal/not equal
        if (has_keep ^ has_close && (sc_close == SC_NULL) == (has_keep == 1)) {
                // already correct
                WS_Release(hp->ws, 0);
                return (sc_close);
        }
        http_Unset(hp, H_Connection);
        if (n == 0 && sc_close == SC_NULL) {
                WS_Release(hp->ws, 0);
                http_SetHeader(hp, "Connection: keep-alive");
                return (sc_close);
        }
        if (n == 0) {
                WS_Release(hp->ws, 0);
                http_SetHeader(hp, "Connection: close");
                return (sc_close);
        }
        if (sc_close == SC_NULL)
                VSB_cat(vsb, ", keep-alive");
        else
                VSB_cat(vsb, ", close");
        h = WS_VSB_finish(vsb, hp->ws, NULL);
        if (h == NULL)
                return (SC_OVERLOAD);
        http_SetHeader(hp, h);
        return (sc_close);
}

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

int
http_HdrIs(const struct http *hp, hdr_t hdr, const char *val)
{
        const char *p;

        if (!http_GetHdr(hp, hdr, &p))
                return (0);
        AN(p);
        if (http_tok_eq(p, val))
                return (1);
        return (0);
}

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

uint16_t
http_GetStatus(const struct http *hp)
{

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        return (hp->status);
}

int
http_IsStatus(const struct http *hp, int val)
{

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        assert(val >= 100 && val <= 999);
        return (val == (hp->status % 1000));
}

/*--------------------------------------------------------------------
 * Setting the status will also set the Reason appropriately
 */

void
http_SetStatus(struct http *to, uint16_t status, const char *reason)
{
        char buf[4];
        const char *sstr = NULL;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        /*
         * We allow people to use top digits for internal VCL
         * signalling, but strip them from the ASCII version.
         */
        to->status = status;
        status %= 1000;
        assert(status >= 100);

        if (reason == NULL)
                reason = http_Status2Reason(status, &sstr);
        else
                (void)http_Status2Reason(status, &sstr);

        if (sstr) {
                http_SetH(to, HTTP_HDR_STATUS, sstr);
        } else {
                bprintf(buf, "%03d", status);
                http_PutField(to, HTTP_HDR_STATUS, buf);
        }
        http_SetH(to, HTTP_HDR_REASON, reason);
}

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

const char *
http_GetMethod(const struct http *hp)
{

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
        Tcheck(hp->hd[HTTP_HDR_METHOD]);
        return (hp->hd[HTTP_HDR_METHOD].b);
}

/*--------------------------------------------------------------------
 * Force a particular header field to a particular value
 */

void
http_ForceField(struct http *to, unsigned n, const char *t)
{
        int i;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        assert(n < HTTP_HDR_FIRST);
        assert(n == HTTP_HDR_METHOD || n == HTTP_HDR_PROTO);
        AN(t);

        /* NB: method names and protocol versions are case-sensitive. */
        if (to->hd[n].b == NULL || vstrcmp(to->hd[n].b, t)) {
                i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
                i += to->logtag;
                /* XXX: this is a dead branch */
                if (n >= HTTP_HDR_FIRST)
                        VSLbt(to->vsl, (enum VSL_tag_e)i, to->hd[n]);
                http_SetH(to, n, t);
        }
}

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

void
http_PutResponse(struct http *to, const char *proto, uint16_t status,
    const char *reason)
{

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        if (proto != NULL)
                http_SetH(to, HTTP_HDR_PROTO, proto);
        http_SetStatus(to, status, reason);
}

/*--------------------------------------------------------------------
 * check if header is filtered by the dynamic marker or the static
 * definitions in http_headers.h
 */

static inline int
http_isfiltered(const struct http *fm, unsigned u, unsigned how)
{
        const char *e;
        const struct http_hdrflg *f;

        if (fm->hdf[u] & HDF_FILTER)
                return (1);
        if (u < HTTP_HDR_FIRST)
                return (0);
        e = strchr(fm->hd[u].b, ':');
        if (e == NULL)
                return (0);
        f = http_hdr_flags(fm->hd[u].b, e);
        return (f != NULL && f->flag & how);
}

int
http_IsFiltered(const struct http *fm, unsigned u, unsigned how)
{

        return (http_isfiltered(fm, u, how));
}

/*--------------------------------------------------------------------
 * Estimate how much workspace we need to Filter this header according
 * to 'how'.
 */

unsigned
http_EstimateWS(const struct http *fm, unsigned how)
{
        unsigned u, l;

        l = 4;
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);
        for (u = 0; u < fm->nhd; u++) {
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
                        continue;
                Tcheck(fm->hd[u]);
                if (http_isfiltered(fm, u, how))
                        continue;
                l += Tlen(fm->hd[u]) + 1L;
        }
        return (PRNDUP(l + 1L));
}

/*--------------------------------------------------------------------
 * Encode http struct as byte string.
 *
 * XXX: We could save considerable special-casing below by encoding also
 * XXX: H__Status, H__Reason and H__Proto into the string, but it would
 * XXX: add 26-30 bytes to all encoded objects to save a little code.
 * XXX: It could possibly be a good idea for later HTTP versions.
 */

void
HTTP_Encode(const struct http *fm, uint8_t *p0, unsigned l, unsigned how)
{
        unsigned u, w;
        uint16_t n;
        uint8_t *p, *e;

        AN(p0);
        AN(l);
        p = p0;
        e = p + l;
        assert(p + 5 <= e);
        assert(fm->nhd <= fm->shd);
        n = HTTP_HDR_FIRST - 3;
        vbe16enc(p + 2, fm->status);
        p += 4;
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);
        for (u = 0; u < fm->nhd; u++) {
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
                        continue;
                Tcheck(fm->hd[u]);
                if (http_isfiltered(fm, u, how))
                        continue;
                http_VSLH(fm, u);
                w = Tlen(fm->hd[u]) + 1L;
                assert(p + w + 1 <= e);
                vmemcpy(p, fm->hd[u].b, w);
                p += w;
                n++;
        }
        *p++ = '\0';
        assert(p <= e);
        vbe16enc(p0, n + 1);
}

/*--------------------------------------------------------------------
 * Decode byte string into http struct
 */

int
HTTP_Decode(struct http *to, const uint8_t *fm)
{

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        AN(to->vsl);
        AN(fm);
        if (vbe16dec(fm) <= to->shd) {
                to->status = vbe16dec(fm + 2);
                fm += 4;
                for (to->nhd = 0; to->nhd < to->shd; to->nhd++) {
                        if (to->nhd == HTTP_HDR_METHOD ||
                            to->nhd == HTTP_HDR_URL) {
                                to->hd[to->nhd].b = NULL;
                                to->hd[to->nhd].e = NULL;
                                continue;
                        }
                        if (*fm == '\0')
                                return (0);
                        to->hd[to->nhd].b = (const void*)fm;
                        fm = (const void*)strchr((const void*)fm, '\0');
                        to->hd[to->nhd].e = (const void*)fm;
                        fm++;
                        http_VSLH(to, to->nhd);
                }
        }
        VSLb(to->vsl, SLT_Error,
            "Too many headers to Decode object (%u vs. %u)",
            vbe16dec(fm), to->shd);
        return (-1);
}

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

uint16_t
HTTP_GetStatusPack(struct worker *wrk, struct objcore *oc)
{
        const char *ptr;
        ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
        AN(ptr);

        return (vbe16dec(ptr + 2));
}

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

/* Get the first packed header */
int
HTTP_IterHdrPack(struct worker *wrk, struct objcore *oc, const char **p)
{
        const char *ptr;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        AN(p);

        if (*p == NULL) {
                ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
                AN(ptr);
                ptr += 4;       /* Skip nhd and status */
                ptr = strchr(ptr, '\0') + 1;    /* Skip :proto: */
                ptr = strchr(ptr, '\0') + 1;    /* Skip :status: */
                ptr = strchr(ptr, '\0') + 1;    /* Skip :reason: */
                *p = ptr;
        } else {
                *p = strchr(*p, '\0') + 1;      /* Skip to next header */
        }
        if (**p == '\0')
                return (0);
        return (1);
}

const char *
HTTP_GetHdrPack(struct worker *wrk, struct objcore *oc, hdr_t hdr)
{
        const char *ptr;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CHECK_HDR(hdr);

        if (hdr->str[0] == ':') {
                /* Special cases */
                ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
                AN(ptr);
                ptr += 4;       /* Skip nhd and status */

                /* XXX: should we also have h2_hdr_eq() ? */
                if (!vstrcmp(hdr->str, ":proto:"))
                        return (ptr);
                ptr = strchr(ptr, '\0') + 1;
                if (!vstrcmp(hdr->str, ":status:"))
                        return (ptr);
                ptr = strchr(ptr, '\0') + 1;
                if (!vstrcmp(hdr->str, ":reason:"))
                        return (ptr);
                WRONG("Unknown magic packed header");
        }

        HTTP_FOREACH_PACK(wrk, oc, ptr) {
                if (http_hdr_at(ptr, hdr->str, hdr->len)) {
                        ptr += hdr->len;
                        while (vct_islws(*ptr))
                                ptr++;
                        return (ptr);
                }
        }

        return (NULL);
}

/*--------------------------------------------------------------------
 * Merge any headers in the oc->OA_HEADER into the struct http if they
 * are not there already.
 */

void
HTTP_Merge(struct worker *wrk, struct objcore *oc, struct http *to)
{
        const char *ptr;
        unsigned u;
        const char *p;
        unsigned nhd_before_merge;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);

        ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
        AN(ptr);

        to->status = vbe16dec(ptr + 2);
        ptr += 4;

        for (u = 0; u < HTTP_HDR_FIRST; u++) {
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
                        continue;
                http_SetH(to, u, ptr);
                ptr = strchr(ptr, '\0') + 1;
        }
        nhd_before_merge = to->nhd;
        while (*ptr != '\0') {
                p = strchr(ptr, ':');
                AN(p);
                u = http_findhdr(to, p - ptr, ptr);
                if (u == 0 || u >= nhd_before_merge)
                        http_SetHeader(to, ptr);
                ptr = strchr(ptr, '\0') + 1;
        }
}

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

static void
http_linkh(const struct http *to, const struct http *fm, unsigned n)
{

        assert(n < HTTP_HDR_FIRST);
        Tcheck(fm->hd[n]);
        to->hd[n] = fm->hd[n];
        to->hdf[n] = fm->hdf[n];
        http_VSLH(to, n);
}

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

void
http_FilterReq(struct http *to, const struct http *fm, unsigned how)
{
        unsigned u;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);

        http_linkh(to, fm, HTTP_HDR_METHOD);
        http_SetWellKnownMethod(to);
        http_linkh(to, fm, HTTP_HDR_URL);
        http_linkh(to, fm, HTTP_HDR_PROTO);
        to->protover = fm->protover;
        to->status = fm->status;

        to->nhd = HTTP_HDR_FIRST;
        for (u = HTTP_HDR_FIRST; u < fm->nhd; u++) {
                Tcheck(fm->hd[u]);
                if (http_isfiltered(fm, u, how))
                        continue;
                assert (to->nhd < to->shd);
                to->hd[to->nhd] = fm->hd[u];
                to->hdf[to->nhd] = 0;
                http_VSLH(to, to->nhd);
                to->nhd++;
        }
}

/*--------------------------------------------------------------------
 * This function copies any header fields which reference foreign
 * storage into our own WS.
 */

void
http_CopyHome(const struct http *hp)
{
        unsigned u, l;
        const char *p;

        for (u = 0; u < hp->nhd; u++) {
                if (hp->hd[u].b == NULL) {
                        assert(u < HTTP_HDR_FIRST);
                        continue;
                }

                l = Tlen(hp->hd[u]);
                if (WS_Allocated(hp->ws, hp->hd[u].b, l))
                        continue;

                p = WS_Copy(hp->ws, hp->hd[u].b, l + 1L);
                if (p == NULL) {
                        http_fail(hp);
                        VSLbs(hp->vsl, SLT_LostHeader, TOSTRAND(hp->hd[u].b));
                        return;
                }
                hp->hd[u].b = p;
                hp->hd[u].e = p + l;
        }
}

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

void
http_SetHeader(struct http *to, const char *header)
{

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        if (to->nhd >= to->shd) {
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(header));
                http_fail(to);
                return;
        }
        http_SetH(to, to->nhd++, header);
}

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

void
http_ForceHeader(struct http *to, hdr_t hdr, const char *val)
{

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        if (http_HdrIs(to, hdr, val))
                return;
        http_Unset(to, hdr);
        http_PrintfHeader(to, "%s %s", hdr->str, val);
}

void
http_AppendHeader(struct http *to, hdr_t hdr, const char *val)
{
        const char *old;

        http_CollectHdr(to, hdr);
        if (http_GetHdr(to, hdr, &old)) {
                http_Unset(to, hdr);
                http_PrintfHeader(to, "%s %s, %s", hdr->str, old, val);
        } else {
                http_PrintfHeader(to, "%s %s", hdr->str, val);
        }
}

void
http_PrintfHeader(struct http *to, const char *fmt, ...)
{
        va_list ap, ap2;
        struct vsb vsb[1];
        size_t sz;
        char *p;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);

        va_start(ap, fmt);
        va_copy(ap2, ap);

        WS_VSB_new(vsb, to->ws);
        VSB_vprintf(vsb, fmt, ap);
        p = WS_VSB_finish(vsb, to->ws, &sz);

        if (p == NULL || to->nhd >= to->shd) {
                http_fail(to);
                VSLbv(to->vsl, SLT_LostHeader, fmt, ap2);
        } else {
                http_SetH(to, to->nhd++, p);
        }
        va_end(ap);
        va_end(ap2);
}

void
http_TimeHeader(struct http *to, const char *fmt, vtim_real now)
{
        unsigned l;
        char *p;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        if (to->nhd >= to->shd) {
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
                http_fail(to);
                return;
        }
        l = (unsigned)vstrlen(fmt);
        p = WS_Alloc(to->ws, l + VTIM_FORMAT_SIZE);
        if (p == NULL) {
                http_fail(to);
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
                return;
        }
        strcpy(p, fmt);
        VTIM_format(now, p + l);
        http_SetH(to, to->nhd++, p);
}

const char *
http_ViaHeader(void)
{

        return (via_hdr);
}

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

void
http_Unset(struct http *hp, hdr_t hdr)
{
        uint16_t u, v;

        for (v = u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (http_IsHdr(&hp->hd[u], hdr)) {
                        http_VSLH_del(hp, u);
                        continue;
                }
                if (v != u) {
                        vmemcpy(&hp->hd[v], &hp->hd[u], sizeof *hp->hd);
                        vmemcpy(&hp->hdf[v], &hp->hdf[u], sizeof *hp->hdf);
                }
                v++;
        }
        hp->nhd = v;
}

void
http_SetWellKnownMethod(struct http *hp)
{
        size_t l;
        const char *method;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        method = http_GetMethod(hp);
        AN(method);
        l = vstrlen(method);
        hp->wkm = WKM_UNKNOWN;
#define WKM(wk, bit)                                                    \
        do {                                                            \
                if (l == vstrlen(#wk) && !vmemcmp(#wk, method, l)) {    \
                        hp->wkm = WKM_##wk;                             \
                        return;                                         \
                }                                                       \
        } while (0);
#include "tbl/well_known_methods.h"
#undef WKM
}

		vinyl-cache/bin/vinyld/cache/cache_http.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2017 Varnish Software AS
3		* Copyright 2026 UPLEX - Nils Goroll Systemoptimierung
4		* All rights reserved.
5		*
6		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
7		*
8		* SPDX-License-Identifier: BSD-2-Clause
9		*
10		* Redistribution and use in source and binary forms, with or without
11		* modification, are permitted provided that the following conditions
12		* are met:
13		* 1. Redistributions of source code must retain the above copyright
14		* notice, this list of conditions and the following disclaimer.
15		* 2. Redistributions in binary form must reproduce the above copyright
16		* notice, this list of conditions and the following disclaimer in the
17		* documentation and/or other materials provided with the distribution.
18		*
19		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
23		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29		* SUCH DAMAGE.
30	131494	*
31	15015	* HTTP request storage and manipulation
32	12369	*/
33	7182
34	1596	#include "config.h"
35	1491
36	1365	#include "cache_int.h"
37	1365	#include <stdio.h>
38	1365	#include <stdlib.h>
39	1302
40	1302	#include "common/heritage.h"
41
42		#include "vct.h"
43		#include "vend.h"
44		#include "vnum.h"
45		#include "vtim.h"
46
47		#define BODYSTATUS(U, l, n, a, k) \
48		const struct body_status BS_##U[1] = {{ \
49		.name = #l, \
50		.nbr = n, \
51		.avail = a, \
52		.length_known = k \
53		}};
54		#include "tbl/body_status.h"
55
56
57		#define HTTPH(a, b, c) hdr_t b = HDR(a);
58		#include "tbl/http_headers.h"
59
60		hdr_t H__Status = HDR(":status");
61		hdr_t H__Proto = HDR(":proto");
62		hdr_t H__Reason = HDR(":reason");
63
64		static char * via_hdr;
65
66		/*--------------------------------------------------------------------
67		* Perfect hash to rapidly recognize headers from tbl/http_headers.h
68		* which have non-zero flags.
69		*
70		* A suitable algorithm can be found with `gperf`:
71		*
72		* tr '" ,' ' ' < include/tbl/http_headers.h \|
73		* awk '$1 == "H(" {print $2}' \|
74		* gperf --ignore-case
75		*
76		*/
77
78		#define GPERF_MIN_WORD_LENGTH 2
79		#define GPERF_MAX_WORD_LENGTH 19
80		#define GPERF_MAX_HASH_VALUE 79
81
82		static const unsigned char http_asso_values[256] = {
83		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
84		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
85		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
86		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
87		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
88		80, 80, 80, 0, 80, 80, 80, 80, 80, 80,
89		80, 80, 80, 80, 80, 5, 80, 20, 0, 0,
90		5, 10, 5, 5, 80, 0, 15, 0, 20, 80,
91		40, 80, 0, 35, 10, 20, 55, 45, 0, 0,
92		80, 80, 80, 80, 80, 80, 80, 5, 80, 20,
93		0, 0, 5, 10, 5, 5, 80, 0, 15, 0,
94		20, 80, 40, 80, 0, 35, 10, 20, 55, 45,
95		0, 0, 80, 80, 80, 80, 80, 80, 80, 80,
96		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
97		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
98		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
99		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
100		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
101		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
102		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
103		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
104		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
105		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
106		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
107		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
108		80, 80, 80, 80, 80, 80
109		};
110
111		static struct http_hdrflg {
112		hdr_t *hdr;
113		unsigned flag;
114		} http_hdrflg[GPERF_MAX_HASH_VALUE + 1] = {
115		{ NULL }, { NULL }, { NULL }, { NULL },
116		{ &H_Date },
117		{ &H_Range },
118		{ NULL },
119		{ &H_Referer },
120		{ &H_Age },
121		{ &H_From },
122		{ &H_Keep_Alive },
123		{ &H_Retry_After },
124		{ &H_TE },
125		{ &H_If_Range },
126		{ &H_ETag },
127		{ &H_X_Forwarded_For },
128		{ &H_Expect },
129		{ &H_Trailer },
130		{ &H_If_Match },
131		{ &H_Host },
132		{ &H_Accept_Language },
133		{ &H_Accept },
134		{ &H_If_Modified_Since },
135		{ &H_If_None_Match },
136		{ &H_If_Unmodified_Since },
137		{ NULL },
138		{ &H_Cookie },
139		{ &H_Upgrade },
140		{ &H_Last_Modified },
141		{ &H_Accept_Charset },
142		{ &H_Accept_Encoding },
143		{ &H_Content_MD5 },
144		{ &H_Content_Type },
145		{ &H_Content_Range },
146		{ NULL }, { NULL },
147		{ &H_Content_Language },
148		{ &H_Transfer_Encoding },
149		{ &H_Authorization },
150		{ &H_Content_Length },
151		{ &H_User_Agent },
152		{ &H_Server },
153		{ &H_Expires },
154		{ &H_Location },
155		{ NULL },
156		{ &H_Set_Cookie },
157		{ &H_Content_Encoding },
158		{ &H_Max_Forwards },
159		{ &H_Cache_Control },
160		{ NULL },
161		{ &H_Connection },
162		{ &H_Pragma },
163		{ NULL },
164		{ &H_Accept_Ranges },
165		{ &H_HTTP2_Settings },
166		{ &H_Allow },
167		{ &H_Content_Location },
168		{ NULL },
169		{ &H_Proxy_Authenticate },
170		{ &H_Vary },
171		{ NULL },
172		{ &H_WWW_Authenticate },
173		{ &H_Warning },
174		{ &H_Via },
175		{ NULL }, { NULL }, { NULL }, { NULL },
176		{ NULL }, { NULL }, { NULL }, { NULL },
177		{ NULL }, { NULL }, { NULL }, { NULL },
178		{ NULL }, { NULL }, { NULL },
179		{ &H_Proxy_Authorization }
180		};
181
182		static struct http_hdrflg *
183	1690303	http_hdr_flags(const char b, const char e)
184		{
185		unsigned u;
186		struct http_hdrflg *retval;
187
188	1690303	if (b == NULL \|\| e == NULL)
189	172	return (NULL);
190	1690297	u = pdiff(b, e);
191	1690297	if (u < GPERF_MIN_WORD_LENGTH \|\| u > GPERF_MAX_WORD_LENGTH)
192	777	return (NULL);
193	3379040	u += http_asso_values[(uint8_t)(e[-1])] +
194	1689520	http_asso_values[(uint8_t)(b[0])];
195	1689520	if (u > GPERF_MAX_HASH_VALUE)
196	25563	return (NULL);
197	1663957	retval = &http_hdrflg[u];
198	1663957	if (retval->hdr == NULL)
199	6611	return (NULL);
200	1657346	AN(*retval->hdr);
201	1657346	if (!http_hdr_at(*retval->hdr + 1, b, e - b))
202	22910	return (NULL);
203	1634436	return (retval);
204	1690297	}
205
206		/--------------------------------------------------------------------/
207
208		static void
209	1086176	http_init_hdr(hdr_t hdr, int flg)
210		{
211		struct http_hdrflg *f;
212
213	1086176	f = http_hdr_flags(hdr->str, hdr->str + hdr->len - 1);
214	1086176	AN(f);
215	1086176	assert(*f->hdr == hdr);
216	1086176	f->flag = flg;
217	1086176	}
218
219		void
220	20888	HTTP_Init(void)
221		{
222		struct vsb *vsb;
223
224		#define HTTPH(a, b, c) http_init_hdr(b, c);
225		#include "tbl/http_headers.h"
226
227		vsb = VSB_new_auto();
228	20888	AN(vsb);
229		VSB_printf(vsb, "1.1 %s (Vinyl-Cache/" PACKAGE_BRANCH ")",
230		heritage.identity);
231	20888	AZ(VSB_finish(vsb));
232	20888	REPLACE(via_hdr, VSB_data(vsb));
233		VSB_destroy(&vsb);
234		}
235
236		/*--------------------------------------------------------------------
237		* These two functions are in an incestuous relationship with the
238		* order of macros in include/tbl/vsl_tags_http.h
239		*
240		* The http->logtag is the SLT_*Method enum, and we add to that, to
241		* get the SLT_ to use.
242		*/
243
244		static void
245	2840649	http_VSLH(const struct http *hp, unsigned hdr)
246		{
247		int i;
248
249	2840649	if (hp->vsl != NULL) {
250	2840732	assert(VXID_TAG(hp->vsl->wid));
251	2840732	i = hdr;
252	2840732	if (i > HTTP_HDR_FIRST)
253	1489291	i = HTTP_HDR_FIRST;
254	2840732	i += hp->logtag;
255	2840732	VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
256	2840732	}
257	2840817	}
258
259		static void
260	23541	http_VSLH_del(const struct http *hp, unsigned hdr)
261		{
262		int i;
263
264	23541	if (hp->vsl != NULL) {
265		/* We don't support unsetting stuff in the first line */
266	23541	assert (hdr >= HTTP_HDR_FIRST);
267	23541	assert(VXID_TAG(hp->vsl->wid));
268	23541	i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
269	23541	i += hp->logtag;
270	23541	VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
271	23541	}
272	23541	}
273
274		/--------------------------------------------------------------------/
275
276		void
277	133864	http_VSL_log(const struct http *hp)
278		{
279		unsigned u;
280
281	1167980	for (u = 0; u < hp->nhd; u++)
282	1800592	if (hp->hd[u].b != NULL)
283	766476	http_VSLH(hp, u);
284	133864	}
285
286		/--------------------------------------------------------------------/
287
288		static void
289	2289	http_fail(const struct http *hp)
290		{
291		char id[WS_ID_SIZE];
292
293	2289	VSC_C_main->losthdr++;
294	2289	WS_Id(hp->ws, id);
295	2289	VSLb(hp->vsl, SLT_Error, "out of workspace (%s)", id);
296	2289	WS_MarkOverflow(hp->ws);
297	2289	}
298
299		/*--------------------------------------------------------------------
300		* List of canonical HTTP response code names from RFC2616
301		*/
302
303		static struct http_msg {
304		unsigned nbr;
305		const char *status;
306		const char *txt;
307		} http_msg[] = {
308		#define HTTP_RESP(n, t) { n, #n, t},
309		#include "tbl/http_response.h"
310		{ 0, "0", NULL }
311		};
312
313		const char *
314	38977	http_Status2Reason(unsigned status, const char **sstr)
315		{
316		struct http_msg *mp;
317
318	38977	status %= 1000;
319	38977	assert(status >= 100);
320	1031132	for (mp = http_msg; mp->nbr != 0 && mp->nbr <= status; mp++)
321	1030133	if (mp->nbr == status) {
322	37978	if (sstr)
323	25909	*sstr = mp->status;
324	37978	return (mp->txt);
325		}
326	987	return ("Unknown HTTP Status");
327	38965	}
328
329		/--------------------------------------------------------------------/
330
331		unsigned
332	120215	HTTP_estimate(unsigned nhttp)
333		{
334
335		/* XXX: We trust the structs to size-aligned as necessary */
336	120215	return (PRNDUP(sizeof(struct http) + sizeof(txt) * nhttp + nhttp));
337		}
338
339		struct http *
340	360647	HTTP_create(void *p, uint16_t nhttp, unsigned len)
341		{
342		struct http *hp;
343
344	360647	hp = p;
345	360647	hp->magic = HTTP_MAGIC;
346	360647	hp->hd = (void*)(hp + 1);
347	360647	hp->shd = nhttp;
348	360647	hp->hdf = (void*)(hp->hd + nhttp);
349	360647	assert((unsigned char*)p + len == hp->hdf + PRNDUP(nhttp));
350	360647	return (hp);
351		}
352
353		/--------------------------------------------------------------------/
354
355		void
356	339267	HTTP_Setup(struct http hp, struct ws ws, struct vsl_log *vsl,
357		enum VSL_tag_e whence)
358		{
359	339267	http_Teardown(hp);
360	339267	hp->nhd = HTTP_HDR_FIRST;
361	339267	hp->logtag = whence;
362	339267	hp->ws = ws;
363	339267	hp->vsl = vsl;
364	339267	hp->wkm = WKM_UNKNOWN;
365	339267	}
366
367		/*--------------------------------------------------------------------
368		* http_Teardown() is a safety feature, we use it to zap all http
369		* structs once we're done with them, to minimize the risk that
370		* old stale pointers exist to no longer valid stuff.
371		*/
372
373		void
374	528987	http_Teardown(struct http *hp)
375		{
376
377	528987	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
378	528987	AN(hp->shd);
379	528987	memset(&hp->nhd, 0, sizeof *hp - offsetof(struct http, nhd));
380	528987	memset(hp->hd, 0, sizeof hp->hd hp->shd);
381	528987	memset(hp->hdf, 0, sizeof hp->hdf hp->shd);
382	528987	}
383
384		/*--------------------------------------------------------------------
385		* Duplicate the http content into another http
386		* We cannot just memcpy the struct because the hd & hdf are private
387		* storage to the struct http.
388		*/
389
390		void
391	148086	HTTP_Dup(struct http to, const struct http fm)
392		{
393
394	148086	assert(fm->nhd <= to->shd);
395	148086	vmemcpy(to->hd, fm->hd, fm->nhd * sizeof *to->hd);
396	148086	vmemcpy(to->hdf, fm->hdf, fm->nhd * sizeof *to->hdf);
397	148086	to->nhd = fm->nhd;
398	148086	to->logtag = fm->logtag;
399	148086	to->status = fm->status;
400	148086	to->protover = fm->protover;
401	148086	to->wkm = fm->wkm;
402	148086	}
403
404
405		/*--------------------------------------------------------------------
406		* Clone the entire http structure, including vsl & ws
407		*/
408
409		void
410	140310	HTTP_Clone(struct http to, const struct http const fm)
411		{
412
413	140310	HTTP_Dup(to, fm);
414	140310	to->vsl = fm->vsl;
415	140310	to->ws = fm->ws;
416	140310	}
417
418		/--------------------------------------------------------------------/
419
420		void
421	154475	http_Proto(struct http *to)
422		{
423		const char *fm;
424
425	154475	fm = to->hd[HTTP_HDR_PROTO].b;
426
427	308765	if (fm != NULL &&
428	154311	(fm[0] == 'H' \|\| fm[0] == 'h') &&
429	154291	(fm[1] == 'T' \|\| fm[1] == 't') &&
430	154291	(fm[2] == 'T' \|\| fm[2] == 't') &&
431	154291	(fm[3] == 'P' \|\| fm[3] == 'p') &&
432	154291	fm[4] == '/' &&
433	154291	vct_isdigit(fm[5]) &&
434	154288	fm[6] == '.' &&
435	154288	vct_isdigit(fm[7]) &&
436	154290	fm[8] == '\0') {
437	154290	to->protover = 10 * (fm[5] - '0') + (fm[7] - '0');
438	154290	} else {
439	189	to->protover = 0;
440		}
441	154479	}
442
443		/--------------------------------------------------------------------/
444
445		void
446	902141	http_SetH(struct http to, unsigned n, const char header)
447		{
448
449	902141	assert(n < to->nhd);
450	902141	AN(header);
451	902141	to->hd[n].b = TRUST_ME(header);
452	902141	to->hd[n].e = strchr(to->hd[n].b, '\0');
453	902141	to->hdf[n] = 0;
454	902141	http_VSLH(to, n);
455	902141	if (n == HTTP_HDR_PROTO)
456	31535	http_Proto(to);
457	902141	if (n == HTTP_HDR_METHOD)
458	819	http_SetWellKnownMethod(to);
459	902141	}
460
461		/--------------------------------------------------------------------/
462
463		static void
464	735	http_PutField(struct http to, int field, const char string)
465		{
466		const char *p;
467
468	735	CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
469	735	p = WS_Copy(to->ws, string, -1);
470	735	if (p == NULL) {
471	21	http_fail(to);
472	21	VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(string));
473	21	return;
474		}
475	714	http_SetH(to, field, p);
476	735	}
477
478		/--------------------------------------------------------------------/
479
480		int
481	4089210	http_IsHdr(const txt *hh, hdr_t hdr)
482		{
483
484	4089210	Tcheck(*hh);
485	4089210	CHECK_HDR(hdr);
486	4089210	return (http_hdr_at(hdr->str, hh->b, hdr->len));
487		}
488
489		/--------------------------------------------------------------------/
490
491		static unsigned
492	3453014	http_findhdr(const struct http hp, unsigned l, const char hdr)
493		{
494		unsigned u;
495
496	15991322	for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
497	13120656	Tcheck(hp->hd[u]);
498	13120656	if (hp->hd[u].e < hp->hd[u].b + l + 1)
499	2714819	continue;