GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This file contains the two central state machine for pushing HTTP1
 * sessions through their states.
 *
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>

#include "cache/cache_varnishd.h"
#include "cache/cache_objhead.h"
#include "cache/cache_transport.h"
#include "cache_http1.h"

#include "vtcp.h"

static const char H1NEWREQ[] = "HTTP1::NewReq";
static const char H1PROC[] = "HTTP1::Proc";
static const char H1CLEANUP[] = "HTTP1::Cleanup";

static void HTTP1_Session(struct worker *, struct req *);

static void
http1_setstate(const struct sess *sp, const char *s)
{
        uintptr_t p;

        p = (uintptr_t)s;
        AZ(SES_Set_proto_priv(sp, &p));
}

static const char *
http1_getstate(const struct sess *sp)
{
        uintptr_t *p;

        AZ(SES_Get_proto_priv(sp, &p));
        return ((const char *)*p);
}

/*--------------------------------------------------------------------
 * Call protocol for this request
 */

static void v_matchproto_(task_func_t)
http1_req(struct worker *wrk, void *arg)
{
        struct req *req;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);

        THR_SetRequest(req);
        assert(!WS_IsReserved(wrk->aws));
        HTTP1_Session(wrk, req);
        WS_Assert(wrk->aws);
        THR_SetRequest(NULL);
}

/*--------------------------------------------------------------------
 * Call protocol for this session (new or from waiter)
 *
 * When sessions are rescheduled from the waiter, a struct pool_task
 * is put on the reserved session workspace (for reasons of memory
 * conservation).  This reservation is released as the first thing.
 * The acceptor and any other code which schedules this function
 * must obey this calling convention with a dummy reservation.
 */

static void v_matchproto_(task_func_t)
http1_new_session(struct worker *wrk, void *arg)
{
        struct sess *sp;
        struct req *req;
        uintptr_t *u;
        ssize_t sz;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
        sp = req->sp;
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);

        HTC_RxInit(req->htc, req->ws);

        sz = sizeof u;
        if (SES_Get_proto_priv(sp, &u) &&
            !SES_Reserve_proto_priv(sp, &u, &sz)) {
                /* Out of session workspace. Free the req, close the sess,
                 * and do not set a new task func, which will exit the
                 * worker thread. */
                VSL(SLT_Error, req->sp->vxid,
                    "insufficient workspace (proto_priv)");
                WS_Release(req->ws, 0);
                Req_Release(req);
                SES_Delete(sp, SC_RX_JUNK, NAN);
                return;
        }
        assert(sz == sizeof u);
        http1_setstate(sp, H1NEWREQ);
        wrk->task->func = http1_req;
        wrk->task->priv = req;
}

static void v_matchproto_(task_func_t)
http1_unwait(struct worker *wrk, void *arg)
{
        struct sess *sp;
        struct req *req;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CAST_OBJ_NOTNULL(sp, arg, SESS_MAGIC);
        WS_Release(sp->ws, 0);
        req = Req_New(sp, NULL);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        req->htc->rfd = &sp->fd;
        HTC_RxInit(req->htc, req->ws);
        http1_setstate(sp, H1NEWREQ);
        wrk->task->func = http1_req;
        wrk->task->priv = req;
}

static void v_matchproto_(vtr_req_body_t)
http1_req_body(struct req *req)
{

        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        if (V1F_Setup_Fetch(req->vfc, req->htc) != 0)
                req->req_body_status = BS_ERROR;
}

static void
http1_sess_panic(struct vsb *vsb, const struct sess *sp)
{

        VSB_printf(vsb, "state = %s\n", http1_getstate(sp));
}

static void
http1_req_panic(struct vsb *vsb, const struct req *req)
{

        VSB_printf(vsb, "state = %s\n", http1_getstate(req->sp));
}

