varnish-cache/bin/varnishd/http1/cache_http1_fsm.c
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_varnishd.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 451297
http1_setstate(const struct sess *sp, const char *s)
55
{
56
        uintptr_t p;
57
58 451297
        p = (uintptr_t)s;
59 451297
        AZ(SES_Set_proto_priv(sp, &p));
60 451297
}
61
62
static const char *
63 540388
http1_getstate(const struct sess *sp)
64
{
65
        uintptr_t *p;
66
67 540388
        AZ(SES_Get_proto_priv(sp, &p));
68 540388
        return ((const char *)*p);
69
}
70
71
/*--------------------------------------------------------------------
72
 * Call protocol for this request
73
 */
74
75
static void v_matchproto_(task_func_t)
76 91693
http1_req(struct worker *wrk, void *arg)
77
{
78
        struct req *req;
79
80 91693
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
81 91693
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
82
83 91693
        THR_SetRequest(req);
84 91693
        assert(!WS_IsReserved(wrk->aws));
85 91693
        HTTP1_Session(wrk, req);
86 91693
        WS_Assert(wrk->aws);
87 91693
        THR_SetRequest(NULL);
88 91693
}
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 83465
http1_new_session(struct worker *wrk, void *arg)
102
{
103
        struct sess *sp;
104
        struct req *req;
105
        uintptr_t *u;
106
        ssize_t sz;
107
108 83465
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
109 83465
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
110 83465
        sp = req->sp;
111 83465
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
112
113 83465
        HTC_RxInit(req->htc, req->ws);
114
115 83465
        sz = sizeof u;
116 83465
        if (SES_Get_proto_priv(sp, &u) &&
117 83456
            !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 40
                VSL(SLT_Error, req->sp->vxid,
122
                    "insufficient workspace (proto_priv)");
123 40
                WS_Release(req->ws, 0);
124 40
                Req_Release(req);
125 40
                SES_Delete(sp, SC_RX_JUNK, NAN);
126 40
                return;
127
        }
128 83425
        assert(sz == sizeof u);
129 83419
        http1_setstate(sp, H1NEWREQ);
130 83419
        wrk->task->func = http1_req;
131 83419
        wrk->task->priv = req;
132 83459
}
133
134
static void v_matchproto_(task_func_t)
135 5602
http1_unwait(struct worker *wrk, void *arg)
136
{
137
        struct sess *sp;
138
        struct req *req;
139
140 5602
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
141 5602
        CAST_OBJ_NOTNULL(sp, arg, SESS_MAGIC);
142 5602
        WS_Release(sp->ws, 0);
143 5602
        req = Req_New(sp);
144 5602
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
145 5602
        req->htc->rfd = &sp->fd;
146 5602
        HTC_RxInit(req->htc, req->ws);
147 5602
        http1_setstate(sp, H1NEWREQ);
148 5602
        wrk->task->func = http1_req;
149 5602
        wrk->task->priv = req;
150 5602
}
151
152
static void v_matchproto_(vtr_req_body_t)
153 3400
http1_req_body(struct req *req)
154
{
155
156 3400
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
157 3400
        if (V1F_Setup_Fetch(req->vfc, req->htc) != 0)
158 0
                req->req_body_status = BS_ERROR;
159 3400
}
160
161
static void
162 240
http1_sess_panic(struct vsb *vsb, const struct sess *sp)
163
{
164
165 240
        VSB_printf(vsb, "state = %s\n", http1_getstate(sp));
166 240
}
167
168
static void
169 200
http1_req_panic(struct vsb *vsb, const struct req *req)
170
{
171
172 200
        VSB_printf(vsb, "state = %s\n", http1_getstate(req->sp));
173 200
}
174
175
static void v_matchproto_(vtr_req_fail_f)
176 1120
http1_req_fail(struct req *req, stream_close_t reason)
177
{
178 1120
        assert(reason != SC_NULL);
179 1120
        assert(req->sp->fd != 0);
180 1120
        if (req->sp->fd > 0)
181 1120
                SES_Close(req->sp, reason);
182 1120
}
183
184
static int v_matchproto_(vtr_minimal_response_f)
185 1920
http1_minimal_response(struct req *req, uint16_t status)
186
{
187
        ssize_t wl, l;
188
        char buf[80];
189
        const char *reason;
190
191 1920
        assert(status >= 100);
192 1920
        assert(status < 1000);
193
194 1920
        reason = http_Status2Reason(status, NULL);
195
196 1920
        bprintf(buf, "HTTP/1.1 %03d %s\r\n\r\n", status, reason);
197 1920
        l = strlen(buf);
198
199 1920
        VSLb(req->vsl, SLT_RespProtocol, "HTTP/1.1");
200 1920
        VSLb(req->vsl, SLT_RespStatus, "%03d", status);
201 1920
        VSLbs(req->vsl, SLT_RespReason, TOSTRAND(reason));
202
203 1920
        if (status >= 400)
204 1720
                req->err_code = status;
205 1920
        wl = write(req->sp->fd, buf, l);
206
207 1920
        if (wl > 0)
208 1920
                req->acct.resp_hdrbytes += wl;
209 1920
        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
        }
