Code Coverage: vinyl-cache/bin/vinyld/http1/cache_http1_fsm.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 *
30
 * This file contains the two central state machine for pushing HTTP1
31
 * sessions through their states.
32
 *
33
 */
34
35
#include "config.h"
36
37
#include <stdio.h>
38
#include <stdlib.h>
39
40
#include "cache/cache_int.h"
41
#include "cache/cache_objhead.h"
42
#include "cache/cache_transport.h"
43
#include "cache_http1.h"
44
45
#include "vtcp.h"
46
47
static const char H1NEWREQ[] = "HTTP1::NewReq";
48
static const char H1PROC[] = "HTTP1::Proc";
49
static const char H1CLEANUP[] = "HTTP1::Cleanup";
50
51
static void HTTP1_Session(struct worker *, struct req *);
52
53
static void
54
http1_setstate(const struct sess *sp, const char *s)
55 14712
{
56 14712
        uintptr_t p;
57
58 14712
        p = (uintptr_t)s;
59 14712
        AZ(SES_Set_proto_priv(sp, &p));
60 14712
}
61
62
static const char *
63
http1_getstate(const struct sess *sp)
64 17375
{
65 17375
        uintptr_t *p;
66
67 17375
        AZ(SES_Get_proto_priv(sp, &p));
68 17375
        return ((const char *)*p);
69 17375
}
70
71
/*--------------------------------------------------------------------
72
 * Call protocol for this request
73
 */
74
75
static void v_matchproto_(task_func_t)
76
http1_req(struct worker *wrk, void *arg)
77 2699
{
78 2699
        struct req *req;
79
80 2699
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
81 2699
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
82
83 2699
        THR_SetRequest(req);
84 2699
        assert(!WS_IsReserved(wrk->aws));
85 2699
        HTTP1_Session(wrk, req);
86 2699
        WS_Assert(wrk->aws);
87 2699
        THR_SetRequest(NULL);
88 2699
}
89
90
/*--------------------------------------------------------------------
91
 * Call protocol for this session (new or from waiter)
92
 *
93
 * When sessions are rescheduled from the waiter, a struct pool_task
94
 * is put on the reserved session workspace (for reasons of memory
95
 * conservation).  This reservation is released as the first thing.
96
 * The acceptor and any other code which schedules this function
97
 * must obey this calling convention with a dummy reservation.
98
 */