static void v_matchproto_(vtr_req_fail_f)
http1_req_fail(struct req *req, stream_close_t reason)
{
        assert(reason != SC_NULL);
        assert(req->sp->fd != 0);
        if (req->sp->fd > 0)
                SES_Close(req->sp, reason);
}

static int v_matchproto_(vtr_minimal_response_f)
http1_minimal_response(struct req *req, uint16_t status)
{
        ssize_t wl, l;
        char buf[80];
        const char *reason;

        assert(status >= 100);
        assert(status < 1000);

        reason = http_Status2Reason(status, NULL);

        bprintf(buf, "HTTP/1.1 %03d %s\r\n\r\n", status, reason);
        l = strlen(buf);

        VSLb(req->vsl, SLT_RespProtocol, "HTTP/1.1");
        VSLb(req->vsl, SLT_RespStatus, "%03d", status);
        VSLbs(req->vsl, SLT_RespReason, TOSTRAND(reason));

        if (status >= 400)
                req->err_code = status;
        wl = write(req->sp->fd, buf, l);

        if (wl > 0)
                req->acct.resp_hdrbytes += wl;
        if (wl != l) {
                if (wl < 0)
                        VTCP_Assert(1);
                if (req->doclose == SC_NULL)
                        req->doclose = SC_REM_CLOSE;
                return (-1);
        }
        return (0);
}

struct transport HTTP1_transport = {
        .name =                 "HTTP/1",
        .proto_ident =          "HTTP",
        .magic =                TRANSPORT_MAGIC,
        .deliver =              V1D_Deliver,
        .minimal_response =     http1_minimal_response,
        .new_session =          http1_new_session,
        .req_body =             http1_req_body,
        .req_fail =             http1_req_fail,
        .req_panic =            http1_req_panic,
        .sess_panic =           http1_sess_panic,
        .unwait =               http1_unwait,
};

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

static inline void
http1_abort(struct req *req, uint16_t status)
{
        assert(req->doclose != SC_NULL);
        assert(status >= 400);
        (void)http1_minimal_response(req, status);
}

static int
http1_dissect(struct worker *wrk, struct req *req)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);

        /* Allocate a new vxid now that we know we'll need it. */
        assert(IS_NO_VXID(req->vsl->wid));
        req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);

        VSLb(req->vsl, SLT_Begin, "req %ju rxreq", VXID(req->sp->vxid));
        VSL(SLT_Link, req->sp->vxid, "req %ju rxreq", VXID(req->vsl->wid));
        AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
        AZ(isnan(req->t_req));   /* Complete req rcvd set by http1_wait */
        req->t_prev = req->t_first;
        VSLb_ts_req(req, "Start", req->t_first);
        VSLb_ts_req(req, "Req", req->t_req);

        HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
        req->err_code = HTTP1_DissectRequest(req->htc, req->http);

        /* If we could not even parse the request, just close */
        if (req->err_code != 0) {
                VSLb(req->vsl, SLT_HttpGarbage, "%.*s",
                    (int)(req->htc->rxbuf_e - req->htc->rxbuf_b),
                    req->htc->rxbuf_b);
                wrk->stats->client_req_400++;

                (void)Req_LogStart(wrk, req);

                req->doclose = SC_RX_JUNK;
                http1_abort(req, 400);
                return (-1);
        }

        AZ(req->req_body_status);
        req->req_body_status = req->htc->body_status;
        return (0);
}

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