216 1920
        return (0);
217 1920
}
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 1320
http1_abort(struct req *req, uint16_t status)
238
{
239 1320
        assert(req->doclose != SC_NULL);
240 1320
        assert(status >= 400);
241 1320
        (void)http1_minimal_response(req, status);
242 1320
}
243
244
static int
245 126286
http1_dissect(struct worker *wrk, struct req *req)
246
{
247
248 126286
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
249 126286
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
250 126286
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
251
252
        /* Allocate a new vxid now that we know we'll need it. */
253 126286
        assert(IS_NO_VXID(req->vsl->wid));
254 126286
        req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
255
256 126286
        VSLb(req->vsl, SLT_Begin, "req %ju rxreq", VXID(req->sp->vxid));
257 126286
        VSL(SLT_Link, req->sp->vxid, "req %ju rxreq", VXID(req->vsl->wid));
258 126286
        AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
259 126286
        AZ(isnan(req->t_req));   /* Complete req rcvd set by http1_wait */
260 126286
        req->t_prev = req->t_first;
261 126286
        VSLb_ts_req(req, "Start", req->t_first);
262 126286
        VSLb_ts_req(req, "Req", req->t_req);
263
264 126286
        HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
265 126286
        req->err_code = HTTP1_DissectRequest(req->htc, req->http);
266
267
        /* If we could not even parse the request, just close */
268 126286
        if (req->err_code != 0) {
269 2640
                VSLb(req->vsl, SLT_HttpGarbage, "%.*s",
270 1320
                    (int)(req->htc->rxbuf_e - req->htc->rxbuf_b),
271 1320
                    req->htc->rxbuf_b);
272 1320
                wrk->stats->client_req_400++;
273
274 1320
                (void)Req_LogStart(wrk, req);
275
276 1320
                req->doclose = SC_RX_JUNK;
277 1320
                http1_abort(req, 400);
278 1320
                return (-1);
279
        }
280
281 124966
        AZ(req->req_body_status);
282 124966
        req->req_body_status = req->htc->body_status;
283 124966
        return (0);
284 126286
}
285
286
/*----------------------------------------------------------------------
287
 */