99
100
static void v_matchproto_(task_func_t)
101
http1_new_session(struct worker *wrk, void *arg)
102 2356
{
103 2356
        struct sess *sp;
104 2356
        struct req *req;
105 2356
        uintptr_t *u;
106 2356
        ssize_t sz;
107
108 2356
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
109 2356
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
110 2356
        sp = req->sp;
111 2356
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
112
113 2356
        HTC_RxInit(req->htc, req->ws);
114
115 2356
        sz = sizeof u;
116 2356
        if (SES_Get_proto_priv(sp, &u) &&
117 2365
            !SES_Reserve_proto_priv(sp, &u, &sz)) {
118
                /* Out of session workspace. Free the req, close the sess,
119
                 * and do not set a new task func, which will exit the
120
                 * worker thread. */
121 1
                VSL(SLT_Error, req->sp->vxid,
122 1
                    "insufficient workspace (proto_priv)");
123 1
                WS_Release(req->ws, 0);
124 1
                Req_Release(req);
125 1
                SES_Delete(sp, SC_RX_JUNK, NAN);
126 1
                return;
127 1
        }
128 2355
        assert(sz == sizeof u);
129 2355
        http1_setstate(sp, H1NEWREQ);
130 2355
        wrk->task->func = http1_req;
131 2355
        wrk->task->priv = req;
132 2355
}
133
134
static void v_matchproto_(task_func_t)
135
http1_unwait(struct worker *wrk, void *arg)
136 217
{
137 217
        struct sess *sp;
138 217
        struct req *req;
139
140 217
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
141 217
        CAST_OBJ_NOTNULL(sp, arg, SESS_MAGIC);
142 217
        WS_Release(sp->ws, 0);
143 217
        req = Req_New(sp, NULL);
144 217
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
145 217
        req->htc->rfd = &sp->fd;
146 217
        HTC_RxInit(req->htc, req->ws);
147 217
        http1_setstate(sp, H1NEWREQ);
148 217
        wrk->task->func = http1_req;
149 217
        wrk->task->priv = req;
150 217
}
151
152
static void v_matchproto_(vtr_req_body_t)
153
http1_req_body(struct req *req)
154 238
{
155
156 238
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
157 238
        if (V1F_Setup_Fetch(req->vfc, req->htc) != 0)
158 0
                req->req_body_status = BS_ERROR;
159 238
}
160
161
static void
162
http1_sess_panic(struct vsb *vsb, const struct sess *sp)
163 6
{
164
165 6
        VSB_printf(vsb, "state = %s\n", http1_getstate(sp));
166 6
}
167
168
static void
169
http1_req_panic(struct vsb *vsb, const struct req *req)
170 5
{
171
172 5
        VSB_printf(vsb, "state = %s\n", http1_getstate(req->sp));
173 5
}
174
175
static void v_matchproto_(vtr_req_fail_f)
176
http1_req_fail(struct req *req, stream_close_t reason)
177 33
{
178 33
        assert(reason != SC_NULL);
179 33
        assert(req->sp->fd != 0);
180 33
        if (req->sp->fd > 0)
181 33
                SES_Close(req->sp, reason);
182 33
}
183
184
static int v_matchproto_(vtr_minimal_response_f)
185
http1_minimal_response(struct req *req, uint16_t status)
186 131
{
187 131
        ssize_t wl, l;
188 131
        char buf[80];
189 131
        const char *reason;
190
191 131
        assert(status >= 100);
192 131
        assert(status < 1000);
193
194 131
        reason = http_Status2Reason(status, NULL);
195
196 131
        bprintf(buf, "HTTP/1.1 %03d %s\r\n\r\n", status, reason);
197 131
        l = vstrlen(buf);
198
199 131
        VSLb(req->vsl, SLT_RespProtocol, "HTTP/1.1");
200 131
        VSLb(req->vsl, SLT_RespStatus, "%03d", status);
201 131
        VSLbs(req->vsl, SLT_RespReason, TOSTRAND(reason));
202
203 131
        if (status >= 400)
204 126
                req->err_code = status;
205 131
        wl = write(req->sp->fd, buf, l);
206
207 131
        if (wl > 0)
208 131
                req->acct.resp_hdrbytes += wl;
209 131
        if (wl != l) {
210 0
                if (wl < 0)
211 0
                        VTCP_Assert(1);
212 0
                if (req->doclose == SC_NULL)
213 0
                        req->doclose = SC_REM_CLOSE;
214 0
                return (-1);
215 0
        }
216 131
        return (0);
217 131
}
218
219
struct transport HTTP1_transport = {
220
        .name =                 "HTTP/1",
221
        .proto_ident =          "HTTP",
222
        .magic =                TRANSPORT_MAGIC,
223
        .deliver =              V1D_Deliver,
224
        .minimal_response =     http1_minimal_response,
225
        .new_session =          http1_new_session,
226
        .req_body =             http1_req_body,
227
        .req_fail =             http1_req_fail,
228
        .req_panic =            http1_req_panic,
229
        .sess_panic =           http1_sess_panic,
230
        .unwait =               http1_unwait,
231
};
232
233
/*----------------------------------------------------------------------
234
 */
