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 3050378
http_hdr_flags(const char *b, const char *e)
183
{
184
        unsigned u;
185
        struct http_hdrflg *retval;
186
187 3050378
        if (b == NULL || e == NULL)
188 240
                return (NULL);
189 3050350
        u = pdiff(b, e);
190 3050350
        if (u < GPERF_MIN_WORD_LENGTH || u > GPERF_MAX_WORD_LENGTH)
191 1400
                return (NULL);
192 6097900
        u += http_asso_values[(uint8_t)(e[-1])] +
193 3048950
             http_asso_values[(uint8_t)(b[0])];
194 3048950
        if (u > GPERF_MAX_HASH_VALUE)
195 41680
                return (NULL);
196 3007270
        retval = &http_hdrflg[u];
197 3007270
        if (retval->hdr == NULL)
198 11593
                return (NULL);
199 2995677
        AN(*retval->hdr);
200 2995677
        if (!http_hdr_at(*retval->hdr + 1, b, e - b))
201 42400
                return (NULL);
202 2953277
        return (retval);
203 3050350
}
204
205
/*--------------------------------------------------------------------*/
206
207
static void
208 1973348
http_init_hdr(hdr_t hdr, int flg)
209
{
210
        struct http_hdrflg *f;
211
212 1973348
        f = http_hdr_flags(hdr->str, hdr->str + hdr->len - 1);
213 1973348
        AN(f);
214 1973348
        assert(*f->hdr == hdr);
215 1973348
        f->flag = flg;
216 1973348
}
217
218
void
219 37949
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 37949
        AN(vsb);
228
        VSB_printf(vsb, "1.1 %s (Varnish/" PACKAGE_BRANCH ")",
229
            heritage.identity);
230 37949
        AZ(VSB_finish(vsb));
231 37949
        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 5052973
http_VSLH(const struct http *hp, unsigned hdr)
245
{
246
        int i;
247
248 5052973
        if (hp->vsl != NULL) {
249 5053146
                assert(VXID_TAG(hp->vsl->wid));
250 5053146
                i = hdr;
251 5053146
                if (i > HTTP_HDR_FIRST)
252 2660820
                        i = HTTP_HDR_FIRST;
253 5053146
                i += hp->logtag;
254 5053146
                VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
255 5053146
        }
256 5053339
}
257
258
static void
259 41360
http_VSLH_del(const struct http *hp, unsigned hdr)
260
{
261
        int i;
262
263 41360
        if (hp->vsl != NULL) {
264
                /* We don't support unsetting stuff in the first line */
265 41360
                assert (hdr >= HTTP_HDR_FIRST);
266 41360
                assert(VXID_TAG(hp->vsl->wid));
267 41360
                i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
268 41360
                i += hp->logtag;
269 41360
                VSLbt(hp->vsl, (enum VSL_tag_e)i, hp->hd[hdr]);
270 41360
        }
271 41360
}
272
273
/*--------------------------------------------------------------------*/
274
275
void
276 234996
http_VSL_log(const struct http *hp)
277
{
278
        unsigned u;
279
280 2052320
        for (u = 0; u < hp->nhd; u++)
281 3164828
                if (hp->hd[u].b != NULL)
282 1347504
                        http_VSLH(hp, u);
283 234996
}
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 59679
http_Status2Reason(unsigned status, const char **sstr)
314
{
315
        struct http_msg *mp;
316
317 59679
        status %= 1000;
318 59679
        assert(status >= 100);
319 1819895
        for (mp = http_msg; mp->nbr != 0 && mp->nbr <= status; mp++)
320 1818095
                if (mp->nbr == status) {
321 57879
                        if (sstr)
322 44200
                                *sstr = mp->status;
323 57879
                        return (mp->txt);
324
                }
325 1800
        return ("Unknown HTTP Status");
326 59679
}
327
328
/*--------------------------------------------------------------------*/
329
330
unsigned
331 214554
HTTP_estimate(unsigned nhttp)
332
{
333
334
        /* XXX: We trust the structs to size-aligned as necessary */
335 214554
        return (PRNDUP(sizeof(struct http) + sizeof(txt) * nhttp + nhttp));
336
}
337
338
struct http *
339 643660
HTTP_create(void *p, uint16_t nhttp, unsigned len)
340
{
341
        struct http *hp;
342
343 643660
        hp = p;
344 643660
        hp->magic = HTTP_MAGIC;
345 643660
        hp->hd = (void*)(hp + 1);
346 643660
        hp->shd = nhttp;
347 643660
        hp->hdf = (void*)(hp->hd + nhttp);
348 643660
        assert((unsigned char*)p + len == hp->hdf + PRNDUP(nhttp));
349 643660
        return (hp);
350
}
351
352
/*--------------------------------------------------------------------*/
353
354
void
355 600276
HTTP_Setup(struct http *hp, struct ws *ws, struct vsl_log *vsl,
356
    enum VSL_tag_e  whence)
357
{
358 600276
        http_Teardown(hp);
359 600276
        hp->nhd = HTTP_HDR_FIRST;
360 600276
        hp->logtag = whence;
361 600276
        hp->ws = ws;
362 600276
        hp->vsl = vsl;
363 600276
}
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 937062
http_Teardown(struct http *hp)
373
{
374
375 937062
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
376 937062
        AN(hp->shd);
377 937062
        memset(&hp->nhd, 0, sizeof *hp - offsetof(struct http, nhd));
378 937062
        memset(hp->hd, 0, sizeof *hp->hd * hp->shd);
379 937062
        memset(hp->hdf, 0, sizeof *hp->hdf * hp->shd);
380 937062
}
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 263646
HTTP_Dup(struct http *to, const struct http * fm)
390
{
391
392 263646
        assert(fm->nhd <= to->shd);
393 263646
        memcpy(to->hd, fm->hd, fm->nhd * sizeof *to->hd);
394 263646
        memcpy(to->hdf, fm->hdf, fm->nhd * sizeof *to->hdf);
395 263646
        to->nhd = fm->nhd;
396 263646
        to->logtag = fm->logtag;
397 263646
        to->status = fm->status;
398 263646
        to->protover = fm->protover;
399 263646
}
400
401
402
/*--------------------------------------------------------------------
403
 * Clone the entire http structure, including vsl & ws
404
 */