static void
HTTP1_Session(struct worker *wrk, struct req *req)
{
        enum htc_status_e hs;
        struct sess *sp;
        const char *st;
        int i;

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        sp = req->sp;
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);

        /*
         * Whenever we come in from the acceptor or waiter, we need to set
         * blocking mode.  It would be simpler to do this in the acceptor
         * or waiter, but we'd rather do the syscall in the worker thread.
         */
        if (http1_getstate(sp) == H1NEWREQ)
                VTCP_blocking(sp->fd);
        req->transport = XPORT_ByNumber(sp->sattr[SA_TRANSPORT]);

        while (1) {
                st = http1_getstate(sp);
                if (st == H1NEWREQ) {
                        CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
                        assert(isnan(req->t_prev));
                        assert(isnan(req->t_req));
                        AZ(req->vcl);
                        AZ(req->esi_level);
                        AN(WS_Reservation(req->htc->ws));

                        hs = HTC_RxStuff(req->htc, HTTP1_Complete,
                            &req->t_first, &req->t_req,
                            sp->t_idle + SESS_TMO(sp, timeout_linger),
                            sp->t_idle + SESS_TMO(sp, timeout_idle),
                            NAN,
                            cache_param->http_req_size);
                        assert(!WS_IsReserved(req->htc->ws));
                        if (hs < HTC_S_EMPTY) {
                                if (hs == HTC_S_OVERFLOW && cache_param->http_req_overflow_status != 0) {
                                        (void)req->transport->minimal_response(req,
                                            cache_param->http_req_overflow_status);
                                }
                                req->acct.req_hdrbytes +=
                                    req->htc->rxbuf_e - req->htc->rxbuf_b;
                                Req_AcctLogCharge(wrk->stats, req);
                                Req_Release(req);
                                SES_DeleteHS(sp, hs, NAN);
                                return;
                        }
                        if (hs == HTC_S_IDLE) {
                                wrk->stats->sess_herd++;
                                Req_Release(req);
                                SES_Wait(sp, &HTTP1_transport);
                                return;
                        }
                        if (hs != HTC_S_COMPLETE)
                                WRONG("htc_status (nonbad)");

                        if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
                                if (!FEATURE(FEATURE_HTTP2)) {
                                        SES_Close(req->sp, SC_REQ_HTTP20);
                                        assert(!WS_IsReserved(req->ws));
                                        assert(!WS_IsReserved(wrk->aws));
                                        http1_setstate(sp, H1CLEANUP);
                                        continue;
                                }
                                http1_setstate(sp, NULL);
                                H2_PU_Sess(wrk, sp, req);
                                return;
                        }

                        i = http1_dissect(wrk, req);
                        req->acct.req_hdrbytes +=
                            req->htc->rxbuf_e - req->htc->rxbuf_b;
                        if (i) {
                                assert(req->doclose != SC_NULL);
                                SES_Close(req->sp, req->doclose);
                                assert(!WS_IsReserved(req->ws));
                                assert(!WS_IsReserved(wrk->aws));
                                http1_setstate(sp, H1CLEANUP);
                                continue;
                        }
                        if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
                                if (!FEATURE(FEATURE_HTTP2)) {
                                        VSLb(req->vsl, SLT_Debug,
                                            "H2 upgrade attempt");
                                } else if (req->htc->body_status != BS_NONE) {
                                        VSLb(req->vsl, SLT_Debug,
                                            "H2 upgrade attempt has body");
                                } else {
                                        http1_setstate(sp, NULL);
                                        req->err_code = 2;
                                        H2_OU_Sess(wrk, sp, req);
                                        return;
                                }
                        }
                        assert(req->req_step == R_STP_TRANSPORT);
                        VCL_TaskEnter(req->privs);
                        VCL_TaskEnter(req->top->privs);
                        http1_setstate(sp, H1PROC);
                } else if (st == H1PROC) {
                        req->task->func = http1_req;
                        req->task->priv = req;
                        CNT_Embark(wrk, req);
                        if (CNT_Request(req) == REQ_FSM_DISEMBARK)
                                return;
                        wrk->stats->client_req++;
                        AZ(req->top->vcl0);
                        req->task->func = NULL;
                        req->task->priv = NULL;
                        assert(!WS_IsReserved(req->ws));
                        assert(!WS_IsReserved(wrk->aws));
                        http1_setstate(sp, H1CLEANUP);
                } else if (st == H1CLEANUP) {

                        assert(!WS_IsReserved(wrk->aws));
                        assert(!WS_IsReserved(req->ws));

                        if (sp->fd >= 0 && req->doclose != SC_NULL)
                                SES_Close(sp, req->doclose);

                        if (sp->fd < 0) {
                                wrk->stats->sess_closed++;
                                Req_Cleanup(sp, wrk, req);
                                Req_Release(req);
                                SES_Delete(sp, SC_NULL, NAN);
                                return;
                        }

                        Req_Cleanup(sp, wrk, req);
                        HTC_RxInit(req->htc, req->ws);
                        if (req->htc->rxbuf_e != req->htc->rxbuf_b)
                                wrk->stats->sess_readahead++;
                        if (FEATURE(FEATURE_BUSY_STATS_RATE))
                                WRK_AddStat(wrk);
                        http1_setstate(sp, H1NEWREQ);
                } else {
                        WRONG("Wrong H1 session state");
                }
        }
}

		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	458393	http1_setstate(const struct sess sp, const char s)