235
236
static inline void
237
http1_abort(struct req *req, uint16_t status)
238 46
{
239 46
        assert(req->doclose != SC_NULL);
240 46
        assert(status >= 400);
241 46
        (void)http1_minimal_response(req, status);
242 46
}
243
244
static int
245
http1_dissect(struct worker *wrk, struct req *req)
246 4199
{
247
248 4199
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
249 4199
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
250 4199
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
251
252
        /* Allocate a new vxid now that we know we'll need it. */
253 4199
        assert(IS_NO_VXID(req->vsl->wid));
254 4199
        req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
255
256 4199
        VSLb(req->vsl, SLT_Begin, "req %ju rxreq", VXID(req->sp->vxid));
257 4199
        VSL(SLT_Link, req->sp->vxid, "req %ju rxreq", VXID(req->vsl->wid));
258 4199
        AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
259 4199
        AZ(isnan(req->t_req));   /* Complete req rcvd set by http1_wait */
260 4199
        req->t_prev = req->t_first;
261 4199
        VSLb_ts_req(req, "Start", req->t_first);
262 4199
        VSLb_ts_req(req, "Req", req->t_req);
263
264 4199
        HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
265 4199
        req->err_code = HTTP1_DissectRequest(req->htc, req->http);
266
267
        /* If we could not even parse the request, just close */
268 4199
        if (req->err_code != 0) {
269 46
                wrk->stats->client_req_400++;
270
271 46
                (void)Req_LogStart(wrk, req);
272
273 46
                req->doclose = SC_RX_JUNK;
274 46
                http1_abort(req, 400);
275 46
                return (-1);
276 46
        }
277
278 4153
        AZ(req->req_body_status);
279 4153
        req->req_body_status = req->htc->body_status;
280 4153
        return (0);
281 4153
}
282
283
/*----------------------------------------------------------------------
284
 */