405
406
void
407 249006
HTTP_Clone(struct http *to, const struct http * const fm)
408
{
409
410 249006
        HTTP_Dup(to, fm);
411 249006
        to->vsl = fm->vsl;
412 249006
        to->ws = fm->ws;
413 249006
}
414
415
/*--------------------------------------------------------------------*/
416
417
void
418 268881
http_Proto(struct http *to)
419
{
420
        const char *fm;
421
422 268881
        fm = to->hd[HTTP_HDR_PROTO].b;
423
424 537406
        if (fm != NULL &&
425 268563
            (fm[0] == 'H' || fm[0] == 'h') &&
426 268525
            (fm[1] == 'T' || fm[1] == 't') &&
427 268525
            (fm[2] == 'T' || fm[2] == 't') &&
428 268525
            (fm[3] == 'P' || fm[3] == 'p') &&
429 268525
            fm[4] == '/' &&
430 268525
            vct_isdigit(fm[5]) &&
431 268523
            fm[6] == '.' &&
432 268523
            vct_isdigit(fm[7]) &&
433 268525
            fm[8] == '\0') {
434 268525
                to->protover = 10 * (fm[5] - '0') + (fm[7] - '0');
435 268525
        } else {
436 360
                to->protover = 0;
437
        }
438 268885
}
439
440
/*--------------------------------------------------------------------*/
441
442
void
443 1603328
http_SetH(struct http *to, unsigned n, const char *header)
444
{
445
446 1603328
        assert(n < to->nhd);
447 1603328
        AN(header);
448 1603328
        to->hd[n].b = TRUST_ME(header);
449 1603328
        to->hd[n].e = strchr(to->hd[n].b, '\0');
450 1603328
        to->hdf[n] = 0;
451 1603328
        http_VSLH(to, n);
452 1603328
        if (n == HTTP_HDR_PROTO)
453 54996
                http_Proto(to);
454 1603328
}
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 5853282
http_IsHdr(const txt *hh, hdr_t hdr)
477
{
478
479 5853282
        Tcheck(*hh);
480 5853282
        CHECK_HDR(hdr);
481 5853282
        return (http_hdr_at(hdr->str, hh->b, hdr->len));
482
}
483
484
/*--------------------------------------------------------------------*/
485
486
static unsigned
487 6033290
http_findhdr(const struct http *hp, unsigned l, const char *hdr)
488
{
489
        unsigned u;
490
491 26207426
        for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
492 21511455
                Tcheck(hp->hd[u]);
493 21511455
                if (hp->hd[u].e < hp->hd[u].b + l + 1)
494 3878462
                        continue;
495 17632993
                if (hp->hd[u].b[l] != ':')
496 14825840
                        continue;
497 2807153
                if (!http_hdr_at(hdr, hp->hd[u].b, l))
498 1469834
                        continue;
499 1337319
                return (u);
500
        }
501 4695971
        return (0);
502 6033290
}
503
504
/*--------------------------------------------------------------------
505
 * Count how many instances we have of this header
506
 */
507
508
unsigned
509 305176
http_CountHdr(const struct http *hp, hdr_t hdr)
510
{
511 305176
        unsigned retval = 0;
512
        unsigned u;
513
514 305176
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
515
516 1017503
        for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
517 712327
                Tcheck(hp->hd[u]);
518 712327
                if (http_IsHdr(&hp->hd[u], hdr))
519 150798
                        retval++;
520 712327
        }
521 305176
        return (retval);
522
}
523
524
/*--------------------------------------------------------------------
525
 * This function collapses multiple header lines of the same name.
526
 * The lines are joined with a comma, according to [rfc2616, 4.2bot, p32]
527
 */
528
529
void
530 981485
http_CollectHdr(struct http *hp, hdr_t hdr)
531
{
532
533 981485
        http_CollectHdrSep(hp, hdr, NULL);
534 981485
}
535
536
/*--------------------------------------------------------------------
537
 * You may prefer to collapse header fields using a different separator.
538
 * For Cookie headers, the separator is "; " for example. That's probably
539
 * the only example too.
540
 */
541
542
void
543 987549
http_CollectHdrSep(struct http *hp, hdr_t hdr, const char *sep)
544
{
545
        unsigned u, lsep, ml, f, x, d;
546 987549
        char *b = NULL, *e = NULL;
547
        const char *v;
548
549 987549
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
550 987549
        CHECK_HDR(hdr);
551
552 987549
        if (WS_Overflowed(hp->ws))
553 800
                return;
554
555 986749
        if (sep == NULL || *sep == '\0')
556 980678
                sep = ", ";
557 986769
        lsep = strlen(sep);
558
559 986769
        f = http_findhdr(hp, hdr->len - 1, hdr->str);
560 986769
        if (f == 0)
561 970177
                return;
562
563 61050
        for (d = u = f + 1; u < hp->nhd; u++) {
564 44458
                Tcheck(hp->hd[u]);
565 44458
                if (!http_IsHdr(&hp->hd[u], hdr)) {
566 43738
                        if (d != u) {
567 2840
                                hp->hd[d] = hp->hd[u];
568 2840
                                hp->hdf[d] = hp->hdf[u];
569 2840
                        }
570 43738
                        d++;
571 43738
                        continue;
572
                }
573 720
                if (b == NULL) {
574
                        /* Found second header, start our collection */
575 640
                        ml = WS_ReserveAll(hp->ws);
576 640
                        b = WS_Reservation(hp->ws);
577 640
                        e = b + ml;
578 640
                        x = Tlen(hp->hd[f]);
579 640
                        if (b + x >= e) {
580 0
                                http_fail(hp);
581 0
                                VSLbs(hp->vsl, SLT_LostHeader,
582 0
                                    TOSTRAND(hdr->str));
583 0
                                WS_Release(hp->ws, 0);
584 0
                                return;
585
                        }
586 640
                        memcpy(b, hp->hd[f].b, x);
587 640
                        b += x;
588 640
                }
589
590 720
                AN(b);
591 720
                AN(e);
592
593
                /* Append the Nth header we found */
594 720
                x = Tlen(hp->hd[u]) - hdr->len;
595
596 720
                v = hp->hd[u].b + hdr->len;
597 1440
                while (vct_issp(*v)) {
598 720
                        v++;
599 720
                        x--;
600
                }
601
602 720
                if (b + lsep + x >= e) {
603 0
                        http_fail(hp);
604 0
                        VSLbs(hp->vsl, SLT_LostHeader, TOSTRAND(hdr->str));
605 0
                        WS_Release(hp->ws, 0);
606 0
                        return;
607
                }
608 720
                memcpy(b, sep, lsep);
609 720
                b += lsep;
610 720
                memcpy(b, v, x);
611 720
                b += x;
612 720
        }
613 16592
        if (b == NULL)
614 15952
                return;
615 640
        hp->nhd = (uint16_t)d;
616 640
        AN(e);
617 640
        *b = '\0';
618 640
        hp->hd[f].b = WS_Reservation(hp->ws);
619 640
        hp->hd[f].e = b;
620 640
        WS_ReleaseP(hp->ws, b + 1);
621 987569
}
622
623
/*--------------------------------------------------------------------*/
624
625
int
626 5040561
http_GetHdr(const struct http *hp, hdr_t hdr, const char **ptr)
627
{
628
        unsigned u;
629
        const char *p;
630
631 5040561
        CHECK_HDR(hdr);
632 5040561
        u = http_findhdr(hp, hdr->len - 1, hdr->str);
633 5040561
        if (u == 0) {
634 3723051
                if (ptr != NULL)
635 3421934
                        *ptr = NULL;
636 3723051
                return (0);
637
        }
638 1317510
        if (ptr != NULL) {
639 1078559
                p = hp->hd[u].b + hdr->len;
640 2155329
                while (vct_issp(*p))
641 1076770
                        p++;
642 1078559
                *ptr = p;
643 1078559
        }
644 1317510
        return (1);
645 5040561
}
646
647
/*-----------------------------------------------------------------------------
648
 * Split source string at any of the separators, return pointer to first
649
 * and last+1 char of substrings, with whitespace trimmed at both ends.
650
 * If sep being an empty string is shorthand for VCT::SP
651
 * If stop is NULL, src is NUL terminated.
652
 */