55		{
56		uintptr_t p;
57
58	458393	p = (uintptr_t)s;
59	458393	AZ(SES_Set_proto_priv(sp, &p));
60	458393	}
61
62		static const char *
63	548605	http1_getstate(const struct sess *sp)
64		{
65		uintptr_t *p;
66
67	548605	AZ(SES_Get_proto_priv(sp, &p));
68	548605	return ((const char )p);
69		}
70
71		/*--------------------------------------------------------------------
72		* Call protocol for this request
73		*/
74
75		static void v_matchproto_(task_func_t)
76	93275	http1_req(struct worker wrk, void arg)
77		{
78		struct req *req;
79
80	93275	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
81	93275	CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
82
83	93275	THR_SetRequest(req);
84	93275	assert(!WS_IsReserved(wrk->aws));
85	93275	HTTP1_Session(wrk, req);
86	93275	WS_Assert(wrk->aws);
87	93275	THR_SetRequest(NULL);
88	93275	}
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	85060	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	85060	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
109	85060	CAST_OBJ_NOTNULL(req, arg, REQ_MAGIC);
110	85060	sp = req->sp;
111	85060	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
112
113	85060	HTC_RxInit(req->htc, req->ws);
114
115	85060	sz = sizeof u;
116	85060	if (SES_Get_proto_priv(sp, &u) &&
117	85053	!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	85020	assert(sz == sizeof u);
129	85014	http1_setstate(sp, H1NEWREQ);
130	85014	wrk->task->func = http1_req;
131	85014	wrk->task->priv = req;
132	85054	}
133
134		static void v_matchproto_(task_func_t)
135	5600	http1_unwait(struct worker wrk, void arg)
136		{
137		struct sess *sp;
138		struct req *req;
139
140	5600	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
141	5600	CAST_OBJ_NOTNULL(sp, arg, SESS_MAGIC);
142	5600	WS_Release(sp->ws, 0);
143	5600	req = Req_New(sp, NULL);
144	5600	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
145	5600	req->htc->rfd = &sp->fd;
146	5600	HTC_RxInit(req->htc, req->ws);
147	5600	http1_setstate(sp, H1NEWREQ);
148	5600	wrk->task->func = http1_req;
149	5600	wrk->task->priv = req;
150	5600	}
151
152		static void v_matchproto_(vtr_req_body_t)
153	3480	http1_req_body(struct req *req)
154		{
155
156	3480	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
157	3480	if (V1F_Setup_Fetch(req->vfc, req->htc) != 0)
158	0	req->req_body_status = BS_ERROR;
159	3480	}
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	1960	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	1960	assert(status >= 100);
192	1960	assert(status < 1000);
193
194	1960	reason = http_Status2Reason(status, NULL);
195
196	1960	bprintf(buf, "HTTP/1.1 %03d %s\r\n\r\n", status, reason);
197	1960	l = strlen(buf);
198
199	1960	VSLb(req->vsl, SLT_RespProtocol, "HTTP/1.1");
200	1960	VSLb(req->vsl, SLT_RespStatus, "%03d", status);
201	1960	VSLbs(req->vsl, SLT_RespReason, TOSTRAND(reason));
202
203	1960	if (status >= 400)
204	1760	req->err_code = status;
205	1960	wl = write(req->sp->fd, buf, l);
206
207	1960	if (wl > 0)
208	1960	req->acct.resp_hdrbytes += wl;
209	1960	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	1960	return (0);
217	1960	}
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	128011	http1_dissect(struct worker wrk, struct req req)
246		{
247
248	128011	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
249	128011	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
250	128011	CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
251
252		/* Allocate a new vxid now that we know we'll need it. */
253	128011	assert(IS_NO_VXID(req->vsl->wid));
254	128011	req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);
255
256	128011	VSLb(req->vsl, SLT_Begin, "req %ju rxreq", VXID(req->sp->vxid));
257	128011	VSL(SLT_Link, req->sp->vxid, "req %ju rxreq", VXID(req->vsl->wid));
258	128011	AZ(isnan(req->t_first)); /* First byte timestamp set by http1_wait */
259	128011	AZ(isnan(req->t_req)); /* Complete req rcvd set by http1_wait */
260	128011	req->t_prev = req->t_first;
261	128011	VSLb_ts_req(req, "Start", req->t_first);
262	128011	VSLb_ts_req(req, "Req", req->t_req);
263
264	128011	HTTP_Setup(req->http, req->ws, req->vsl, SLT_ReqMethod);
265	128011	req->err_code = HTTP1_DissectRequest(req->htc, req->http);
266
267		/* If we could not even parse the request, just close */
268	128011	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	126691	AZ(req->req_body_status);
282	126691	req->req_body_status = req->htc->body_status;
283	126691	return (0);
284	128011	}
285
286		/*----------------------------------------------------------------------
287		*/
288
289		static void
290	93005	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	93005	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
298	93005	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
299	93005	sp = req->sp;
300	93005	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	93005	if (http1_getstate(sp) == H1NEWREQ)
308	90606	VTCP_blocking(sp->fd);
309	93005	req->transport = XPORT_ByNumber(sp->sattr[SA_TRANSPORT]);
310
311	453296	while (1) {
312	454696	st = http1_getstate(sp);
313	454696	if (st == H1NEWREQ) {
314	198290	CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
315	198290	assert(isnan(req->t_prev));
316	198290	assert(isnan(req->t_req));
317	198290	AZ(req->vcl);
318	198290	AZ(req->esi_level);
319	198290	AN(WS_Reservation(req->htc->ws));
320
321	396580	hs = HTC_RxStuff(req->htc, HTTP1_Complete,
322	198290	&req->t_first, &req->t_req,
323	198290	sp->t_idle + SESS_TMO(sp, timeout_linger),
324	198290	sp->t_idle + SESS_TMO(sp, timeout_idle),
325		NAN,
326	198290	cache_param->http_req_size);
327	198290	assert(!WS_IsReserved(req->htc->ws));
328	198290	if (hs < HTC_S_EMPTY) {
329	57236	if (hs == HTC_S_OVERFLOW && cache_param->http_req_overflow_status != 0) {
330	80	(void)req->transport->minimal_response(req,
331	40	cache_param->http_req_overflow_status);
332	40	}
333	57236	req->acct.req_hdrbytes +=
334	57236	req->htc->rxbuf_e - req->htc->rxbuf_b;
335	57236	Req_AcctLogCharge(wrk->stats, req);
336	57236	Req_Release(req);
337	57236	SES_DeleteHS(sp, hs, NAN);
338	57236	return;
339		}
340	141054	if (hs == HTC_S_IDLE) {
341	7128	wrk->stats->sess_herd++;
342	7128	Req_Release(req);
343	7128	SES_Wait(sp, &HTTP1_transport);
344	7128	return;
345		}
346	133926	if (hs != HTC_S_COMPLETE)
347	0	WRONG("htc_status (nonbad)");
348
349	133926	if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
350	5920	if (!FEATURE(FEATURE_HTTP2)) {
351	80	SES_Close(req->sp, SC_REQ_HTTP20);
352	80	assert(!WS_IsReserved(req->ws));
353	80	assert(!WS_IsReserved(wrk->aws));
354	80	http1_setstate(sp, H1CLEANUP);
355	80	continue;
356		}
357	5840	http1_setstate(sp, NULL);
358	5840	H2_PU_Sess(wrk, sp, req);
359	5840	return;
360		}
361
362	128006	i = http1_dissect(wrk, req);
363	128006	req->acct.req_hdrbytes +=
364	128006	req->htc->rxbuf_e - req->htc->rxbuf_b;
365	128006	if (i) {
366	1320	assert(req->doclose != SC_NULL);
367	1320	SES_Close(req->sp, req->doclose);
368	1320	assert(!WS_IsReserved(req->ws));
369	1320	assert(!WS_IsReserved(wrk->aws));
370	1320	http1_setstate(sp, H1CLEANUP);
371	1320	continue;
372		}
373	126686	if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
374	360	if (!FEATURE(FEATURE_HTTP2)) {
375	40	VSLb(req->vsl, SLT_Debug,
376		"H2 upgrade attempt");
377	360	} else if (req->htc->body_status != BS_NONE) {
378	40	VSLb(req->vsl, SLT_Debug,
379		"H2 upgrade attempt has body");
380	40	} else {
381	280	http1_setstate(sp, NULL);
382	280	req->err_code = 2;
383	280	H2_OU_Sess(wrk, sp, req);
384	280	return;
385		}
386	80	}
387	126406	assert(req->req_step == R_STP_TRANSPORT);
388	126406	VCL_TaskEnter(req->privs);
389	126406	VCL_TaskEnter(req->top->privs);
390	126406	http1_setstate(sp, H1PROC);
391	382812	} else if (st == H1PROC) {
392	128833	req->task->func = http1_req;
393	128833	req->task->priv = req;
394	128833	CNT_Embark(wrk, req);
395	128833	if (CNT_Request(req) == REQ_FSM_DISEMBARK)
396	2661	return;
397	126172	wrk->stats->client_req++;
398	126172	AZ(req->top->vcl0);
399	126172	req->task->func = NULL;
400	126172	req->task->priv = NULL;
401	126172	assert(!WS_IsReserved(req->ws));
402	126172	assert(!WS_IsReserved(wrk->aws));
403	126172	http1_setstate(sp, H1CLEANUP);
404	253745	} else if (st == H1CLEANUP) {
405
406	127573	assert(!WS_IsReserved(wrk->aws));
407	127573	assert(!WS_IsReserved(req->ws));
408
409	127573	if (sp->fd >= 0 && req->doclose != SC_NULL)
410	16341	SES_Close(sp, req->doclose);
411
412	127573	if (sp->fd < 0) {
413	19860	wrk->stats->sess_closed++;
414	19860	Req_Cleanup(sp, wrk, req);
415	19860	Req_Release(req);
416	19860	SES_Delete(sp, SC_NULL, NAN);
417	19860	return;
418		}
419
420	107713	Req_Cleanup(sp, wrk, req);
421	107713	HTC_RxInit(req->htc, req->ws);
422	107713	if (req->htc->rxbuf_e != req->htc->rxbuf_b)
423	544	wrk->stats->sess_readahead++;
424	107713	if (FEATURE(FEATURE_BUSY_STATS_RATE))
425	0	WRK_AddStat(wrk);
426	107713	http1_setstate(sp, H1NEWREQ);
427	107713	} else {
428	0	WRONG("Wrong H1 session state");
429		}
430		}
431	93005	}