Code Coverage: vinyl-cache/bin/vinyld/http2/cache_http2_session.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2016 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 */
30
31
#include "config.h"
32
33
#include "cache/cache_int.h"
34
35
#include <stdio.h>
36
37
#include "cache/cache_transport.h"
38
#include "http2/cache_http2.h"
39
40
#include "vend.h"
41
#include "vtcp.h"
42
43
static const char h2_resp_101[] =
44
        "HTTP/1.1 101 Switching Protocols\r\n"
45
        "Connection: Upgrade\r\n"
46
        "Upgrade: h2c\r\n"
47
        "\r\n";
48
49
static const char H2_prism[24] = {
50
        0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54,
51
        0x54, 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x0d, 0x0a,
52
        0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a, 0x0d, 0x0a
53
};
54
55
static size_t
56
h2_enc_settings(const struct h2_settings *h2s, uint8_t *buf, ssize_t n)
57 153
{
58 153
        uint8_t *p = buf;
59
60 153
#define H2_SETTING(U,l,v,d,...)                         \
61 1377
        if (h2s->l != d) {                              \
62 444
                n -= 6;                                 \
63 444
                assert(n >= 0);                         \
64 444
                vbe16enc(p, v);                         \
65 444
                p += 2;                                 \
66 444
                vbe32enc(p, h2s->l);                    \
67 444
                p += 4;                                 \
68 444
        }
69 153
#include "tbl/h2_settings.h"
70 153
        return (p - buf);
71 1224
}
72
73
static const struct h2_settings H2_proto_settings = {
74
#define H2_SETTING(U,l,v,d,...) . l = d,
75
#include "tbl/h2_settings.h"
76
};
77
78
static void
79
h2_local_settings(struct h2_settings *h2s)
80 157
{
81 157
        *h2s = H2_proto_settings;
82 157
#define H2_SETTINGS_PARAM_ONLY
83 157
#define H2_SETTING(U, l, ...)                   \
84 628
        h2s->l = cache_param->h2_##l;
85 157
#include "tbl/h2_settings.h"
86 157
#undef H2_SETTINGS_PARAM_ONLY
87 157
        h2s->max_header_list_size = cache_param->http_req_size;
88 157
}
89
90
void
91
H2S_Lock_VSLb(const struct h2_sess *h2, enum VSL_tag_e tag, const char *fmt, ...)
92 276
{
93 276
        va_list ap;
94 276
        int held = 0;
95
96 276
        AN(h2);
97
98 276
        if (VSL_tag_is_masked(tag))
99 0
                return;
100
101 276
        if (h2->highest_stream > 0) {
102 251
                held = 1;
103 251
                Lck_Lock(&h2->sess->mtx);
104 251
        }
105
106 276
        va_start(ap, fmt);
107 276
        VSLbv(h2->vsl, tag, fmt, ap);
108 276
        va_end(ap);
109
110 276
        if (held)
111 251
                Lck_Unlock(&h2->sess->mtx);
112 276
}
113
114
/**********************************************************************
115
 * The h2_sess struct needs many of the same things as a request,
116
 * WS, VSL, HTC &c,  but rather than implement all that stuff over, we
117
 * grab an actual struct req, and mirror the relevant fields into
118
 * struct h2_sess.
119
 */
120
121
static struct h2_sess *
122
h2_init_sess(struct sess *sp,
123
    struct h2_sess *h2s, struct req *srq, struct h2h_decode *decode)