653
654
static int
655 99385
http_split(const char **src, const char *stop, const char *sep,
656
    const char **b, const char **e)
657
{
658
        const char *p, *q;
659
660 99385
        AN(src);
661 99385
        AN(*src);
662 99385
        AN(sep);
663 99385
        AN(b);
664 99385
        AN(e);
665
666 99385
        if (stop == NULL)
667 99105
                stop = strchr(*src, '\0');
668
669 170257
        for (p = *src; p < stop && (vct_issp(*p) || strchr(sep, *p)); p++)
670 3480
                continue;
671
672 99385
        if (p >= stop) {
673 35473
                *b = NULL;
674 35473
                *e = NULL;
675 35473
                return (0);
676
        }
677
678 63912
        *b = p;
679 63912
        if (*sep == '\0') {
680 0
                for (q = p + 1; q < stop && !vct_issp(*q); q++)
681 0
                        continue;
682 0
                *e = q;
683 0
                *src = q;
684 0
                return (1);
685
        }
686 311120
        for (q = p + 1; q < stop && !strchr(sep, *q); q++)
687 247208
                continue;
688 63912
        *src = q;
689 63912
        while (q > p && vct_issp(q[-1]))
690 0
                q--;
691 63912
        *e = q;
692 63912
        return (1);
693 99385
}
694
695
/*-----------------------------------------------------------------------------
696
 * Comparison rule for tokens:
697
 *      if target string starts with '"', we use memcmp() and expect closing
698
 *      double quote as well
699
 *      otherwise we use http_tok_at()
700
 *
701
 * On match we increment *bp past the token name.
702
 */
703
704
static int
705 56399
http_istoken(const char **bp, const char *e, const char *token)
706
{
707 56399
        int fl = strlen(token);
708
        const char *b;
709
710 56399
        AN(bp);
711 56399
        AN(e);
712 56399
        AN(token);
713
714 56399
        b = *bp;
715
716 56399
        if (b + fl + 2 <= e && *b == '"' &&
717 0
            !memcmp(b + 1, token, fl) && b[fl + 1] == '"') {
718 0
                *bp += fl + 2;
719 0
                return (1);
720
        }
721 58039
        if (b + fl <= e && http_tok_at(b, token, fl) &&
722 26440
            (b + fl == e || !vct_istchar(b[fl]))) {
723 26440
                *bp += fl;
724 26440
                return (1);
725
        }
726 29959
        return (0);
727 56399
}
728
729
/*-----------------------------------------------------------------------------
730
 * Find a given data element (token) in a header according to RFC2616's #rule
731
 * (section 2.1, p15)
732
 *
733
 * On case sensitivity:
734
 *
735
 * Section 4.2 (Messages Headers) defines field (header) name as case
736
 * insensitive, but the field (header) value/content may be case-sensitive.
737
 *
738
 * http_GetHdrToken looks up a token in a header value and the rfc does not say
739
 * explicitly if tokens are to be compared with or without respect to case.
740
 *
741
 * But all examples and specific statements regarding tokens follow the rule
742
 * that unquoted tokens are to be matched case-insensitively and quoted tokens
743
 * case-sensitively.
744
 *
745
 * The optional pb and pe arguments will point to the token content start and
746
 * end+1, white space trimmed on both sides.
747
 */
748
749
int
750 601357
http_GetHdrToken(const struct http *hp, hdr_t hdr,
751
    const char *token, const char **pb, const char **pe)
752
{
753
        const char *h, *b, *e;
754
755 601357
        if (pb != NULL)
756 454232
                *pb = NULL;
757 601357
        if (pe != NULL)
758 142184
                *pe = NULL;
759 601357
        if (!http_GetHdr(hp, hdr, &h))
760 546437
                return (0);
761 54920
        AN(h);
762
763 84880
        while (http_split(&h, NULL, ",", &b, &e))
764 56400
                if (http_istoken(&b, e, token))
765 26440
                        break;
766 54920
        if (b == NULL)
767 28480
                return (0);
768 26440
        if (pb != NULL) {
769 26280
                for (; vct_islws(*b); b++)
770 200
                        continue;
771 26080
                if (b == e) {
772 24480
                        b = NULL;
773 24480
                        e = NULL;
774 24480
                }
775 26080
                *pb = b;
776 26080
                if (pe != NULL)
777 24200
                        *pe = e;
778 26080
        }
779 26440
        return (1);
780 601357
}
781
782
/*--------------------------------------------------------------------
783
 * Find a given header field's quality value (qvalue).
784
 */