288
289
static void
290 91435
HTTP1_Session(struct worker *wrk, struct req *req)
291
{
292
        enum htc_status_e hs;
293
        struct sess *sp;
294
        const char *st;
295
        int i;
296
297 91435
        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
298 91435
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
299 91435
        sp = req->sp;
300 91435
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
301
302
        /*
303
         * Whenever we come in from the acceptor or waiter, we need to set
304
         * blocking mode.  It would be simpler to do this in the acceptor
305
         * or waiter, but we'd rather do the syscall in the worker thread.
306
         */
307 91435
        if (http1_getstate(sp) == H1NEWREQ)
308 89023
                VTCP_blocking(sp->fd);
309 91435
        req->transport = XPORT_ByNumber(sp->sattr[SA_TRANSPORT]);
310
311 446656
        while (1) {
312 448056
                st = http1_getstate(sp);
313 448056
                if (st == H1NEWREQ) {
314 195054
                        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
315 195054
                        assert(isnan(req->t_prev));
316 195054
                        assert(isnan(req->t_req));
317 195054
                        AZ(req->vcl);
318 195054
                        AZ(req->esi_level);
319 195054
                        AN(WS_Reservation(req->htc->ws));
320
321 390108
                        hs = HTC_RxStuff(req->htc, HTTP1_Complete,
322 195054
                            &req->t_first, &req->t_req,
323 195054
                            sp->t_idle + SESS_TMO(sp, timeout_linger),
324 195054
                            sp->t_idle + SESS_TMO(sp, timeout_idle),
325
                            NAN,
326 195054
                            cache_param->http_req_size);
327 195054
                        assert(!WS_IsReserved(req->htc->ws));
328 195054
                        if (hs < HTC_S_EMPTY) {
329 56158
                                req->acct.req_hdrbytes +=
330 56158
                                    req->htc->rxbuf_e - req->htc->rxbuf_b;
331 56158
                                Req_AcctLogCharge(wrk->stats, req);
332 56158
                                Req_Release(req);
333 56158
                                SES_DeleteHS(sp, hs, NAN);
334 56158
                                return;
335
                        }
336 138896
                        if (hs == HTC_S_IDLE) {
337 7134
                                wrk->stats->sess_herd++;
338 7134
                                Req_Release(req);
339 7134
                                SES_Wait(sp, &HTTP1_transport);
340 7134
                                return;
341
                        }
342 131762
                        if (hs != HTC_S_COMPLETE)
343 0
                                WRONG("htc_status (nonbad)");
344
345 131762
                        if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
346 5480
                                if (!FEATURE(FEATURE_HTTP2)) {
347 80
                                        SES_Close(req->sp, SC_REQ_HTTP20);
348 80
                                        assert(!WS_IsReserved(req->ws));
349 80
                                        assert(!WS_IsReserved(wrk->aws));
350 80
                                        http1_setstate(sp, H1CLEANUP);
351 80
                                        continue;
352
                                }
353 5400
                                http1_setstate(sp, NULL);
354 5400
                                H2_PU_Sess(wrk, sp, req);
355 5400
                                return;
356
                        }
357
358 126282
                        i = http1_dissect(wrk, req);
359 126282
                        req->acct.req_hdrbytes +=
360 126282
                            req->htc->rxbuf_e - req->htc->rxbuf_b;
361 126282
                        if (i) {
362 1320
                                assert(req->doclose != SC_NULL);
363 1320
                                SES_Close(req->sp, req->doclose);
364 1320
                                assert(!WS_IsReserved(req->ws));
365 1320
                                assert(!WS_IsReserved(wrk->aws));
366 1320
                                http1_setstate(sp, H1CLEANUP);
367 1320
                                continue;
368
                        }
369 124962
                        if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
370 360
                                if (!FEATURE(FEATURE_HTTP2)) {
371 40
                                        VSLb(req->vsl, SLT_Debug,
372
                                            "H2 upgrade attempt");
373 360
                                } else if (req->htc->body_status != BS_NONE) {
374 40
                                        VSLb(req->vsl, SLT_Debug,
375
                                            "H2 upgrade attempt has body");
376 40
                                } else {
377 280
                                        http1_setstate(sp, NULL);
378 280
                                        req->err_code = 2;
379 280
                                        H2_OU_Sess(wrk, sp, req);
380 280
                                        return;
381
                                }
382 80
                        }
383 124682
                        assert(req->req_step == R_STP_TRANSPORT);
384 124682
                        VCL_TaskEnter(req->privs);
385 124682
                        VCL_TaskEnter(req->top->privs);
386 124682
                        http1_setstate(sp, H1PROC);
387 377684
                } else if (st == H1PROC) {
388 127136
                        req->task->func = http1_req;
389 127136
                        req->task->priv = req;
390 127136
                        CNT_Embark(wrk, req);
391 127136
                        if (CNT_Request(req) == REQ_FSM_DISEMBARK)
392 2677
                                return;
393 124459
                        wrk->stats->client_req++;
394 124459
                        AZ(req->top->vcl0);
395 124459
                        req->task->func = NULL;
396 124459
                        req->task->priv = NULL;
397 124459
                        assert(!WS_IsReserved(req->ws));
398 124459
                        assert(!WS_IsReserved(wrk->aws));
399 124459
                        http1_setstate(sp, H1CLEANUP);
400 250325
                } else if (st == H1CLEANUP) {
401
402 125866
                        assert(!WS_IsReserved(wrk->aws));
403 125866
                        assert(!WS_IsReserved(req->ws));
404
405 125866
                        if (sp->fd >= 0 && req->doclose != SC_NULL)
406 16266
                                SES_Close(sp, req->doclose);
407
408 125866
                        if (sp->fd < 0) {
409 19786
                                wrk->stats->sess_closed++;
410 19786
                                Req_Cleanup(sp, wrk, req);
411 19786
                                Req_Release(req);
412 19786
                                SES_Delete(sp, SC_NULL, NAN);
413 19786
                                return;
414
                        }
415
416 106080
                        Req_Cleanup(sp, wrk, req);
417 106080
                        HTC_RxInit(req->htc, req->ws);
418 106080
                        if (req->htc->rxbuf_e != req->htc->rxbuf_b)
419 585
                                wrk->stats->sess_readahead++;
420 106080
                        if (FEATURE(FEATURE_BUSY_STATS_RATE))
421 0
                                WRK_AddStat(wrk);
422 106080
                        http1_setstate(sp, H1NEWREQ);
423 106080
                } else {
424 0
                        WRONG("Wrong H1 session state");
425
                }
426
        }
427 91435
}