124 157
{
125 157
        uintptr_t *up;
126 157
        struct h2_sess *h2;
127
128
        /* proto_priv session attribute will always have been set up by H1
129
         * before reaching here. */
130 157
        AZ(SES_Get_proto_priv(sp, &up));
131 157
        assert(*up == 0);
132
133 157
        if (srq == NULL)
134 7
                srq = Req_New(sp, NULL);
135 157
        AN(srq);
136 157
        h2 = h2s;
137 157
        AN(h2);
138 157
        INIT_OBJ(h2, H2_SESS_MAGIC);
139 157
        h2->srq = srq;
140 157
        h2->htc = srq->htc;
141 157
        h2->ws = srq->ws;
142 157
        h2->vsl = srq->vsl;
143 157
        VSL_Flush(h2->vsl, 0);
144 157
        h2->vsl->wid = sp->vxid;
145 157
        h2->htc->rfd = &sp->fd;
146 157
        h2->sess = sp;
147 157
        h2->rxthr = pthread_self();
148 157
        PTOK(pthread_cond_init(h2->winupd_cond, NULL));
149 157
        VTAILQ_INIT(&h2->streams);
150 157
        VTAILQ_INIT(&h2->txqueue);
151 157
        h2_local_settings(&h2->local_settings);
152 157
        h2->remote_settings = H2_proto_settings;
153 157
        h2->decode = decode;
154
155 157
        h2->rapid_reset = cache_param->h2_rapid_reset;
156 157
        h2->rapid_reset_limit = cache_param->h2_rapid_reset_limit;
157 157
        h2->rapid_reset_period = cache_param->h2_rapid_reset_period;
158
159 157
        h2->rst_budget = h2->rapid_reset_limit;
160 157
        h2->last_rst = sp->t_open;
161 157
        AZ(isnan(h2->last_rst));
162
163 157
        AZ(VHT_Init(h2->dectbl, h2->local_settings.header_table_size));
164
165 157
        *up = (uintptr_t)h2;
166
167 157
        return (h2);
168 157
}
169
170
static void
171
h2_del_sess(struct worker *wrk, struct h2_sess *h2, stream_close_t reason)
172 156
{
173 156
        struct sess *sp;
174 156
        struct req *req;
175
176 156
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
177 156
        AZ(h2->refcnt);
178 156
        assert(VTAILQ_EMPTY(&h2->streams));
179 156
        AN(reason);
180
181 156
        VHT_Fini(h2->dectbl);
182 156
        PTOK(pthread_cond_destroy(h2->winupd_cond));
183 156
        TAKE_OBJ_NOTNULL(req, &h2->srq, REQ_MAGIC);
184 156
        assert(!WS_IsReserved(req->ws));
185 156
        sp = h2->sess;
186 156
        Req_Cleanup(sp, wrk, req);
187 156
        Req_Release(req);
188 156
        SES_Delete(sp, reason, NAN);
189 156
}
190
191
/**********************************************************************/
192
193
enum htc_status_e v_matchproto_(htc_complete_f)
194
H2_prism_complete(struct http_conn *htc)
195 12087
{
196 12087
        size_t sz;
197
198 12087
        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
199 12087
        sz = sizeof(H2_prism);
200 12087
        if (htc->rxbuf_b + sz > htc->rxbuf_e)
201 264
                sz = htc->rxbuf_e - htc->rxbuf_b;
202 12087
        if (vmemcmp(htc->rxbuf_b, H2_prism, sz))
203 11465
                return (HTC_S_JUNK);
204 622
        return (sz == sizeof(H2_prism) ? HTC_S_COMPLETE : HTC_S_MORE);
205 12087
}
206
207
208
/**********************************************************************
209
 * Deal with the base64url (NB: ...url!) encoded SETTINGS in the H1 req
210
 * of a H2C upgrade.
211
 */