785
786
double
787 142177
http_GetHdrQ(const struct http *hp, hdr_t hdr, const char *field)
788
{
789
        const char *hb, *he, *b, *e;
790
        int i;
791
        double a, f;
792
793 142177
        i = http_GetHdrToken(hp, hdr, field, &hb, &he);
794 142177
        if (!i)
795 117977
                return (0.);
796
797 24200
        if (hb == NULL)
798 23920
                return (1.);
799 280
        while (http_split(&hb, he, ";", &b, &e)) {
800 280
                if (*b != 'q')
801 0
                        continue;
802 280
                for (b++; b < e && vct_issp(*b); b++)
803 0
                        continue;
804 280
                if (b == e || *b != '=')
805 0
                        continue;
806 280
                break;
807
        }
808 280
        if (b == NULL)
809 0
                return (1.);
810 280
        for (b++; b < e && vct_issp(*b); b++)
811 0
                continue;
812 280
        if (b == e || (*b != '.' && !vct_isdigit(*b)))
813 40
                return (0.);
814 240
        a = 0;
815 480
        while (b < e && vct_isdigit(*b)) {
816 240
                a *= 10.;
817 240
                a += *b - '0';
818 240
                b++;
819
        }
820 240
        if (b == e || *b++ != '.')
821 40
                return (a);
822 200
        f = .1;
823 640
        while (b < e && vct_isdigit(*b)) {
824 440
                a += f * (*b - '0');
825 440
                f *= .1;
826 440
                b++;
827
        }
828 200
        return (a);
829 142177
}
830
831
/*--------------------------------------------------------------------
832
 * Find a given header field's value.
833
 */
834
835
int
836 312035
http_GetHdrField(const struct http *hp, hdr_t hdr,
837
    const char *field, const char **ptr)
838
{
839
        const char *h;
840
        int i;
841
842 312035
        if (ptr != NULL)
843 158719
                *ptr = NULL;
844
845 312035
        h = NULL;
846 312035
        i = http_GetHdrToken(hp, hdr, field, &h, NULL);
847 312035
        if (!i)
848 310155
                return (i);
849
850 1880
        if (ptr != NULL && h != NULL) {
851
                /* Skip whitespace, looking for '=' */
852 1320
                while (*h && vct_issp(*h))
853 0
                        h++;
854 1320
                if (*h == '=') {
855 1320
                        h++;
856 1480
                        while (*h && vct_issp(*h))
857 160
                                h++;
858 1320
                        *ptr = h;
859 1320
                }
860 1320
        }
861 1880
        return (i);
862 312035
}
863
864
/*--------------------------------------------------------------------*/
865
866
ssize_t
867 449407
http_GetContentLength(const struct http *hp)
868
{
869
        ssize_t cl;
870
        const char *b;
871
872 449407
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
873
874 449407
        if (!http_GetHdr(hp, H_Content_Length, &b))
875 176649
                return (-1);
876 272758
        cl = VNUM_uint(b, NULL, &b);
877 272758
        if (cl < 0)
878 160
                return (-2);
879 272598
        while (vct_islws(*b))
880 0
                b++;
881 272598
        if (*b != '\0')
882 0
                return (-2);
883 272598
        return (cl);
884 449407
}
885
886
ssize_t
887 80559
http_GetContentRange(const struct http *hp, ssize_t *lo, ssize_t *hi)
888
{
889
        ssize_t tmp, cl;
890
        const char *b, *t;
891
892 80559
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
893
894 80559
        if (lo == NULL)
895 0
                lo = &tmp;
896 80559
        if (hi == NULL)
897 0
                hi = &tmp;
898
899 80559
        *lo = *hi = -1;
900
901 80559
        if (!http_GetHdr(hp, H_Content_Range, &b))
902 80159
                return (-1);
903
904 400
        t = strchr(b, ' ');
905 400
        if (t == NULL)
906 40
                return (-2);            // Missing space after range unit
907
908 360
        if (!http_range_at(b, bytes, t - b))
909 40
                return (-1);            // Unknown range unit, ignore
910 320
        b = t + 1;
911
912 320
        if (*b == '*') {                // Content-Range: bytes */123
913 120
                *lo = *hi = -1;
914 120
                b++;
915 120
        } else {                        // Content-Range: bytes 1-2/3
916 200
                *lo = VNUM_uint(b, NULL, &b);
917 200
                if (*lo < 0)
918 0
                        return (-2);
919 200
                if (*b != '-')
920 0
                        return (-2);
921 200
                *hi = VNUM_uint(b + 1, NULL, &b);
922 200
                if (*hi < 0)
923 0
                        return (-2);
924
        }
925 320
        if (*b != '/')
926 0
                return (-2);
927 320
        if (b[1] == '*') {              // Content-Range: bytes 1-2/*
928 40
                cl = -1;
929 40
                b += 2;
930 40
        } else {
931 280
                cl = VNUM_uint(b + 1, NULL, &b);
932 280
                if (cl <= 0)
933 0
                        return (-2);
934
        }
935 320
        while (vct_islws(*b))
936 0
                b++;
937 320
        if (*b != '\0')
938 0
                return (-2);
939 320
        if (*lo > *hi)
940 0
                return (-2);
941 320
        assert(cl >= -1);
942 320
        if (*lo >= cl || *hi >= cl)
943 40
                return (-2);
944 280
        AN(cl);
945 280
        return (cl);
946 80559
}
947
948
const char *
949 82520
http_GetRange(const struct http *hp, ssize_t *lo, ssize_t *hi, ssize_t len)
950
{
951
        ssize_t tmp_lo, tmp_hi;
952
        const char *b, *t;
953
954 82520
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
955
956 82520
        if (lo == NULL)
957 0
                lo = &tmp_lo;
958 82520
        if (hi == NULL)
959 0
                hi = &tmp_hi;
960
961 82520
        *lo = *hi = -1;
962
963 82520
        if (!http_GetHdr(hp, H_Range, &b))
964 80320
                return (NULL);
965
966 2200
        t = strchr(b, '=');
967 2200
        if (t == NULL)
968 80
                return ("Missing '='");
969
970 2120
        if (!http_range_at(b, bytes, t - b))
971 120
                return ("Not Bytes");
972 2000
        b = t + 1;
973
974 2000
        *lo = VNUM_uint(b, NULL, &b);
975 2000
        if (*lo == -2)
976 0
                return ("Low number too big");
977 2000
        if (*b++ != '-')
978 0
                return ("Missing hyphen");
979
980 2000
        *hi = VNUM_uint(b, NULL, &b);
981 2000
        if (*hi == -2)
982 0
                return ("High number too big");
983 2000
        if (*lo == -1 && *hi == -1)
984 40
                return ("Neither high nor low");
985 1960
        if (*lo == -1 && *hi == 0)
986 40
                return ("No low, high is zero");
987 1920
        if (*hi >= 0 && *hi < *lo)
988 40
                return ("high smaller than low");
989
990 1920
        while (vct_islws(*b))
991 40
                b++;
992 1880
        if (*b != '\0')
993 40
                return ("Trailing stuff");
994
995 1840
        assert(*lo >= -1);
996 1840
        assert(*hi >= -1);
997
998 1840
        if (*lo < 0) {
999 160
                assert(*hi > 0);
1000 160
                *lo = len - *hi;
1001 160
                if (*lo < 0)
1002 80
                        *lo = 0;
1003 160
                *hi = len - 1;
1004 1840
        } else if (len >= 0 && (*hi >= len || *hi < 0)) {
1005 360
                *hi = len - 1;
1006 360
        }
1007
1008 1840
        if (len <= 0)
1009 720
                return (NULL);                  // Allow 200 response
1010
1011 1120
        if (*lo >= len)
1012 40
                return ("low range beyond object");
1013
1014 1080
        return (NULL);
1015 82520
}
1016
1017
/*--------------------------------------------------------------------
1018
 */
