GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2017 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.
 *
 * HTTP request storage and manipulation
 */

#include "config.h"

#include "cache_varnishd.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 (Varnish/" 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;
}

/*--------------------------------------------------------------------
 * 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);
        memcpy(to->hd, fm->hd, fm->nhd * sizeof *to->hd);
        memcpy(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;
}


/*--------------------------------------------------------------------
 * 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);
}

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

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]
 */

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.
 */

void
http_CollectHdrSep(struct http *hp, hdr_t hdr, const char *sep)
{
        unsigned u, lsep, ml, f, x, d;
        char *b = NULL, *e = NULL;
        const char *v;

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

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

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

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

        for (d = u = f + 1; u < hp->nhd; u++) {
                Tcheck(hp->hd[u]);
                if (!http_IsHdr(&hp->hd[u], hdr)) {
                        if (d != u) {
                                hp->hd[d] = hp->hd[u];
                                hp->hdf[d] = hp->hdf[u];
                        }
                        d++;
                        continue;
                }
                if (b == NULL) {
                        /* 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(hdr->str));
                                WS_Release(hp->ws, 0);
                                return;
                        }
                        memcpy(b, hp->hd[f].b, x);
                        b += x;
                }

                AN(b);
                AN(e);

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

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

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

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

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 = strlen(token);
        const char *b;

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

        b = *bp;

        if (b + fl + 2 <= e && *b == '"' &&
            !memcmp(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);
}

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

ssize_t
http_GetContentLength(const struct http *hp)
{
        ssize_t cl;
        const char *b;

        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);

        if (!http_GetHdr(hp, H_Content_Length, &b))
                return (-1);
        cl = VNUM_uint(b, NULL, &b);
        if (cl < 0)
                return (-2);
        while (vct_islws(*b))
                b++;
        if (*b != '\0')
                return (-2);
        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_islws(*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);

        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_islws(*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);
}

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

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 || strcmp(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);
                memcpy(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 (!strcmp(hdr->str, ":proto:"))
                        return (ptr);
                ptr = strchr(ptr, '\0') + 1;
                if (!strcmp(hdr->str, ":status:"))
                        return (ptr);
                ptr = strchr(ptr, '\0') + 1;
                if (!strcmp(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_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)
{
        char *p;

        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
        if (to->nhd >= to->shd) {
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
                http_fail(to);
                return;
        }
        p = WS_Alloc(to->ws, strlen(fmt) + VTIM_FORMAT_SIZE);
        if (p == NULL) {
                http_fail(to);
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
                return;
        }
        strcpy(p, fmt);
        VTIM_format(now, strchr(p, '\0'));
        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) {
                        memcpy(&hp->hd[v], &hp->hd[u], sizeof *hp->hd);
                        memcpy(&hp->hdf[v], &hp->hdf[u], sizeof *hp->hdf);
                }
                v++;
        }
        hp->nhd = v;
}

		varnish-cache/bin/varnishd/cache/cache_http.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2017 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		* HTTP request storage and manipulation
31		*/
32
33		#include "config.h"
34
35		#include "cache_varnishd.h"
36		#include <stdio.h>
37		#include <stdlib.h>
38
39		#include "common/heritage.h"
40
41		#include "vct.h"
42		#include "vend.h"
43		#include "vnum.h"
44		#include "vtim.h"
45
46		#define BODYSTATUS(U, l, n, a, k) \
47		const struct body_status BS_##U[1] = {{ \
48		.name = #l, \
49		.nbr = n, \
50		.avail = a, \
51		.length_known = k \
52		}};
53		#include "tbl/body_status.h"
54
55
56		#define HTTPH(a, b, c) hdr_t b = HDR(a);
57		#include "tbl/http_headers.h"
58
59		hdr_t H__Status = HDR(":status");
60		hdr_t H__Proto = HDR(":proto");
61		hdr_t H__Reason = HDR(":reason");
62
63		static char * via_hdr;
64
65		/*--------------------------------------------------------------------
66		* Perfect hash to rapidly recognize headers from tbl/http_headers.h
67		* which have non-zero flags.
68		*
69		* A suitable algorithm can be found with `gperf`:
70		*
71		* tr '" ,' ' ' < include/tbl/http_headers.h \|
72		* awk '$1 == "H(" {print $2}' \|
73		* gperf --ignore-case
74		*
75		*/
76
77		#define GPERF_MIN_WORD_LENGTH 2
78		#define GPERF_MAX_WORD_LENGTH 19
79		#define GPERF_MAX_HASH_VALUE 79
80
81		static const unsigned char http_asso_values[256] = {
82		80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
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, 0, 80, 80, 80, 80, 80, 80,
88		80, 80, 80, 80, 80, 5, 80, 20, 0, 0,
89		5, 10, 5, 5, 80, 0, 15, 0, 20, 80,
90		40, 80, 0, 35, 10, 20, 55, 45, 0, 0,
91		80, 80, 80, 80, 80, 80, 80, 5, 80, 20,
92		0, 0, 5, 10, 5, 5, 80, 0, 15, 0,
93		20, 80, 40, 80, 0, 35, 10, 20, 55, 45,
94		0, 0, 80, 80, 80, 80, 80, 80, 80, 80,
95		80, 80, 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
108		};
109
110		static struct http_hdrflg {
111		hdr_t *hdr;
112		unsigned flag;
113		} http_hdrflg[GPERF_MAX_HASH_VALUE + 1] = {
114		{ NULL }, { NULL }, { NULL }, { NULL },
115		{ &H_Date },
116		{ &H_Range },
117		{ NULL },
118		{ &H_Referer },
119		{ &H_Age },
120		{ &H_From },
121		{ &H_Keep_Alive },
122		{ &H_Retry_After },
123		{ &H_TE },
124		{ &H_If_Range },
125		{ &H_ETag },
126		{ &H_X_Forwarded_For },
127		{ &H_Expect },
128		{ &H_Trailer },
129		{ &H_If_Match },
130		{ &H_Host },
131		{ &H_Accept_Language },
132		{ &H_Accept },
133		{ &H_If_Modified_Since },
134		{ &H_If_None_Match },
135		{ &H_If_Unmodified_Since },
136		{ NULL },
137		{ &H_Cookie },
138		{ &H_Upgrade },
139		{ &H_Last_Modified },
140		{ &H_Accept_Charset },
141		{ &H_Accept_Encoding },
142		{ &H_Content_MD5 },
143		{ &H_Content_Type },
144		{ &H_Content_Range },
145		{ NULL }, { NULL },
146		{ &H_Content_Language },
147		{ &H_Transfer_Encoding },
148		{ &H_Authorization },
149		{ &H_Content_Length },
150		{ &H_User_Agent },
151		{ &H_Server },
152		{ &H_Expires },
153		{ &H_Location },
154		{ NULL },
155		{ &H_Set_Cookie },
156		{ &H_Content_Encoding },
157		{ &H_Max_Forwards },
158		{ &H_Cache_Control },
159		{ NULL },
160		{ &H_Connection },
161		{ &H_Pragma },
162		{ NULL },
163		{ &H_Accept_Ranges },
164		{ &H_HTTP2_Settings },
165		{ &H_Allow },
166		{ &H_Content_Location },
167		{ NULL },
168		{ &H_Proxy_Authenticate },
169		{ &H_Vary },
170		{ NULL },
171		{ &H_WWW_Authenticate },
172		{ &H_Warning },
173		{ &H_Via },
174		{ NULL }, { NULL }, { NULL }, { NULL },
175		{ NULL }, { NULL }, { NULL }, { NULL },
176		{ NULL }, { NULL }, { NULL }, { NULL },
177		{ NULL }, { NULL }, { NULL },
178		{ &H_Proxy_Authorization }
179		};
180
181		static struct http_hdrflg *
182	3057368	http_hdr_flags(const char b, const char e)
183		{
184		unsigned u;
185		struct http_hdrflg *retval;
186
187	3057368	if (b == NULL \|\| e == NULL)
188	154	return (NULL);
189	3057282	u = pdiff(b, e);
190	3057282	if (u < GPERF_MIN_WORD_LENGTH \|\| u > GPERF_MAX_WORD_LENGTH)
191	1400	return (NULL);
192	6111764	u += http_asso_values[(uint8_t)(e[-1])] +
193	3055882	http_asso_values[(uint8_t)(b[0])];
194	3055882	if (u > GPERF_MAX_HASH_VALUE)
195	41840	return (NULL);
196	3014042	retval = &http_hdrflg[u];
197	3014042	if (retval->hdr == NULL)
198	11590	return (NULL);
199	3002452	AN(*retval->hdr);
200	3002452	if (!http_hdr_at(*retval->hdr + 1, b, e - b))
201	42439	return (NULL);
202	2960013	return (retval);
203	3057282	}
204
205		/--------------------------------------------------------------------/
206
207		static void
208	1977456	http_init_hdr(hdr_t hdr, int flg)
209		{
210		struct http_hdrflg *f;
211
212	1977456	f = http_hdr_flags(hdr->str, hdr->str + hdr->len - 1);
213	1977456	AN(f);
214	1977456	assert(*f->hdr == hdr);
215	1977456	f->flag = flg;
216	1977456	}
217
218		void
219	38028	HTTP_Init(void)
220		{
221		struct vsb *vsb;
222
223		#define HTTPH(a, b, c) http_init_hdr(b, c);
224		#include "tbl/http_headers.h"
225
226		vsb = VSB_new_auto();
227	38028	AN(vsb);
228		VSB_printf(vsb, "1.1 %s (Varnish/" PACKAGE_BRANCH ")",
229		heritage.identity);
230	38028	AZ(VSB_finish(vsb));
231	38028	REPLACE(via_hdr, VSB_data(vsb));
232		VSB_destroy(&vsb);
233		}
234
235		/*--------------------------------------------------------------------
236		* These two functions are in an incestuous relationship with the
237		* order of macros in include/tbl/vsl_tags_http.h
238		*
239		* The http->logtag is the SLT_*Method enum, and we add to that, to
240		* get the SLT_ to use.
241		*/
242
243		static void
244	5065610	http_VSLH(const struct http *hp, unsigned hdr)
245		{
246		int i;
247
248	5065610	if (hp->vsl != NULL) {
249	5065489	assert(VXID_TAG(hp->vsl->wid));
250	5065489	i = hdr;
251	5065489	if (i > HTTP_HDR_FIRST)
252	2667483	i = HTTP_HDR_FIRST;
253	5065489	i += hp->logtag;
254	5065489	VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
255	5065489	}
256	5065732	}
257
258		static void
259	41520	http_VSLH_del(const struct http *hp, unsigned hdr)
260		{
261		int i;
262
263	41520	if (hp->vsl != NULL) {
264		/* We don't support unsetting stuff in the first line */
265	41520	assert (hdr >= HTTP_HDR_FIRST);
266	41520	assert(VXID_TAG(hp->vsl->wid));
267	41520	i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
268	41520	i += hp->logtag;
269	41520	VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
270	41520	}
271	41520	}
272
273		/--------------------------------------------------------------------/
274
275		void
276	235626	http_VSL_log(const struct http *hp)
277		{
278		unsigned u;
279
280	2058113	for (u = 0; u < hp->nhd; u++)
281	3173882	if (hp->hd[u].b != NULL)
282	1351395	http_VSLH(hp, u);
283	235626	}
284
285		/--------------------------------------------------------------------/
286
287		static void
288	4160	http_fail(const struct http *hp)
289		{
290		char id[WS_ID_SIZE];
291
292	4160	VSC_C_main->losthdr++;
293	4160	WS_Id(hp->ws, id);
294	4160	VSLb(hp->vsl, SLT_Error, "out of workspace (%s)", id);
295	4160	WS_MarkOverflow(hp->ws);
296	4160	}
297
298		/*--------------------------------------------------------------------
299		* List of canonical HTTP response code names from RFC2616
300		*/
301
302		static struct http_msg {
303		unsigned nbr;
304		const char *status;
305		const char *txt;
306		} http_msg[] = {
307		#define HTTP_RESP(n, t) { n, #n, t},
308		#include "tbl/http_response.h"
309		{ 0, "0", NULL }
310		};
311
312		const char *
313	59797	http_Status2Reason(unsigned status, const char **sstr)
314		{
315		struct http_msg *mp;
316
317	59797	status %= 1000;
318	59797	assert(status >= 100);
319	1822726	for (mp = http_msg; mp->nbr != 0 && mp->nbr <= status; mp++)
320	1820926	if (mp->nbr == status) {
321	57997	if (sstr)
322	44319	*sstr = mp->status;
323	57997	return (mp->txt);
324		}
325	1800	return ("Unknown HTTP Status");
326	59797	}
327
328		/--------------------------------------------------------------------/
329
330		unsigned
331	215064	HTTP_estimate(unsigned nhttp)
332		{
333
334		/* XXX: We trust the structs to size-aligned as necessary */
335	215064	return (PRNDUP(sizeof(struct http) + sizeof(txt) * nhttp + nhttp));
336		}
337
338		struct http *
339	645199	HTTP_create(void *p, uint16_t nhttp, unsigned len)
340		{
341		struct http *hp;
342
343	645199	hp = p;
344	645199	hp->magic = HTTP_MAGIC;
345	645199	hp->hd = (void*)(hp + 1);
346	645199	hp->shd = nhttp;
347	645199	hp->hdf = (void*)(hp->hd + nhttp);
348	645199	assert((unsigned char*)p + len == hp->hdf + PRNDUP(nhttp));
349	645199	return (hp);
350		}
351
352		/--------------------------------------------------------------------/
353
354		void
355	601695	HTTP_Setup(struct http hp, struct ws ws, struct vsl_log *vsl,
356		enum VSL_tag_e whence)
357		{
358	601695	http_Teardown(hp);
359	601695	hp->nhd = HTTP_HDR_FIRST;
360	601695	hp->logtag = whence;
361	601695	hp->ws = ws;
362	601695	hp->vsl = vsl;
363	601695	}
364
365		/*--------------------------------------------------------------------
366		* http_Teardown() is a safety feature, we use it to zap all http
367		* structs once we're done with them, to minimize the risk that
368		* old stale pointers exist to no longer valid stuff.
369		*/
370
371		void
372	939302	http_Teardown(struct http *hp)
373		{
374
375	939302	CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
376	939302	AN(hp->shd);
377	939302	memset(&hp->nhd, 0, sizeof *hp - offsetof(struct http, nhd));
378	939302	memset(hp->hd, 0, sizeof hp->hd hp->shd);
379	939302	memset(hp->hdf, 0, sizeof hp->hdf hp->shd);
380	939302	}
381
382		/*--------------------------------------------------------------------
383		* Duplicate the http content into another http
384		* We cannot just memcpy the struct because the hd & hdf are private
385		* storage to the struct http.
386		*/
387
388		void
389	264191	HTTP_Dup(struct http to, const struct http fm)
390		{
391
392	264191	assert(fm->nhd <= to->shd);
393	264191	memcpy(to->hd, fm->hd, fm->nhd * sizeof *to->hd);
394	264191	memcpy(to->hdf, fm->hdf, fm->nhd * sizeof *to->hdf);
395	264191	to->nhd = fm->nhd;
396	264191	to->logtag = fm->logtag;
397	264191	to->status = fm->status;
398	264191	to->protover = fm->protover;
399	264191	}
400
401
402		/*--------------------------------------------------------------------
403		* Clone the entire http structure, including vsl & ws
404		*/
405
406		void
407	249552	HTTP_Clone(struct http to, const struct http const fm)
408		{
409
410	249552	HTTP_Dup(to, fm);
411	249552	to->vsl = fm->vsl;
412	249552	to->ws = fm->ws;
413	249552	}
414
415		/--------------------------------------------------------------------/
416
417		void
418	269617	http_Proto(struct http *to)
419		{
420		const char *fm;
421
422	269617	fm = to->hd[HTTP_HDR_PROTO].b;
423
424	538889	if (fm != NULL &&
425	269303	(fm[0] == 'H' \|\| fm[0] == 'h') &&
426	269267	(fm[1] == 'T' \|\| fm[1] == 't') &&
427	269265	(fm[2] == 'T' \|\| fm[2] == 't') &&
428	269265	(fm[3] == 'P' \|\| fm[3] == 'p') &&
429	269265	fm[4] == '/' &&
430	269265	vct_isdigit(fm[5]) &&
431	269265	fm[6] == '.' &&
432	269266	vct_isdigit(fm[7]) &&
433	269272	fm[8] == '\0') {
434	269271	to->protover = 10 * (fm[5] - '0') + (fm[7] - '0');
435	269271	} else {
436	360	to->protover = 0;
437		}
438	269631	}
439
440		/--------------------------------------------------------------------/
441
442		void
443	1606995	http_SetH(struct http to, unsigned n, const char header)
444		{
445
446	1606995	assert(n < to->nhd);
447	1606995	AN(header);
448	1606995	to->hd[n].b = TRUST_ME(header);
449	1606995	to->hd[n].e = strchr(to->hd[n].b, '\0');
450	1606995	to->hdf[n] = 0;
451	1606995	http_VSLH(to, n);
452	1606995	if (n == HTTP_HDR_PROTO)
453	55153	http_Proto(to);
454	1606995	}
455
456		/--------------------------------------------------------------------/
457
458		static void
459	1440	http_PutField(struct http to, int field, const char string)
460		{
461		const char *p;
462
463	1440	CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
464	1440	p = WS_Copy(to->ws, string, -1);
465	1440	if (p == NULL) {
466	40	http_fail(to);
467	40	VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(string));
468	40	return;
469		}
470	1400	http_SetH(to, field, p);
471	1440	}
472
473		/--------------------------------------------------------------------/
474
475		int
476	5867020	http_IsHdr(const txt *hh, hdr_t hdr)
477		{
478
479	5867020	Tcheck(*hh);
480	5867020	CHECK_HDR(hdr);
481	5867020	return (http_hdr_at(hdr->str, hh->b, hdr->len));
482		}
483
484		/--------------------------------------------------------------------/
485
486		static unsigned
487	6049442	http_findhdr(const struct http hp, unsigned l, const char hdr)
488		{
489		unsigned u;
490
491	26277440	for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
492	21568901	Tcheck(hp->hd[u]);
493	21568901	if (hp->hd[u].e < hp->hd[u].b + l + 1)
494	3891804	continue;
495	17677097	if (hp->hd[u].b[l] != ':')
496	14861974	continue;
497	2815123	if (!http_hdr_at(hdr, hp->hd[u].b, l))
498	1474220	continue;
499	1340903	return (u);