212
213
static int
214
h2_b64url_settings(struct h2_sess *h2, struct req *req)
215 7
{
216 7
        const char *p, *q;
217 7
        uint8_t u[6], *up;
218 7
        unsigned x;
219 7
        int i, n;
220 7
        static const char s[] =
221 7
            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
222 7
            "abcdefghijklmnopqrstuvwxyz"
223 7
            "0123456789"
224 7
            "-_=";
225
226
        /*
227
         * If there is trouble with this, we could reject the upgrade
228
         * but putting this on the H1 side is just plain wrong...
229
         */
230 7
        if (!http_GetHdr(req->http, H_HTTP2_Settings, &p))
231 1
                return (-1);
232 6
        AN(p);
233 6
        VSLb(req->vsl, SLT_Debug, "H2CS %s", p);
234
235 6
        n = 0;
236 6
        x = 0;
237 6
        up = u;
238 86
        for (;*p; p++) {
239 81
                q = strchr(s, *p);
240 81
                if (q == NULL)
241 1
                        return (-1);
242 80
                i = q - s;
243 80
                assert(i >= 0 && i <= 64);
244 80
                x <<= 6;
245 80
                x |= i;
246 80
                n += 6;
247 80
                if (n < 8)
248 20
                        continue;
249 60
                *up++ = (uint8_t)(x >> (n - 8));
250 60
                n -= 8;
251 60
                if (up == u + sizeof u) {
252 10
                        AZ(n);
253 10
                        if (h2_set_setting(h2, (void*)u))
254 0
                                return (-1);
255 10
                        up = u;
256 10
                }
257 60
        }
258 5
        if (up != u)
259 0
                return (-1);
260 5
        return (0);
261 5
}
262
263
264
/**********************************************************************/
265
266
static int
267
h2_ou_rel(struct worker *wrk, struct req *req)
268 2
{
269 2
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
270 2
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
271 2
        AZ(req->vcl);
272 2
        Req_AcctLogCharge(wrk->stats, req);
273 2
        Req_Release(req);
274 2
        return (0);
275 2
}
276
277
static int
278
h2_ou_session(struct worker *wrk, struct h2_sess *h2,
279
    struct req *req)
280 7
{
281 7
        ssize_t sz;
282 7
        enum htc_status_e hs;
283 7
        struct h2_req *r2;
284
285 7
        if (h2_b64url_settings(h2, req)) {
286 2
                VSLb(h2->vsl, SLT_Debug, "H2: Bad HTTP-Settings");
287 2
                return (h2_ou_rel(wrk, req));
288 2
        }
289
290 5
        sz = write(h2->sess->fd, h2_resp_101, vstrlen(h2_resp_101));
291 5
        VTCP_Assert(sz);
292 5
        if (sz != vstrlen(h2_resp_101)) {
293 0
                VSLb(h2->vsl, SLT_Debug, "H2: Upgrade: Error writing 101"
294 0
                    " response: %s\n", VAS_errtxt(errno));
295 0
                return (h2_ou_rel(wrk, req));
296 0
        }
297
298 5
        http_Unset(req->http, H_Upgrade);
299 5
        http_Unset(req->http, H_HTTP2_Settings);
300
301
        /* Steal pipelined read-ahead, if any */
302 5
        h2->htc->pipeline_b = req->htc->pipeline_b;
303 5
        h2->htc->pipeline_e = req->htc->pipeline_e;
304 5
        req->htc->pipeline_b = NULL;
305 5
        req->htc->pipeline_e = NULL;
306
        /* XXX: This call may assert on buffer overflow if the pipelined
307
           data exceeds the available space in the ws workspace. What to
308
           do about the overflowing data is an open issue. */
309 5
        HTC_RxInit(h2->htc, h2->ws);
310
311
        /* Start req thread */
312 5
        r2 = h2_new_req(h2, 1, req);
313 5
        AZ(h2->highest_stream);
314 5
        h2->highest_stream = r2->stream;
315 5
        req->transport = &HTTP2_transport;
316 5
        assert(req->req_step == R_STP_TRANSPORT);
317 5
        req->task->func = h2_do_req;
318 5
        req->task->priv = req;
319 5
        r2->scheduled = 1;
320 5
        r2->state = H2_S_CLOS_REM; // rfc7540,l,489,491
321 5
        req->err_code = 0;
322 5
        http_SetH(req->http, HTTP_HDR_PROTO, "HTTP/2.0");
323
324
        /* Wait for PRISM response */
325 5
        hs = HTC_RxStuff(h2->htc, H2_prism_complete,
326 5
            NULL, NULL, NAN, h2->sess->t_idle + cache_param->timeout_idle, NAN,
327 5
            sizeof H2_prism);
328 5
        if (hs != HTC_S_COMPLETE) {
329 1
                VSLb(h2->vsl, SLT_Debug, "H2: No/Bad OU PRISM (hs=%d)", hs);
330 1
                r2->scheduled = 0;
331 1
                h2_del_req(wrk, r2);
332 1
                return (0);
333 1
        }
334 4
        if (Pool_Task(wrk->pool, req->task, TASK_QUEUE_REQ)) {
335 1
                r2->scheduled = 0;
336 1
                h2_del_req(wrk, r2);
337 1
                VSLb(h2->vsl, SLT_Debug, "H2: No Worker-threads");
338 1
                return (0);
339 1
        }
340 3
        return (1);
341 4
}
342
343
/**********************************************************************
344
 */