1019
1020
stream_close_t
1021 236256
http_DoConnection(struct http *hp, stream_close_t sc_close)
1022
{
1023
        const char *h, *b, *e;
1024
        stream_close_t retval;
1025
        unsigned u, v;
1026
        struct http_hdrflg *f;
1027
1028 236256
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
1029 236256
        assert(sc_close == SC_REQ_CLOSE || sc_close == SC_RESP_CLOSE);
1030
1031 236256
        if (hp->protover == 10)
1032 1554
                retval = SC_REQ_HTTP10;
1033
        else
1034 234702
                retval = SC_NULL;
1035
1036 236256
        http_CollectHdr(hp, H_Connection);
1037 236256
        if (!http_GetHdr(hp, H_Connection, &h))
1038 229143
                return (retval);
1039 7113
        AN(h);
1040 14226
        while (http_split(&h, NULL, ",", &b, &e)) {
1041 7233
                u = pdiff(b, e);
1042 7233
                if (u == 5 && http_hdr_at(b, "close", u))
1043 5833
                        retval = sc_close;
1044 7233
                if (u == 10 && http_hdr_at(b, "keep-alive", u))
1045 920
                        retval = SC_NULL;
1046
1047
                /* Refuse removal of well-known-headers if they would pass. */
1048 7233
                f = http_hdr_flags(b, e);
1049 7233
                if (f != NULL && !(f->flag & HTTPH_R_PASS))
1050 120
                        return (SC_RX_BAD);
1051
1052 34473
                for (v = HTTP_HDR_FIRST; v < hp->nhd; v++) {
1053 27360
                        Tcheck(hp->hd[v]);
1054 27360
                        if (hp->hd[v].e < hp->hd[v].b + u + 1)
1055 1240
                                continue;
1056 26120
                        if (hp->hd[v].b[u] != ':')
1057 24120
                                continue;
1058 2000
                        if (!http_hdr_at(b, hp->hd[v].b, u))
1059 1520
                                continue;
1060 480
                        hp->hdf[v] |= HDF_FILTER;
1061 480
                }
1062
        }
1063 6993
        CHECK_OBJ_NOTNULL(retval, STREAM_CLOSE_MAGIC);
1064 6993
        return (retval);
1065 236256
}
1066
1067
/*--------------------------------------------------------------------*/
1068
1069
int
1070 464835
http_HdrIs(const struct http *hp, hdr_t hdr, const char *val)
1071
{
1072
        const char *p;
1073
1074 464835
        if (!http_GetHdr(hp, hdr, &p))
1075 441101
                return (0);
1076 23734
        AN(p);
1077 23734
        if (http_tok_eq(p, val))
1078 22694
                return (1);
1079 1040
        return (0);
1080 464835
}
1081
1082
/*--------------------------------------------------------------------*/
1083
1084
uint16_t
1085 581248
http_GetStatus(const struct http *hp)
1086
{
1087
1088 581248
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
1089 581248
        return (hp->status);
1090
}
1091
1092
int
1093 402759
http_IsStatus(const struct http *hp, int val)
1094
{
1095
1096 402759
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
1097 402759
        assert(val >= 100 && val <= 999);
1098 402759
        return (val == (hp->status % 1000));
1099
}
1100
1101
/*--------------------------------------------------------------------
1102
 * Setting the status will also set the Reason appropriately
1103
 */
1104
1105
void
1106 45639
http_SetStatus(struct http *to, uint16_t status, const char *reason)
1107
{
1108
        char buf[4];
1109 45639
        const char *sstr = NULL;
1110
1111 45639
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1112
        /*
1113
         * We allow people to use top digits for internal VCL
1114
         * signalling, but strip them from the ASCII version.
1115
         */
1116 45639
        to->status = status;
1117 45639
        status %= 1000;
1118 45639
        assert(status >= 100);
1119
1120 45639
        if (reason == NULL)
1121 9320
                reason = http_Status2Reason(status, &sstr);
1122
        else
1123 36319
                (void)http_Status2Reason(status, &sstr);
1124
1125 45639
        if (sstr) {
1126 44199
                http_SetH(to, HTTP_HDR_STATUS, sstr);
1127 44199
        } else {
1128 1440
                bprintf(buf, "%03d", status);
1129 1440
                http_PutField(to, HTTP_HDR_STATUS, buf);
1130
        }
1131 45639
        http_SetH(to, HTTP_HDR_REASON, reason);
1132 45639
}
1133
1134
/*--------------------------------------------------------------------*/
1135
1136
const char *
1137 212169
http_GetMethod(const struct http *hp)
1138
{
1139
1140 212169
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
1141 212169
        Tcheck(hp->hd[HTTP_HDR_METHOD]);
1142 212169
        return (hp->hd[HTTP_HDR_METHOD].b);
1143
}
1144
1145
/*--------------------------------------------------------------------
1146
 * Force a particular header field to a particular value
1147
 */