285
286
static void
287
HTTP1_Session(struct worker *wrk, struct req *req)
288 2699
{
289 2699
        enum htc_status_e hs;
290 2699
        struct sess *sp;
291 2699
        const char *st;
292 2699
        int i;
293
294 2699
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
295 2699
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
296 2699
        sp = req->sp;
297 2699
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
298
299
        /*
300
         * Whenever we come in from the acceptor or waiter, we need to set
301
         * blocking mode.  It would be simpler to do this in the acceptor
302
         * or waiter, but we'd rather do the syscall in the worker thread.
303
         */
304 2699
        if (http1_getstate(sp) == H1NEWREQ)
305 2581
                VTCP_blocking(sp->fd);
306 2699
        req->transport = XPORT_ByNumber(sp->sattr[SA_TRANSPORT]);
307
308 14677
        while (1) {
309 14668
                st = http1_getstate(sp);
310 14668
                if (st == H1NEWREQ) {
311 6220
                        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
312 6220
                        assert(isnan(req->t_prev));
313 6220
                        assert(isnan(req->t_req));
314 6220
                        AZ(req->vcl);
315 6220
                        AZ(req->esi_level);
316 6220
                        AN(WS_Reservation(req->htc->ws));
317
318 6220
                        hs = HTC_RxStuff(req->htc, HTTP1_Complete,
319 6220
                            &req->t_first, &req->t_req,
320 6220
                            sp->t_idle + SESS_TMO(sp, timeout_linger),
321 6220
                            sp->t_idle + SESS_TMO(sp, timeout_idle),
322 6220
                            NAN,
323 6220
                            cache_param->http_req_size);
324 6220
                        assert(!WS_IsReserved(req->htc->ws));
325 6220
                        if (hs < HTC_S_EMPTY) {
326 1588
                                if (hs == HTC_S_OVERFLOW && cache_param->http_req_overflow_status != 0) {
327 1
                                        (void)req->transport->minimal_response(req,
328 1
                                            cache_param->http_req_overflow_status);
329 1
                                }
330 1588
                                req->acct.req_hdrbytes +=
331 1588
                                    req->htc->rxbuf_e - req->htc->rxbuf_b;
332 1588
                                Req_AcctLogCharge(wrk->stats, req);
333 1588
                                Req_Release(req);
334 1588
                                SES_DeleteHS(sp, hs, NAN);
335 1588
                                return;
336 1588
                        }
337 4632
                        if (hs == HTC_S_EMPTY) {
338 280
                                wrk->stats->sess_herd++;
339 280
                                Req_Release(req);
340 280
                                SES_Wait(sp, &HTTP1_transport);
341 280
                                return;
342 280
                        }
343 4352
                        if (hs != HTC_S_COMPLETE)
344 0
                                WRONG("htc_status (nonbad)");
345
346 4352
                        if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
347 152
                                if (!FEATURE(FEATURE_HTTP2)) {
348 2
                                        SES_Close(req->sp, SC_REQ_HTTP20);
349 2
                                        assert(!WS_IsReserved(req->ws));
350 2
                                        assert(!WS_IsReserved(wrk->aws));
351 2
                                        http1_setstate(sp, H1CLEANUP);
352 2
                                        continue;
353 2
                                }
354 150
                                http1_setstate(sp, NULL);
355 150
                                H2_PU_Sess(wrk, sp, req);
356 150
                                return;
357 152
                        }
358
359 4200
                        i = http1_dissect(wrk, req);
360 4200
                        req->acct.req_hdrbytes +=
361 4200
                            req->htc->rxbuf_e - req->htc->rxbuf_b;
362 4200
                        req->htc->rxbuf_b = NULL;
363 4200
                        req->htc->rxbuf_e = NULL;
364 4200
                        if (i) {
365 46
                                assert(req->doclose != SC_NULL);
366 46
                                SES_Close(req->sp, req->doclose);
367 46
                                assert(!WS_IsReserved(req->ws));
368 46
                                assert(!WS_IsReserved(wrk->aws));
369 46
                                http1_setstate(sp, H1CLEANUP);
370 46
                                continue;
371 46
                        }
372 4154
                        if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
373 9
                                if (!FEATURE(FEATURE_HTTP2)) {
374 1
                                        VSLb(req->vsl, SLT_Debug,
375 1
                                            "H2 upgrade attempt");
376 8
                                } else if (req->htc->body_status != BS_NONE) {
377 1
                                        VSLb(req->vsl, SLT_Debug,
378 1
                                            "H2 upgrade attempt has body");
379 7
                                } else {
380 7
                                        http1_setstate(sp, NULL);
381 7
                                        req->err_code = 2;
382 7
                                        H2_OU_Sess(wrk, sp, req);
383 7
                                        return;
384 7
                                }
385 9
                        }
386 4147
                        assert(req->req_step == R_STP_TRANSPORT);
387 4147
                        VCL_TaskEnter(req->privs);
388 4147
                        VCL_TaskEnter(req->top->privs);
389 4147
                        http1_setstate(sp, H1PROC);
390 8448
                } else if (st == H1PROC) {
391 4263
                        req->task->func = http1_req;
392 4263
                        req->task->priv = req;
393 4263
                        CNT_Embark(wrk, req);
394 4263
                        if (CNT_Request(req) == REQ_FSM_DISEMBARK)
395 118
                                return;
396 4145
                        wrk->stats->client_req++;
397 4145
                        AZ(req->top->vcl0);
398 4145
                        req->task->func = NULL;
399 4145
                        req->task->priv = NULL;
400 4145
                        assert(!WS_IsReserved(req->ws));
401 4145
                        assert(!WS_IsReserved(wrk->aws));
402 4145
                        http1_setstate(sp, H1CLEANUP);
403 4188
                } else if (st == H1CLEANUP) {
404
405 4188
                        assert(!WS_IsReserved(wrk->aws));
406 4188
                        assert(!WS_IsReserved(req->ws));
407
408 4188
                        if (sp->fd >= 0 && req->doclose != SC_NULL)
409 444
                                SES_Close(sp, req->doclose);
410
411 4188
                        if (sp->fd < 0) {
412 550
                                wrk->stats->sess_closed++;
413 550
                                Req_Cleanup(sp, wrk, req);
414 550
                                Req_Release(req);
415 550
                                SES_Delete(sp, SC_NULL, NAN);
416 550
                                return;
417 550
                        }
418
419 3638
                        Req_Cleanup(sp, wrk, req);
420 3638
                        HTC_RxInit(req->htc, req->ws);
421 3638
                        if (req->htc->rxbuf_e != req->htc->rxbuf_b)
422 14
                                wrk->stats->sess_readahead++;
423 3638
                        if (FEATURE(FEATURE_BUSY_STATS_RATE))
424 0
                                WRK_AddStat(wrk);
425 3638
                        http1_setstate(sp, H1NEWREQ);
426 18446744073709551613
                } else {
427 18446744073709551613
                        WRONG("Wrong H1 session state");
428 18446744073709551613
                }
429 14668
        }
430 2699
}