345
346 307
#define H2_PU_MARKER    1
347 321
#define H2_OU_MARKER    2
348
349
void
350
H2_PU_Sess(struct worker *wrk, struct sess *sp, struct req *req)
351 150
{
352 150
        VSL(SLT_Debug, sp->vxid, "H2 Prior Knowledge Upgrade");
353 150
        req->err_code = H2_PU_MARKER;
354 150
        SES_SetTransport(wrk, sp, req, &HTTP2_transport);
355 150
}
356
357
void
358
H2_OU_Sess(struct worker *wrk, struct sess *sp, struct req *req)
359 7
{
360 7
        VSL(SLT_Debug, sp->vxid, "H2 Optimistic Upgrade");
361 7
        req->err_code = H2_OU_MARKER;
362 7
        SES_SetTransport(wrk, sp, req, &HTTP2_transport);
363 7
}
364
365
static void v_matchproto_(task_func_t)
366
h2_new_session(struct worker *wrk, void *arg)
367 157
{
368 157
        struct req *req;
369 157
        struct sess *sp;
370 157
        struct h2_sess h2s;
371 157
        struct h2_sess *h2;
372 157
        struct h2_req *r2, *r22;
373 157
        int again;
374 157
        uint8_t settings[48];
375 157
        struct h2h_decode decode;
376 157
        size_t l;
377
378 157
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
379 157
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
380 157
        sp = req->sp;
381 157
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
382
383 157
        if (wrk->wpriv->vcl)
384 26
                VCL_Rel(&wrk->wpriv->vcl);
385
386 157
        assert(req->transport == &HTTP2_transport);
387
388 157
        assert (req->err_code == H2_PU_MARKER || req->err_code == H2_OU_MARKER);
389
390 157
        h2 = h2_init_sess(sp, &h2s,
391 157
            req->err_code == H2_PU_MARKER ? req : NULL, &decode);
392 157
        h2->req0 = h2_new_req(h2, 0, NULL);
393 157
        AZ(h2->htc->priv);
394 157
        h2->htc->priv = h2;
395
396 157
        AZ(wrk->vsl);
397 157
        wrk->vsl = h2->vsl;
398
399 157
        if (req->err_code == H2_OU_MARKER && !h2_ou_session(wrk, h2, req)) {
400 4
                assert(h2->refcnt == 1);
401 4
                h2_del_req(wrk, h2->req0);
402 4
                h2_del_sess(wrk, h2, SC_RX_JUNK);
403 4
                wrk->vsl = NULL;
404 4
                return;
405 4
        }
406 153
        assert(HTC_S_COMPLETE == H2_prism_complete(h2->htc));
407 153
        HTC_RxPipeline(h2->htc, h2->htc->rxbuf_b + sizeof(H2_prism));
408 153
        HTC_RxInit(h2->htc, h2->ws);
409 153
        AN(WS_Reservation(h2->ws));
410 153
        VSLb(h2->vsl, SLT_Debug, "H2: Got pu PRISM");
411
412 153
        THR_SetRequest(h2->srq);
413 153
        AN(WS_Reservation(h2->ws));
414
415 153
        l = h2_enc_settings(&h2->local_settings, settings, sizeof (settings));
416 153
        AN(WS_Reservation(h2->ws));
417 153
        H2_Send_Get(wrk, h2, h2->req0);
418 153
        AN(WS_Reservation(h2->ws));
419 153
        H2_Send_Frame(wrk, h2,
420 153
            H2_F_SETTINGS, H2FF_NONE, l, 0, settings);
421 153
        AN(WS_Reservation(h2->ws));
422 153
        H2_Send_Rel(h2, h2->req0);
423 153
        AN(WS_Reservation(h2->ws));
424
425
        /* and off we go... */
426 153
        h2->cond = &wrk->cond;
427
428 1018
        while (h2_rxframe(wrk, h2)) {
429 865
                HTC_RxInit(h2->htc, h2->ws);
430 865
                if (WS_Overflowed(h2->ws)) {
431 0
                        H2S_Lock_VSLb(h2, SLT_SessError, "H2: Empty Rx Workspace");
432 0
                        h2->error = H2CE_INTERNAL_ERROR;
433 0
                        break;
434 0
                }
435 865
                AN(WS_Reservation(h2->ws));
436 865
        }
437
438 153
        assert(!WS_IsReserved(h2->ws));
439 153
        AN(h2->error);
440
441
        /* Delete all idle streams */
442 153
        Lck_Lock(&h2->sess->mtx);
443 153
        VSLb(h2->vsl, SLT_Debug, "H2 CLEANUP %s", h2->error->name);
444 266
        VTAILQ_FOREACH(r2, &h2->streams, list) {
445 266
                if (r2->error == 0)
446 246
                        r2->error = h2->error;
447 266
                if (r2->cond != NULL)
448 266
                        PTOK(pthread_cond_signal(r2->cond));
449 266
        }
450 153
        PTOK(pthread_cond_broadcast(h2->winupd_cond));
451 152
        Lck_Unlock(&h2->sess->mtx);
452 267
        while (1) {
453 267
                again = 0;
454 428
                VTAILQ_FOREACH_SAFE(r2, &h2->streams, list, r22) {
455 428
                        if (r2 != h2->req0) {
456 161
                                h2_kill_req(wrk, h2, r2, h2->error);
457 161
                                again++;
458 161
                        }
459 428
                }
460 267
                if (!again)
461 152
                        break;
462 115
                Lck_Lock(&h2->sess->mtx);
463 115
                VTAILQ_FOREACH(r2, &h2->streams, list)
464 162
                        VSLb(h2->vsl, SLT_Debug, "ST %u %d",
465 162
                            r2->stream, r2->state);
466 115
                (void)Lck_CondWaitTimeout(h2->cond, &h2->sess->mtx, .1);
467 115
                Lck_Unlock(&h2->sess->mtx);
468 115
        }
469 152
        h2->cond = NULL;
470 152
        assert(h2->refcnt == 1);
471 152
        h2_del_req(wrk, h2->req0);
472 152
        h2_del_sess(wrk, h2, h2->error->reason);
473 152
        wrk->vsl = NULL;
474 152
}
475
476
static int v_matchproto_(vtr_poll_f)
477
h2_poll(struct req *req)
478 479
{
479 479
        struct h2_req *r2;
480
481 479
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
482 479
        CAST_OBJ_NOTNULL(r2, req->transport_priv, H2_REQ_MAGIC);
483 479
        return (r2->error ? -1 : 1);
484 479
}
485
486
struct transport HTTP2_transport = {
487
        .name =                 "HTTP/2",
488
        .magic =                TRANSPORT_MAGIC,
489
        .deliver =              h2_deliver,
490
        .minimal_response =     h2_minimal_response,
491
        .new_session =          h2_new_session,
492
        .req_body =             h2_req_body,
493
        .req_fail =             h2_req_fail,
494
        .sess_panic =           h2_sess_panic,
495
        .poll =                 h2_poll,
496
};