1148
1149
void
1150 311951
http_ForceField(struct http *to, unsigned n, const char *t)
1151
{
1152
        int i;
1153
1154 311951
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1155 311951
        assert(n < HTTP_HDR_FIRST);
1156 311951
        assert(n == HTTP_HDR_METHOD || n == HTTP_HDR_PROTO);
1157 311951
        AN(t);
1158
1159
        /* NB: method names and protocol versions are case-sensitive. */
1160 311951
        if (to->hd[n].b == NULL || strcmp(to->hd[n].b, t)) {
1161 4800
                i = (HTTP_HDR_UNSET - HTTP_HDR_METHOD);
1162 4800
                i += to->logtag;
1163
                /* XXX: this is a dead branch */
1164 4800
                if (n >= HTTP_HDR_FIRST)
1165 0
                        VSLbt(to->vsl, (enum VSL_tag_e)i, to->hd[n]);
1166 4800
                http_SetH(to, n, t);
1167 4800
        }
1168 311953
}
1169
1170
/*--------------------------------------------------------------------*/
1171
1172
void
1173 41633
http_PutResponse(struct http *to, const char *proto, uint16_t status,
1174
    const char *reason)
1175
{
1176
1177 41633
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1178 41633
        if (proto != NULL)
1179 41632
                http_SetH(to, HTTP_HDR_PROTO, proto);
1180 41633
        http_SetStatus(to, status, reason);
1181 41633
}
1182
1183
/*--------------------------------------------------------------------
1184
 * check if header is filtered by the dynamic marker or the static
1185
 * definitions in http_headers.h
1186
 */
1187
1188
static inline int
1189 1609775
http_isfiltered(const struct http *fm, unsigned u, unsigned how)
1190
{
1191
        const char *e;
1192
        const struct http_hdrflg *f;
1193
1194 1609775
        if (fm->hdf[u] & HDF_FILTER)
1195 680
                return (1);
1196 1609095
        if (u < HTTP_HDR_FIRST)
1197 539338
                return (0);
1198 1069757
        e = strchr(fm->hd[u].b, ':');
1199 1069757
        if (e == NULL)
1200 0
                return (0);
1201 1069757
        f = http_hdr_flags(fm->hd[u].b, e);
1202 1069757
        return (f != NULL && f->flag & how);
1203 1609775
}
1204
1205
int
1206 33585
http_IsFiltered(const struct http *fm, unsigned u, unsigned how)
1207
{
1208
1209 33585
        return (http_isfiltered(fm, u, how));
1210
}
1211
1212
/*--------------------------------------------------------------------
1213
 * Estimate how much workspace we need to Filter this header according
1214
 * to 'how'.
1215
 */
1216
1217
unsigned
1218 90039
http_EstimateWS(const struct http *fm, unsigned how)
1219
{
1220
        unsigned u, l;
1221
1222 90039
        l = 4;
1223 90039
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);
1224 861423
        for (u = 0; u < fm->nhd; u++) {
1225 771384
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
1226 180074
                        continue;
1227 591310
                Tcheck(fm->hd[u]);
1228 591310
                if (http_isfiltered(fm, u, how))
1229 10527
                        continue;
1230 580783
                l += Tlen(fm->hd[u]) + 1L;
1231 580783
        }
1232 90039
        return (PRNDUP(l + 1L));
1233
}
1234
1235
/*--------------------------------------------------------------------
1236
 * Encode http struct as byte string.
1237
 *
1238
 * XXX: We could save considerable special-casing below by encoding also
1239
 * XXX: H__Status, H__Reason and H__Proto into the string, but it would
1240
 * XXX: add 26-30 bytes to all encoded objects to save a little code.
1241
 * XXX: It could possibly be a good idea for later HTTP versions.
1242
 */
1243
1244
void
1245 89795
HTTP_Encode(const struct http *fm, uint8_t *p0, unsigned l, unsigned how)
1246
{
1247
        unsigned u, w;
1248
        uint16_t n;
1249
        uint8_t *p, *e;
1250
1251 89795
        AN(p0);
1252 89795
        AN(l);
1253 89795
        p = p0;
1254 89795
        e = p + l;
1255 89795
        assert(p + 5 <= e);
1256 89795
        assert(fm->nhd <= fm->shd);
1257 89795
        n = HTTP_HDR_FIRST - 3;
1258 89795
        vbe16enc(p + 2, fm->status);
1259 89795
        p += 4;
1260 89795
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);
1261 858887
        for (u = 0; u < fm->nhd; u++) {
1262 769092
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
1263 179596
                        continue;
1264 589496
                Tcheck(fm->hd[u]);
1265 589496
                if (http_isfiltered(fm, u, how))
1266 10527
                        continue;
1267 578969
                http_VSLH(fm, u);
1268 578969
                w = Tlen(fm->hd[u]) + 1L;
1269 578969
                assert(p + w + 1 <= e);
1270 578969
                memcpy(p, fm->hd[u].b, w);
1271 578969
                p += w;
1272 578969
                n++;
1273 578969
        }
1274 89795
        *p++ = '\0';
1275 89795
        assert(p <= e);
1276 89795
        vbe16enc(p0, n + 1);
1277 89795
}
1278
1279
/*--------------------------------------------------------------------
1280
 * Decode byte string into http struct
1281
 */
1282
1283
int
1284 132284
HTTP_Decode(struct http *to, const uint8_t *fm)
1285
{
1286
1287 132284
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1288 132284
        AN(to->vsl);
1289 132284
        AN(fm);
1290 132284
        if (vbe16dec(fm) <= to->shd) {
1291 132205
                to->status = vbe16dec(fm + 2);
1292 132205
                fm += 4;
1293 1253927
                for (to->nhd = 0; to->nhd < to->shd; to->nhd++) {
1294 1253927
                        if (to->nhd == HTTP_HDR_METHOD ||
1295 1121588
                            to->nhd == HTTP_HDR_URL) {
1296 264399
                                to->hd[to->nhd].b = NULL;
1297 264399
                                to->hd[to->nhd].e = NULL;
1298 264399
                                continue;
1299
                        }
1300 989528
                        if (*fm == '\0')
1301 132205
                                return (0);
1302 857323
                        to->hd[to->nhd].b = (const void*)fm;
1303 857323
                        fm = (const void*)strchr((const void*)fm, '\0');
1304 857323
                        to->hd[to->nhd].e = (const void*)fm;
1305 857323
                        fm++;
1306 857323
                        http_VSLH(to, to->nhd);
1307 857323
                }
1308 0
        }
1309 158
        VSLb(to->vsl, SLT_Error,
1310
            "Too many headers to Decode object (%u vs. %u)",
1311 79
            vbe16dec(fm), to->shd);
1312 79
        return (-1);
1313 132284
}
1314
1315
/*--------------------------------------------------------------------*/
1316
1317
uint16_t
1318 1320
HTTP_GetStatusPack(struct worker *wrk, struct objcore *oc)
1319
{
1320
        const char *ptr;
1321 1320
        ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
1322 1320
        AN(ptr);
1323
1324 1320
        return (vbe16dec(ptr + 2));
1325
}
1326
1327
/*--------------------------------------------------------------------*/
1328
1329
/* Get the first packed header */
1330
int
1331 35938
HTTP_IterHdrPack(struct worker *wrk, struct objcore *oc, const char **p)
1332
{
1333
        const char *ptr;
1334
1335 35938
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1336 35938
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
1337 35938
        AN(p);
1338
1339 35938
        if (*p == NULL) {
1340 11007
                ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
1341 11007
                AN(ptr);
1342 11007
                ptr += 4;       /* Skip nhd and status */
1343 11007
                ptr = strchr(ptr, '\0') + 1;    /* Skip :proto: */
1344 11007
                ptr = strchr(ptr, '\0') + 1;    /* Skip :status: */
1345 11007
                ptr = strchr(ptr, '\0') + 1;    /* Skip :reason: */
1346 11007
                *p = ptr;
1347 11007
        } else {
1348 24931
                *p = strchr(*p, '\0') + 1;      /* Skip to next header */
1349
        }
1350 35938
        if (**p == '\0')
1351 2305
                return (0);
1352 33633
        return (1);
1353 35938
}
1354
1355
const char *
1356 11728
HTTP_GetHdrPack(struct worker *wrk, struct objcore *oc, hdr_t hdr)
1357
{
1358
        const char *ptr;
1359
1360 11728
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1361 11728
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
1362 11728
        CHECK_HDR(hdr);
1363
1364 11728
        if (hdr->str[0] == ':') {
1365
                /* Special cases */
1366 720
                ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
1367 720
                AN(ptr);
1368 720
                ptr += 4;       /* Skip nhd and status */
1369
1370
                /* XXX: should we also have h2_hdr_eq() ? */
1371 720
                if (!strcmp(hdr->str, ":proto:"))
1372 80
                        return (ptr);
1373 640
                ptr = strchr(ptr, '\0') + 1;
1374 640
                if (!strcmp(hdr->str, ":status:"))
1375 560
                        return (ptr);
1376 80
                ptr = strchr(ptr, '\0') + 1;
1377 80
                if (!strcmp(hdr->str, ":reason:"))
1378 80
                        return (ptr);
1379 0
                WRONG("Unknown magic packed header");
1380 0
        }
1381
1382 35941
        HTTP_FOREACH_PACK(wrk, oc, ptr) {
1383 33636
                if (http_hdr_at(ptr, hdr->str, hdr->len)) {
1384 8703
                        ptr += hdr->len;
1385 17365
                        while (vct_islws(*ptr))
1386 8662
                                ptr++;
1387 8703
                        return (ptr);
1388
                }
1389
        }
1390
1391 2305
        return (NULL);
1392 11728
}
1393
1394
/*--------------------------------------------------------------------
1395
 * Merge any headers in the oc->OA_HEADER into the struct http if they
1396
 * are not there already.
1397
 */
1398
1399
void
1400 1200
HTTP_Merge(struct worker *wrk, struct objcore *oc, struct http *to)
1401
{
1402
        const char *ptr;
1403
        unsigned u;
1404
        const char *p;
1405
        unsigned nhd_before_merge;
1406
1407 1200
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
1408 1200
        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
1409 1200
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1410
1411 1200
        ptr = ObjGetAttr(wrk, oc, OA_HEADERS, NULL);
1412 1200
        AN(ptr);
1413
1414 1200
        to->status = vbe16dec(ptr + 2);
1415 1200
        ptr += 4;
1416
1417 7200
        for (u = 0; u < HTTP_HDR_FIRST; u++) {
1418 6000
                if (u == HTTP_HDR_METHOD || u == HTTP_HDR_URL)
1419 2400
                        continue;
1420 3600
                http_SetH(to, u, ptr);
1421 3600
                ptr = strchr(ptr, '\0') + 1;
1422 3600
        }
1423 1200
        nhd_before_merge = to->nhd;
1424 7200
        while (*ptr != '\0') {
1425 6000
                p = strchr(ptr, ':');
1426 6000
                AN(p);
1427 6000
                u = http_findhdr(to, p - ptr, ptr);
1428 6000
                if (u == 0 || u >= nhd_before_merge)
1429 2840
                        http_SetHeader(to, ptr);
1430 6000
                ptr = strchr(ptr, '\0') + 1;
1431
        }
1432 1200
}
1433
1434
/*--------------------------------------------------------------------*/
1435
1436
static void
1437 276462
http_linkh(const struct http *to, const struct http *fm, unsigned n)
1438
{
1439
1440 276462
        assert(n < HTTP_HDR_FIRST);
1441 276462
        Tcheck(fm->hd[n]);
1442 276462
        to->hd[n] = fm->hd[n];
1443 276462
        to->hdf[n] = fm->hdf[n];
1444 276462
        http_VSLH(to, n);
1445 276462
}
1446
1447
/*--------------------------------------------------------------------*/
1448
1449
void
1450 92158
http_FilterReq(struct http *to, const struct http *fm, unsigned how)
1451
{
1452
        unsigned u;
1453
1454 92158
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1455 92158
        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC);
1456
1457 92158
        http_linkh(to, fm, HTTP_HDR_METHOD);
1458 92158
        http_linkh(to, fm, HTTP_HDR_URL);
1459 92158
        http_linkh(to, fm, HTTP_HDR_PROTO);
1460 92158
        to->protover = fm->protover;
1461 92158
        to->status = fm->status;
1462
1463 92158
        to->nhd = HTTP_HDR_FIRST;
1464 487541
        for (u = HTTP_HDR_FIRST; u < fm->nhd; u++) {
1465 395383
                Tcheck(fm->hd[u]);
1466 395383
                if (http_isfiltered(fm, u, how))
1467 4600
                        continue;
1468 390783
                assert (to->nhd < to->shd);
1469 390783
                to->hd[to->nhd] = fm->hd[u];
1470 390783
                to->hdf[to->nhd] = 0;
1471 390783
                http_VSLH(to, to->nhd);
1472 390783
                to->nhd++;
1473 390783
        }
1474 92158
}
1475
1476
/*--------------------------------------------------------------------
1477
 * This function copies any header fields which reference foreign
1478
 * storage into our own WS.
1479
 */
1480
1481
void
1482 90956
http_CopyHome(const struct http *hp)
1483
{
1484
        unsigned u, l;
1485
        const char *p;
1486
1487 988878
        for (u = 0; u < hp->nhd; u++) {
1488 897922
                if (hp->hd[u].b == NULL) {
1489 181908
                        assert(u < HTTP_HDR_FIRST);
1490 181908
                        continue;
1491
                }
1492
1493 716014
                l = Tlen(hp->hd[u]);
1494 716014
                if (WS_Allocated(hp->ws, hp->hd[u].b, l))
1495 57706
                        continue;
1496
1497 658308
                p = WS_Copy(hp->ws, hp->hd[u].b, l + 1L);
1498 658308
                if (p == NULL) {
1499 0
                        http_fail(hp);
1500 0
                        VSLbs(hp->vsl, SLT_LostHeader, TOSTRAND(hp->hd[u].b));
1501 0
                        return;
1502
                }
1503 658308
                hp->hd[u].b = p;
1504 658308
                hp->hd[u].e = p + l;
1505 658308
        }
1506 90956
}
1507
1508
/*--------------------------------------------------------------------*/
1509
1510
void
1511 380466
http_SetHeader(struct http *to, const char *header)
1512
{
1513
1514 380466
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1515 380466
        if (to->nhd >= to->shd) {
1516 40
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(header));
1517 40
                http_fail(to);
1518 40
                return;
1519
        }
1520 380426
        http_SetH(to, to->nhd++, header);
1521 380466
}
1522
1523
/*--------------------------------------------------------------------*/
1524
1525
void
1526 169587
http_ForceHeader(struct http *to, hdr_t hdr, const char *val)
1527
{
1528
1529 169587
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1530 169587
        if (http_HdrIs(to, hdr, val))
1531 15454
                return;
1532 154133
        http_Unset(to, hdr);
1533 154133
        http_PrintfHeader(to, "%s %s", hdr->str, val);
1534 169587
}
1535
1536
void
1537 433225
http_AppendHeader(struct http *to, hdr_t hdr, const char *val)
1538
{
1539
        const char *old;
1540
1541 433225
        http_CollectHdr(to, hdr);
1542 433225
        if (http_GetHdr(to, hdr, &old)) {
1543 1920
                http_Unset(to, hdr);
1544 1920
                http_PrintfHeader(to, "%s %s, %s", hdr->str, old, val);
1545 1920
        } else {
1546 431305
                http_PrintfHeader(to, "%s %s", hdr->str, val);
1547
        }
1548 433225
}
1549
1550
void
1551 1018883
http_PrintfHeader(struct http *to, const char *fmt, ...)
1552
{
1553
        va_list ap, ap2;
1554
        struct vsb vsb[1];
1555
        size_t sz;
1556
        char *p;
1557
1558 1018883
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1559
1560 1018883
        va_start(ap, fmt);
1561 1018883
        va_copy(ap2, ap);
1562
1563 1018883
        WS_VSB_new(vsb, to->ws);
1564 1018883
        VSB_vprintf(vsb, fmt, ap);
1565 1018883
        p = WS_VSB_finish(vsb, to->ws, &sz);
1566
1567 1018883
        if (p == NULL || to->nhd >= to->shd) {
1568 1091
                http_fail(to);
1569 1091
                VSLbv(to->vsl, SLT_LostHeader, fmt, ap2);
1570 1091
        } else {
1571 1017812
                http_SetH(to, to->nhd++, p);
1572
        }
1573 1018903
        va_end(ap);
1574 1018903
        va_end(ap2);
1575 1018903
}
1576
1577
void
1578 41951
http_TimeHeader(struct http *to, const char *fmt, vtim_real now)
1579
{
1580
        char *p;
1581
1582 41951
        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC);
1583 41951
        if (to->nhd >= to->shd) {
1584 0
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
1585 0
                http_fail(to);
1586 0
                return;
1587
        }
1588 41951
        p = WS_Alloc(to->ws, strlen(fmt) + VTIM_FORMAT_SIZE);
1589 41951
        if (p == NULL) {
1590 3080
                http_fail(to);
1591 3080
                VSLbs(to->vsl, SLT_LostHeader, TOSTRAND(fmt));
1592 3080
                return;
1593
        }
1594 38871
        strcpy(p, fmt);
1595 38871
        VTIM_format(now, strchr(p, '\0'));
1596 38871
        http_SetH(to, to->nhd++, p);
1597 41951
}
1598
1599
const char *
1600 282715
http_ViaHeader(void)
1601
{
1602
1603 282715
        return (via_hdr);
1604
}
1605
1606
/*--------------------------------------------------------------------*/
1607
1608
void
1609 926792
http_Unset(struct http *hp, hdr_t hdr)
1610
{
1611
        uint16_t u, v;
1612
1613 6023220
        for (v = u = HTTP_HDR_FIRST; u < hp->nhd; u++) {
1614 5096428
                Tcheck(hp->hd[u]);
1615 5096428
                if (http_IsHdr(&hp->hd[u], hdr)) {
1616 41360
                        http_VSLH_del(hp, u);
1617 41360
                        continue;
1618
                }
1619 5055068
                if (v != u) {
1620 118379
                        memcpy(&hp->hd[v], &hp->hd[u], sizeof *hp->hd);
1621 118379
                        memcpy(&hp->hdf[v], &hp->hdf[u], sizeof *hp->hdf);
1622 118379
                }
1623 5055068
                v++;
1624 5055068
        }
1625 926792
        hp->nhd = v;
1626 926792
}