blob: f20b46b71eddbc85d0d24c78f83bbe5ce078ee6b [file] [log] [blame]
Christopher Faulet99eff652019-08-11 23:11:30 +02001/*
2 * FastCGI mux-demux for connections
3 *
4 * Copyright (C) 2019 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreaub2551052020-06-09 09:07:15 +020013#include <import/ist.h>
Willy Tarreau63617db2021-10-06 18:23:40 +020014#include <import/eb32tree.h>
15#include <import/ebmbtree.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020016
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020017#include <haproxy/api.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020018#include <haproxy/cfgparse.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020019#include <haproxy/connection.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020020#include <haproxy/errors.h>
Willy Tarreauc6599682020-06-04 21:33:21 +020021#include <haproxy/fcgi-app.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020022#include <haproxy/fcgi.h>
Willy Tarreau5413a872020-06-02 19:33:08 +020023#include <haproxy/h1.h>
Willy Tarreauc6fe8842020-06-04 09:00:02 +020024#include <haproxy/h1_htx.h>
Willy Tarreau87735332020-06-04 09:08:41 +020025#include <haproxy/http_htx.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020026#include <haproxy/htx.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020027#include <haproxy/list.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020028#include <haproxy/log.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020029#include <haproxy/net_helper.h>
Willy Tarreauc5396bd2021-05-08 20:28:54 +020030#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020031#include <haproxy/regex.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020032#include <haproxy/session-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020033#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020034#include <haproxy/stream_interface.h>
Willy Tarreauc6d61d72020-06-04 19:02:42 +020035#include <haproxy/trace.h>
Christopher Faulet5cd0e522021-06-11 13:34:42 +020036#include <haproxy/version.h>
Christopher Faulet99eff652019-08-11 23:11:30 +020037
Willy Tarreaub2551052020-06-09 09:07:15 +020038
Christopher Faulet99eff652019-08-11 23:11:30 +020039/* FCGI Connection flags (32 bits) */
40#define FCGI_CF_NONE 0x00000000
41
42/* Flags indicating why writing to the mux is blockes */
43#define FCGI_CF_MUX_MALLOC 0x00000001 /* mux is blocked on lack connection's mux buffer */
44#define FCGI_CF_MUX_MFULL 0x00000002 /* mux is blocked on connection's mux buffer full */
45#define FCGI_CF_MUX_BLOCK_ANY 0x00000003 /* mux is blocked on connection's mux buffer full */
46
47/* Flags indicating why writing to the demux is blocked.
48 * The first two ones directly affect the ability for the mux to receive data
49 * from the connection. The other ones affect the mux's ability to demux
50 * received data.
51 */
52#define FCGI_CF_DEM_DALLOC 0x00000004 /* demux blocked on lack of connection's demux buffer */
53#define FCGI_CF_DEM_DFULL 0x00000008 /* demux blocked on connection's demux buffer full */
54#define FCGI_CF_DEM_MROOM 0x00000010 /* demux blocked on lack of room in mux buffer */
55#define FCGI_CF_DEM_SALLOC 0x00000020 /* demux blocked on lack of stream's rx buffer */
56#define FCGI_CF_DEM_SFULL 0x00000040 /* demux blocked on stream request buffer full */
57#define FCGI_CF_DEM_TOOMANY 0x00000080 /* demux blocked waiting for some conn_streams to leave */
58#define FCGI_CF_DEM_BLOCK_ANY 0x000000F0 /* aggregate of the demux flags above except DALLOC/DFULL */
59
60/* Other flags */
61#define FCGI_CF_MPXS_CONNS 0x00000100 /* connection multiplexing is supported */
62#define FCGI_CF_ABRTS_SENT 0x00000200 /* a record ABORT was successfully sent to all active streams */
63#define FCGI_CF_ABRTS_FAILED 0x00000400 /* failed to abort processing of all streams */
64#define FCGI_CF_WAIT_FOR_HS 0x00000800 /* We did check that at least a stream was waiting for handshake */
Willy Tarreau714f3452021-05-09 06:47:26 +020065#define FCGI_CF_KEEP_CONN 0x00001000 /* HAProxy is responsible to close the connection */
Christopher Faulet99eff652019-08-11 23:11:30 +020066#define FCGI_CF_GET_VALUES 0x00002000 /* retrieve settings */
67
68/* FCGI connection state (fcgi_conn->state) */
69enum fcgi_conn_st {
70 FCGI_CS_INIT = 0, /* init done, waiting for sending GET_VALUES record */
71 FCGI_CS_SETTINGS, /* GET_VALUES sent, waiting for the GET_VALUES_RESULT record */
72 FCGI_CS_RECORD_H, /* GET_VALUES_RESULT received, waiting for a record header */
73 FCGI_CS_RECORD_D, /* Record header OK, waiting for a record data */
74 FCGI_CS_RECORD_P, /* Record processed, remains the padding */
75 FCGI_CS_CLOSED, /* abort requests if necessary and close the connection ASAP */
76 FCGI_CS_ENTRIES
77} __attribute__((packed));
78
79/* 32 buffers: one for the ring's root, rest for the mbuf itself */
80#define FCGI_C_MBUF_CNT 32
81
Christopher Fauletd1ac2b92020-12-02 19:12:22 +010082/* Size for a record header (also size of empty record) */
83#define FCGI_RECORD_HEADER_SZ 8
84
Christopher Faulet99eff652019-08-11 23:11:30 +020085/* FCGI connection descriptor */
86struct fcgi_conn {
87 struct connection *conn;
88
89 enum fcgi_conn_st state; /* FCGI connection state */
90 int16_t max_id; /* highest ID known on this connection, <0 before mgmt records */
91 uint32_t streams_limit; /* maximum number of concurrent streams the peer supports */
92 uint32_t flags; /* Connection flags: FCGI_CF_* */
93
94 int16_t dsi; /* dmux stream ID (<0 = idle ) */
95 uint16_t drl; /* demux record length (if dsi >= 0) */
96 uint8_t drt; /* demux record type (if dsi >= 0) */
97 uint8_t drp; /* demux record padding (if dsi >= 0) */
98
99 struct buffer dbuf; /* demux buffer */
100 struct buffer mbuf[FCGI_C_MBUF_CNT]; /* mux buffers (ring) */
101
102 int timeout; /* idle timeout duration in ticks */
103 int shut_timeout; /* idle timeout duration in ticks after shutdown */
104 unsigned int nb_streams; /* number of streams in the tree */
105 unsigned int nb_cs; /* number of attached conn_streams */
106 unsigned int nb_reserved; /* number of reserved streams */
107 unsigned int stream_cnt; /* total number of streams seen */
108
109 struct proxy *proxy; /* the proxy this connection was created for */
110 struct fcgi_app *app; /* FCGI application used by this mux */
111 struct task *task; /* timeout management task */
112 struct eb_root streams_by_id; /* all active streams by their ID */
113
114 struct list send_list; /* list of blocked streams requesting to send */
Christopher Faulet99eff652019-08-11 23:11:30 +0200115
116 struct buffer_wait buf_wait; /* Wait list for buffer allocation */
117 struct wait_event wait_event; /* To be used if we're waiting for I/Os */
118};
119
120
121/* FCGI stream state, in fcgi_strm->state */
122enum fcgi_strm_st {
123 FCGI_SS_IDLE = 0,
124 FCGI_SS_OPEN,
125 FCGI_SS_HREM, // half-closed(remote)
126 FCGI_SS_HLOC, // half-closed(local)
127 FCGI_SS_ERROR,
128 FCGI_SS_CLOSED,
129 FCGI_SS_ENTRIES
130} __attribute__((packed));
131
132
133/* FCGI stream flags (32 bits) */
134#define FCGI_SF_NONE 0x00000000
135#define FCGI_SF_ES_RCVD 0x00000001 /* end-of-stream received (empty STDOUT or EDN_REQUEST record) */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +0100136#define FCGI_SF_ES_SENT 0x00000002 /* end-of-stream sent (empty STDIN record) */
137#define FCGI_SF_EP_SENT 0x00000004 /* end-of-param sent (empty PARAMS record) */
138#define FCGI_SF_ABRT_SENT 0x00000008 /* abort sent (ABORT_REQUEST record) */
Christopher Faulet99eff652019-08-11 23:11:30 +0200139
140/* Stream flags indicating the reason the stream is blocked */
141#define FCGI_SF_BLK_MBUSY 0x00000010 /* blocked waiting for mux access (transient) */
142#define FCGI_SF_BLK_MROOM 0x00000020 /* blocked waiting for room in the mux */
143#define FCGI_SF_BLK_ANY 0x00000030 /* any of the reasons above */
144
145#define FCGI_SF_BEGIN_SENT 0x00000100 /* a BEGIN_REQUEST record was sent for this stream */
146#define FCGI_SF_OUTGOING_DATA 0x00000200 /* set whenever we've seen outgoing data */
Willy Tarreauf11be0e2020-01-16 16:59:45 +0100147#define FCGI_SF_NOTIFIED 0x00000400 /* a paused stream was notified to try to send again */
Christopher Faulet99eff652019-08-11 23:11:30 +0200148
149#define FCGI_SF_WANT_SHUTR 0x00001000 /* a stream couldn't shutr() (mux full/busy) */
150#define FCGI_SF_WANT_SHUTW 0x00002000 /* a stream couldn't shutw() (mux full/busy) */
151#define FCGI_SF_KILL_CONN 0x00004000 /* kill the whole connection with this stream */
152
Christopher Faulet99eff652019-08-11 23:11:30 +0200153
154/* FCGI stream descriptor */
155struct fcgi_strm {
156 struct conn_stream *cs;
157 struct session *sess;
158 struct fcgi_conn *fconn;
159
160 int32_t id; /* stream ID */
161
162 uint32_t flags; /* Connection flags: FCGI_SF_* */
163 enum fcgi_strm_st state; /* FCGI stream state */
164 int proto_status; /* FCGI_PS_* */
165
166 struct h1m h1m; /* response parser state for H1 */
167
168 struct buffer rxbuf; /* receive buffer, always valid (buf_empty or real buffer) */
169
170 struct eb32_node by_id; /* place in fcgi_conn's streams_by_id */
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100171 struct wait_event *subs; /* Address of the wait_event the conn_stream associated is waiting on */
Christopher Faulet99eff652019-08-11 23:11:30 +0200172 struct list send_list; /* To be used when adding in fcgi_conn->send_list */
Willy Tarreau7aad7032020-01-16 17:20:57 +0100173 struct tasklet *shut_tl; /* deferred shutdown tasklet, to retry to close after we failed to by lack of space */
Christopher Faulet99eff652019-08-11 23:11:30 +0200174};
175
176/* Flags representing all default FCGI parameters */
177#define FCGI_SP_CGI_GATEWAY 0x00000001
178#define FCGI_SP_DOC_ROOT 0x00000002
179#define FCGI_SP_SCRIPT_NAME 0x00000004
180#define FCGI_SP_PATH_INFO 0x00000008
181#define FCGI_SP_REQ_URI 0x00000010
182#define FCGI_SP_REQ_METH 0x00000020
183#define FCGI_SP_REQ_QS 0x00000040
184#define FCGI_SP_SRV_PORT 0x00000080
185#define FCGI_SP_SRV_PROTO 0x00000100
186#define FCGI_SP_SRV_NAME 0x00000200
187#define FCGI_SP_REM_ADDR 0x00000400
188#define FCGI_SP_REM_PORT 0x00000800
189#define FCGI_SP_SCRIPT_FILE 0x00001000
190#define FCGI_SP_PATH_TRANS 0x00002000
191#define FCGI_SP_CONT_LEN 0x00004000
192#define FCGI_SP_HTTPS 0x00008000
Christopher Faulet5cd0e522021-06-11 13:34:42 +0200193#define FCGI_SP_SRV_SOFT 0x00010000
194#define FCGI_SP_MASK 0x0001FFFF
Christopher Faulet99eff652019-08-11 23:11:30 +0200195#define FCGI_SP_URI_MASK (FCGI_SP_SCRIPT_NAME|FCGI_SP_PATH_INFO|FCGI_SP_REQ_QS)
196
197/* FCGI parameters used when PARAMS record is sent */
198struct fcgi_strm_params {
199 uint32_t mask;
200 struct ist docroot;
201 struct ist scriptname;
202 struct ist pathinfo;
203 struct ist meth;
204 struct ist uri;
205 struct ist vsn;
206 struct ist qs;
207 struct ist srv_name;
208 struct ist srv_port;
209 struct ist rem_addr;
210 struct ist rem_port;
211 struct ist cont_len;
Christopher Faulet5cd0e522021-06-11 13:34:42 +0200212 struct ist srv_soft;
Christopher Faulet99eff652019-08-11 23:11:30 +0200213 int https;
214 struct buffer *p;
215};
216
217/* Maximum amount of data we're OK with re-aligning for buffer optimizations */
218#define MAX_DATA_REALIGN 1024
219
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200220/* trace source and events */
221static void fcgi_trace(enum trace_level level, uint64_t mask,
222 const struct trace_source *src,
223 const struct ist where, const struct ist func,
224 const void *a1, const void *a2, const void *a3, const void *a4);
225
226/* The event representation is split like this :
227 * fconn - internal FCGI connection
228 * fstrm - internal FCGI stream
229 * strm - application layer
230 * rx - data receipt
231 * tx - data transmission
232 * rsp - response parsing
233 */
234static const struct trace_event fcgi_trace_events[] = {
235#define FCGI_EV_FCONN_NEW (1ULL << 0)
236 { .mask = FCGI_EV_FCONN_NEW, .name = "fconn_new", .desc = "new FCGI connection" },
237#define FCGI_EV_FCONN_RECV (1ULL << 1)
238 { .mask = FCGI_EV_FCONN_RECV, .name = "fconn_recv", .desc = "Rx on FCGI connection" },
239#define FCGI_EV_FCONN_SEND (1ULL << 2)
240 { .mask = FCGI_EV_FCONN_SEND, .name = "fconn_send", .desc = "Tx on FCGI connection" },
241#define FCGI_EV_FCONN_BLK (1ULL << 3)
242 { .mask = FCGI_EV_FCONN_BLK, .name = "fconn_blk", .desc = "FCGI connection blocked" },
243#define FCGI_EV_FCONN_WAKE (1ULL << 4)
244 { .mask = FCGI_EV_FCONN_WAKE, .name = "fconn_wake", .desc = "FCGI connection woken up" },
245#define FCGI_EV_FCONN_END (1ULL << 5)
246 { .mask = FCGI_EV_FCONN_END, .name = "fconn_end", .desc = "FCGI connection terminated" },
247#define FCGI_EV_FCONN_ERR (1ULL << 6)
248 { .mask = FCGI_EV_FCONN_ERR, .name = "fconn_err", .desc = "error on FCGI connection" },
249
250#define FCGI_EV_RX_FHDR (1ULL << 7)
251 { .mask = FCGI_EV_RX_FHDR, .name = "rx_fhdr", .desc = "FCGI record header received" },
252#define FCGI_EV_RX_RECORD (1ULL << 8)
253 { .mask = FCGI_EV_RX_RECORD, .name = "rx_record", .desc = "receipt of any FCGI record" },
254#define FCGI_EV_RX_EOI (1ULL << 9)
255 { .mask = FCGI_EV_RX_EOI, .name = "rx_eoi", .desc = "receipt of end of FCGI input" },
256#define FCGI_EV_RX_GETVAL (1ULL << 10)
257 { .mask = FCGI_EV_RX_GETVAL, .name = "rx_get_values", .desc = "receipt of FCGI GET_VALUES_RESULT record" },
258#define FCGI_EV_RX_STDOUT (1ULL << 11)
259 { .mask = FCGI_EV_RX_STDOUT, .name = "rx_stdout", .desc = "receipt of FCGI STDOUT record" },
260#define FCGI_EV_RX_STDERR (1ULL << 12)
261 { .mask = FCGI_EV_RX_STDERR, .name = "rx_stderr", .desc = "receipt of FCGI STDERR record" },
262#define FCGI_EV_RX_ENDREQ (1ULL << 13)
263 { .mask = FCGI_EV_RX_ENDREQ, .name = "rx_end_req", .desc = "receipt of FCGI END_REQUEST record" },
264
265#define FCGI_EV_TX_RECORD (1ULL << 14)
266 { .mask = FCGI_EV_TX_RECORD, .name = "tx_record", .desc = "transmission of any FCGI record" },
267#define FCGI_EV_TX_EOI (1ULL << 15)
268 { .mask = FCGI_EV_TX_EOI, .name = "tx_eoi", .desc = "transmission of FCGI end of input" },
269#define FCGI_EV_TX_BEGREQ (1ULL << 16)
270 { .mask = FCGI_EV_TX_BEGREQ, .name = "tx_begin_request", .desc = "transmission of FCGI BEGIN_REQUEST record" },
271#define FCGI_EV_TX_GETVAL (1ULL << 17)
272 { .mask = FCGI_EV_TX_GETVAL, .name = "tx_get_values", .desc = "transmission of FCGI GET_VALUES record" },
273#define FCGI_EV_TX_PARAMS (1ULL << 18)
274 { .mask = FCGI_EV_TX_PARAMS, .name = "tx_params", .desc = "transmission of FCGI PARAMS record" },
275#define FCGI_EV_TX_STDIN (1ULL << 19)
276 { .mask = FCGI_EV_TX_STDIN, .name = "tx_stding", .desc = "transmission of FCGI STDIN record" },
277#define FCGI_EV_TX_ABORT (1ULL << 20)
278 { .mask = FCGI_EV_TX_ABORT, .name = "tx_abort", .desc = "transmission of FCGI ABORT record" },
279
280#define FCGI_EV_RSP_DATA (1ULL << 21)
281 { .mask = FCGI_EV_RSP_DATA, .name = "rsp_data", .desc = "parse any data of H1 response" },
282#define FCGI_EV_RSP_EOM (1ULL << 22)
283 { .mask = FCGI_EV_RSP_EOM, .name = "rsp_eom", .desc = "reach the end of message of H1 response" },
284#define FCGI_EV_RSP_HDRS (1ULL << 23)
285 { .mask = FCGI_EV_RSP_HDRS, .name = "rsp_headers", .desc = "parse headers of H1 response" },
286#define FCGI_EV_RSP_BODY (1ULL << 24)
287 { .mask = FCGI_EV_RSP_BODY, .name = "rsp_body", .desc = "parse body part of H1 response" },
288#define FCGI_EV_RSP_TLRS (1ULL << 25)
289 { .mask = FCGI_EV_RSP_TLRS, .name = "rsp_trailerus", .desc = "parse trailers of H1 response" },
290
291#define FCGI_EV_FSTRM_NEW (1ULL << 26)
292 { .mask = FCGI_EV_FSTRM_NEW, .name = "fstrm_new", .desc = "new FCGI stream" },
293#define FCGI_EV_FSTRM_BLK (1ULL << 27)
294 { .mask = FCGI_EV_FSTRM_BLK, .name = "fstrm_blk", .desc = "FCGI stream blocked" },
295#define FCGI_EV_FSTRM_END (1ULL << 28)
296 { .mask = FCGI_EV_FSTRM_END, .name = "fstrm_end", .desc = "FCGI stream terminated" },
297#define FCGI_EV_FSTRM_ERR (1ULL << 29)
298 { .mask = FCGI_EV_FSTRM_ERR, .name = "fstrm_err", .desc = "error on FCGI stream" },
299
300#define FCGI_EV_STRM_NEW (1ULL << 30)
301 { .mask = FCGI_EV_STRM_NEW, .name = "strm_new", .desc = "app-layer stream creation" },
302#define FCGI_EV_STRM_RECV (1ULL << 31)
303 { .mask = FCGI_EV_STRM_RECV, .name = "strm_recv", .desc = "receiving data for stream" },
304#define FCGI_EV_STRM_SEND (1ULL << 32)
305 { .mask = FCGI_EV_STRM_SEND, .name = "strm_send", .desc = "sending data for stream" },
306#define FCGI_EV_STRM_FULL (1ULL << 33)
307 { .mask = FCGI_EV_STRM_FULL, .name = "strm_full", .desc = "stream buffer full" },
308#define FCGI_EV_STRM_WAKE (1ULL << 34)
309 { .mask = FCGI_EV_STRM_WAKE, .name = "strm_wake", .desc = "stream woken up" },
310#define FCGI_EV_STRM_SHUT (1ULL << 35)
311 { .mask = FCGI_EV_STRM_SHUT, .name = "strm_shut", .desc = "stream shutdown" },
312#define FCGI_EV_STRM_END (1ULL << 36)
313 { .mask = FCGI_EV_STRM_END, .name = "strm_end", .desc = "detaching app-layer stream" },
314#define FCGI_EV_STRM_ERR (1ULL << 37)
315 { .mask = FCGI_EV_STRM_ERR, .name = "strm_err", .desc = "stream error" },
316
317 { }
318};
319
320static const struct name_desc fcgi_trace_lockon_args[4] = {
321 /* arg1 */ { /* already used by the connection */ },
322 /* arg2 */ { .name="fstrm", .desc="FCGI stream" },
323 /* arg3 */ { },
324 /* arg4 */ { }
325};
326
327
328static const struct name_desc fcgi_trace_decoding[] = {
329#define FCGI_VERB_CLEAN 1
330 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
331#define FCGI_VERB_MINIMAL 2
332 { .name="minimal", .desc="report only fconn/fstrm state and flags, no real decoding" },
333#define FCGI_VERB_SIMPLE 3
334 { .name="simple", .desc="add request/response status line or htx info when available" },
335#define FCGI_VERB_ADVANCED 4
336 { .name="advanced", .desc="add header fields or record decoding when available" },
337#define FCGI_VERB_COMPLETE 5
338 { .name="complete", .desc="add full data dump when available" },
339 { /* end */ }
340};
341
Willy Tarreau6eb3d372021-04-10 19:29:26 +0200342static struct trace_source trace_fcgi __read_mostly = {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200343 .name = IST("fcgi"),
344 .desc = "FastCGI multiplexer",
345 .arg_def = TRC_ARG1_CONN, // TRACE()'s first argument is always a connection
346 .default_cb = fcgi_trace,
347 .known_events = fcgi_trace_events,
348 .lockon_args = fcgi_trace_lockon_args,
349 .decoding = fcgi_trace_decoding,
350 .report_events = ~0, // report everything by default
351};
352
353#define TRACE_SOURCE &trace_fcgi
354INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
355
Christopher Faulet99eff652019-08-11 23:11:30 +0200356/* FCGI connection and stream pools */
357DECLARE_STATIC_POOL(pool_head_fcgi_conn, "fcgi_conn", sizeof(struct fcgi_conn));
358DECLARE_STATIC_POOL(pool_head_fcgi_strm, "fcgi_strm", sizeof(struct fcgi_strm));
359
Willy Tarreau144f84a2021-03-02 16:09:26 +0100360struct task *fcgi_timeout_task(struct task *t, void *context, unsigned int state);
Christopher Faulet99eff652019-08-11 23:11:30 +0200361static int fcgi_process(struct fcgi_conn *fconn);
Willy Tarreau691d5032021-01-20 14:55:01 +0100362/* fcgi_io_cb is exported to see it resolved in "show fd" */
Willy Tarreau144f84a2021-03-02 16:09:26 +0100363struct task *fcgi_io_cb(struct task *t, void *ctx, unsigned int state);
Christopher Faulet99eff652019-08-11 23:11:30 +0200364static inline struct fcgi_strm *fcgi_conn_st_by_id(struct fcgi_conn *fconn, int id);
Willy Tarreau144f84a2021-03-02 16:09:26 +0100365struct task *fcgi_deferred_shut(struct task *t, void *ctx, unsigned int state);
Christopher Faulet99eff652019-08-11 23:11:30 +0200366static struct fcgi_strm *fcgi_conn_stream_new(struct fcgi_conn *fconn, struct conn_stream *cs, struct session *sess);
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200367static void fcgi_strm_notify_recv(struct fcgi_strm *fstrm);
368static void fcgi_strm_notify_send(struct fcgi_strm *fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +0200369static void fcgi_strm_alert(struct fcgi_strm *fstrm);
370static int fcgi_strm_send_abort(struct fcgi_conn *fconn, struct fcgi_strm *fstrm);
371
372/* a dmumy management stream */
373static const struct fcgi_strm *fcgi_mgmt_stream = &(const struct fcgi_strm){
374 .cs = NULL,
375 .fconn = NULL,
376 .state = FCGI_SS_CLOSED,
377 .flags = FCGI_SF_NONE,
378 .id = 0,
379};
380
381/* and a dummy idle stream for use with any unknown stream */
382static const struct fcgi_strm *fcgi_unknown_stream = &(const struct fcgi_strm){
383 .cs = NULL,
384 .fconn = NULL,
385 .state = FCGI_SS_IDLE,
386 .flags = FCGI_SF_NONE,
387 .id = 0,
388};
389
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200390/* returns a fconn state as an abbreviated 3-letter string, or "???" if unknown */
391static inline const char *fconn_st_to_str(enum fcgi_conn_st st)
392{
393 switch (st) {
394 case FCGI_CS_INIT : return "INI";
395 case FCGI_CS_SETTINGS : return "STG";
396 case FCGI_CS_RECORD_H : return "RDH";
397 case FCGI_CS_RECORD_D : return "RDD";
398 case FCGI_CS_RECORD_P : return "RDP";
399 case FCGI_CS_CLOSED : return "CLO";
400 default : return "???";
401 }
402}
403
404/* returns a fstrm state as an abbreviated 3-letter string, or "???" if unknown */
405static inline const char *fstrm_st_to_str(enum fcgi_strm_st st)
406{
407 switch (st) {
408 case FCGI_SS_IDLE : return "IDL";
409 case FCGI_SS_OPEN : return "OPN";
410 case FCGI_SS_HREM : return "RCL";
411 case FCGI_SS_HLOC : return "HCL";
412 case FCGI_SS_ERROR : return "ERR";
413 case FCGI_SS_CLOSED : return "CLO";
414 default : return "???";
415 }
416}
417
418
419/* the FCGI traces always expect that arg1, if non-null, is of type connection
420 * (from which we can derive fconn), that arg2, if non-null, is of type fstrm,
421 * and that arg3, if non-null, is a htx for rx/tx headers.
422 */
423static void fcgi_trace(enum trace_level level, uint64_t mask, const struct trace_source *src,
424 const struct ist where, const struct ist func,
425 const void *a1, const void *a2, const void *a3, const void *a4)
426{
427 const struct connection *conn = a1;
428 const struct fcgi_conn *fconn = conn ? conn->ctx : NULL;
429 const struct fcgi_strm *fstrm = a2;
430 const struct htx *htx = a3;
431 const size_t *val = a4;
432
433 if (!fconn)
434 fconn = (fstrm ? fstrm->fconn : NULL);
435
436 if (!fconn || src->verbosity < FCGI_VERB_CLEAN)
437 return;
438
439 /* Display the response state if fstrm is defined */
440 if (fstrm)
441 chunk_appendf(&trace_buf, " [rsp:%s]", h1m_state_str(fstrm->h1m.state));
442
443 if (src->verbosity == FCGI_VERB_CLEAN)
444 return;
445
446 /* Display the value to the 4th argument (level > STATE) */
447 if (src->level > TRACE_LEVEL_STATE && val)
Willy Tarreaue18f53e2019-11-27 15:41:31 +0100448 chunk_appendf(&trace_buf, " - VAL=%lu", (long)*val);
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200449
450 /* Display status-line if possible (verbosity > MINIMAL) */
451 if (src->verbosity > FCGI_VERB_MINIMAL && htx && htx_nbblks(htx)) {
452 const struct htx_blk *blk = htx_get_head_blk(htx);
453 const struct htx_sl *sl = htx_get_blk_ptr(htx, blk);
454 enum htx_blk_type type = htx_get_blk_type(blk);
455
456 if (type == HTX_BLK_REQ_SL || type == HTX_BLK_RES_SL)
457 chunk_appendf(&trace_buf, " - \"%.*s %.*s %.*s\"",
458 HTX_SL_P1_LEN(sl), HTX_SL_P1_PTR(sl),
459 HTX_SL_P2_LEN(sl), HTX_SL_P2_PTR(sl),
460 HTX_SL_P3_LEN(sl), HTX_SL_P3_PTR(sl));
461 }
462
463 /* Display fconn info and, if defined, fstrm info */
464 chunk_appendf(&trace_buf, " - fconn=%p(%s,0x%08x)", fconn, fconn_st_to_str(fconn->state), fconn->flags);
465 if (fstrm)
466 chunk_appendf(&trace_buf, " fstrm=%p(%d,%s,0x%08x)", fstrm, fstrm->id, fstrm_st_to_str(fstrm->state), fstrm->flags);
467
468 if (!fstrm || fstrm->id <= 0)
469 chunk_appendf(&trace_buf, " dsi=%d", fconn->dsi);
470 if (fconn->dsi >= 0 && (mask & FCGI_EV_RX_FHDR))
471 chunk_appendf(&trace_buf, " drt=%s", fcgi_rt_str(fconn->drt));
472
473 if (src->verbosity == FCGI_VERB_MINIMAL)
474 return;
475
476 /* Display mbuf and dbuf info (level > USER & verbosity > SIMPLE) */
477 if (src->level > TRACE_LEVEL_USER) {
478 if (src->verbosity == FCGI_VERB_COMPLETE ||
479 (src->verbosity == FCGI_VERB_ADVANCED && (mask & (FCGI_EV_FCONN_RECV|FCGI_EV_RX_RECORD))))
480 chunk_appendf(&trace_buf, " dbuf=%u@%p+%u/%u",
481 (unsigned int)b_data(&fconn->dbuf), b_orig(&fconn->dbuf),
482 (unsigned int)b_head_ofs(&fconn->dbuf), (unsigned int)b_size(&fconn->dbuf));
483 if (src->verbosity == FCGI_VERB_COMPLETE ||
484 (src->verbosity == FCGI_VERB_ADVANCED && (mask & (FCGI_EV_FCONN_SEND|FCGI_EV_TX_RECORD)))) {
485 struct buffer *hmbuf = br_head((struct buffer *)fconn->mbuf);
486 struct buffer *tmbuf = br_tail((struct buffer *)fconn->mbuf);
487
488 chunk_appendf(&trace_buf, " .mbuf=[%u..%u|%u],h=[%u@%p+%u/%u],t=[%u@%p+%u/%u]",
489 br_head_idx(fconn->mbuf), br_tail_idx(fconn->mbuf), br_size(fconn->mbuf),
490 (unsigned int)b_data(hmbuf), b_orig(hmbuf),
491 (unsigned int)b_head_ofs(hmbuf), (unsigned int)b_size(hmbuf),
492 (unsigned int)b_data(tmbuf), b_orig(tmbuf),
493 (unsigned int)b_head_ofs(tmbuf), (unsigned int)b_size(tmbuf));
494 }
495
496 if (fstrm && (src->verbosity == FCGI_VERB_COMPLETE ||
497 (src->verbosity == FCGI_VERB_ADVANCED && (mask & (FCGI_EV_STRM_RECV|FCGI_EV_RSP_DATA)))))
498 chunk_appendf(&trace_buf, " rxbuf=%u@%p+%u/%u",
499 (unsigned int)b_data(&fstrm->rxbuf), b_orig(&fstrm->rxbuf),
500 (unsigned int)b_head_ofs(&fstrm->rxbuf), (unsigned int)b_size(&fstrm->rxbuf));
501 }
502
503 /* Display htx info if defined (level > USER) */
504 if (src->level > TRACE_LEVEL_USER && htx) {
505 int full = 0;
506
507 /* Full htx info (level > STATE && verbosity > SIMPLE) */
508 if (src->level > TRACE_LEVEL_STATE) {
509 if (src->verbosity == FCGI_VERB_COMPLETE)
510 full = 1;
511 else if (src->verbosity == FCGI_VERB_ADVANCED && (mask & (FCGI_EV_RSP_HDRS|FCGI_EV_TX_PARAMS)))
512 full = 1;
513 }
514
515 chunk_memcat(&trace_buf, "\n\t", 2);
516 htx_dump(&trace_buf, htx, full);
517 }
518}
Christopher Faulet99eff652019-08-11 23:11:30 +0200519
520/*****************************************************/
521/* functions below are for dynamic buffer management */
522/*****************************************************/
523
524/* Indicates whether or not the we may call the fcgi_recv() function to attempt
525 * to receive data into the buffer and/or demux pending data. The condition is
526 * a bit complex due to some API limits for now. The rules are the following :
527 * - if an error or a shutdown was detected on the connection and the buffer
528 * is empty, we must not attempt to receive
529 * - if the demux buf failed to be allocated, we must not try to receive and
530 * we know there is nothing pending
531 * - if no flag indicates a blocking condition, we may attempt to receive,
532 * regardless of whether the demux buffer is full or not, so that only
533 * de demux part decides whether or not to block. This is needed because
534 * the connection API indeed prevents us from re-enabling receipt that is
535 * already enabled in a polled state, so we must always immediately stop
536 * as soon as the demux can't proceed so as never to hit an end of read
537 * with data pending in the buffers.
538 * - otherwise must may not attempt
539 */
540static inline int fcgi_recv_allowed(const struct fcgi_conn *fconn)
541{
542 if (b_data(&fconn->dbuf) == 0 &&
543 (fconn->state == FCGI_CS_CLOSED ||
544 fconn->conn->flags & CO_FL_ERROR ||
545 conn_xprt_read0_pending(fconn->conn)))
546 return 0;
547
548 if (!(fconn->flags & FCGI_CF_DEM_DALLOC) &&
549 !(fconn->flags & FCGI_CF_DEM_BLOCK_ANY))
550 return 1;
551
552 return 0;
553}
554
555/* Restarts reading on the connection if it was not enabled */
556static inline void fcgi_conn_restart_reading(const struct fcgi_conn *fconn, int consider_buffer)
557{
558 if (!fcgi_recv_allowed(fconn))
559 return;
560 if ((!consider_buffer || !b_data(&fconn->dbuf)) &&
561 (fconn->wait_event.events & SUB_RETRY_RECV))
562 return;
563 tasklet_wakeup(fconn->wait_event.tasklet);
564}
565
566
567/* Tries to grab a buffer and to re-enable processing on mux <target>. The
568 * fcgi_conn flags are used to figure what buffer was requested. It returns 1 if
569 * the allocation succeeds, in which case the connection is woken up, or 0 if
570 * it's impossible to wake up and we prefer to be woken up later.
571 */
572static int fcgi_buf_available(void *target)
573{
574 struct fcgi_conn *fconn = target;
575 struct fcgi_strm *fstrm;
576
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100577 if ((fconn->flags & FCGI_CF_DEM_DALLOC) && b_alloc(&fconn->dbuf)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200578 TRACE_STATE("unblocking fconn, dbuf allocated", FCGI_EV_FCONN_RECV|FCGI_EV_FCONN_BLK|FCGI_EV_FCONN_WAKE, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +0200579 fconn->flags &= ~FCGI_CF_DEM_DALLOC;
580 fcgi_conn_restart_reading(fconn, 1);
581 return 1;
582 }
583
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100584 if ((fconn->flags & FCGI_CF_MUX_MALLOC) && b_alloc(br_tail(fconn->mbuf))) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200585 TRACE_STATE("unblocking fconn, mbuf allocated", FCGI_EV_FCONN_SEND|FCGI_EV_FCONN_BLK|FCGI_EV_FCONN_WAKE, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +0200586 fconn->flags &= ~FCGI_CF_MUX_MALLOC;
Christopher Faulet99eff652019-08-11 23:11:30 +0200587 if (fconn->flags & FCGI_CF_DEM_MROOM) {
588 fconn->flags &= ~FCGI_CF_DEM_MROOM;
589 fcgi_conn_restart_reading(fconn, 1);
590 }
591 return 1;
592 }
593
594 if ((fconn->flags & FCGI_CF_DEM_SALLOC) &&
595 (fstrm = fcgi_conn_st_by_id(fconn, fconn->dsi)) && fstrm->cs &&
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100596 b_alloc(&fstrm->rxbuf)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200597 TRACE_STATE("unblocking fstrm, rxbuf allocated", FCGI_EV_STRM_RECV|FCGI_EV_FSTRM_BLK|FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +0200598 fconn->flags &= ~FCGI_CF_DEM_SALLOC;
599 fcgi_conn_restart_reading(fconn, 1);
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200600 fcgi_strm_notify_recv(fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +0200601 return 1;
602 }
603
604 return 0;
605}
606
607static inline struct buffer *fcgi_get_buf(struct fcgi_conn *fconn, struct buffer *bptr)
608{
609 struct buffer *buf = NULL;
610
Willy Tarreau2b718102021-04-21 07:32:39 +0200611 if (likely(!LIST_INLIST(&fconn->buf_wait.list)) &&
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100612 unlikely((buf = b_alloc(bptr)) == NULL)) {
Christopher Faulet99eff652019-08-11 23:11:30 +0200613 fconn->buf_wait.target = fconn;
614 fconn->buf_wait.wakeup_cb = fcgi_buf_available;
Willy Tarreaub4e34762021-09-30 19:02:18 +0200615 LIST_APPEND(&th_ctx->buffer_wq, &fconn->buf_wait.list);
Christopher Faulet99eff652019-08-11 23:11:30 +0200616 }
617 return buf;
618}
619
620static inline void fcgi_release_buf(struct fcgi_conn *fconn, struct buffer *bptr)
621{
622 if (bptr->size) {
623 b_free(bptr);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100624 offer_buffers(NULL, 1);
Christopher Faulet99eff652019-08-11 23:11:30 +0200625 }
626}
627
628static inline void fcgi_release_mbuf(struct fcgi_conn *fconn)
629{
630 struct buffer *buf;
631 unsigned int count = 0;
632
633 while (b_size(buf = br_head_pick(fconn->mbuf))) {
634 b_free(buf);
635 count++;
636 }
637 if (count)
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100638 offer_buffers(NULL, count);
Christopher Faulet99eff652019-08-11 23:11:30 +0200639}
640
641/* Returns the number of allocatable outgoing streams for the connection taking
642 * the number reserved streams into account.
643 */
644static inline int fcgi_streams_left(const struct fcgi_conn *fconn)
645{
646 int ret;
647
648 ret = (unsigned int)(0x7FFF - fconn->max_id) - fconn->nb_reserved - 1;
649 if (ret < 0)
650 ret = 0;
651 return ret;
652}
653
654/* Returns the number of streams in use on a connection to figure if it's
655 * idle or not. We check nb_cs and not nb_streams as the caller will want
656 * to know if it was the last one after a detach().
657 */
658static int fcgi_used_streams(struct connection *conn)
659{
660 struct fcgi_conn *fconn = conn->ctx;
661
662 return fconn->nb_cs;
663}
664
665/* Returns the number of concurrent streams available on the connection */
666static int fcgi_avail_streams(struct connection *conn)
667{
668 struct server *srv = objt_server(conn->target);
669 struct fcgi_conn *fconn = conn->ctx;
670 int ret1, ret2;
671
672 /* Don't open new stream if the connection is closed */
673 if (fconn->state == FCGI_CS_CLOSED)
674 return 0;
675
676 /* May be negative if this setting has changed */
677 ret1 = (fconn->streams_limit - fconn->nb_streams);
678
679 /* we must also consider the limit imposed by stream IDs */
680 ret2 = fcgi_streams_left(fconn);
681 ret1 = MIN(ret1, ret2);
682 if (ret1 > 0 && srv && srv->max_reuse >= 0) {
683 ret2 = ((fconn->stream_cnt <= srv->max_reuse) ? srv->max_reuse - fconn->stream_cnt + 1: 0);
684 ret1 = MIN(ret1, ret2);
685 }
686 return ret1;
687}
688
689/*****************************************************************/
690/* functions below are dedicated to the mux setup and management */
691/*****************************************************************/
692
693/* Initializes the mux once it's attached. Only outgoing connections are
694 * supported. So the context is already initialized before installing the
695 * mux. <input> is always used as Input buffer and may contain data. It is the
696 * caller responsibility to not reuse it anymore. Returns < 0 on error.
697 */
698static int fcgi_init(struct connection *conn, struct proxy *px, struct session *sess,
699 struct buffer *input)
700{
701 struct fcgi_conn *fconn;
702 struct fcgi_strm *fstrm;
703 struct fcgi_app *app = get_px_fcgi_app(px);
704 struct task *t = NULL;
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200705 void *conn_ctx = conn->ctx;
706
707 TRACE_ENTER(FCGI_EV_FSTRM_NEW);
Christopher Faulet99eff652019-08-11 23:11:30 +0200708
Christopher Faulet73518be2021-01-27 12:06:54 +0100709 if (!app) {
710 TRACE_ERROR("No FCGI app found, don't create fconn", FCGI_EV_FCONN_NEW|FCGI_EV_FCONN_END|FCGI_EV_FCONN_ERR);
Christopher Faulet99eff652019-08-11 23:11:30 +0200711 goto fail_conn;
Christopher Faulet73518be2021-01-27 12:06:54 +0100712 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200713
714 fconn = pool_alloc(pool_head_fcgi_conn);
Christopher Faulet73518be2021-01-27 12:06:54 +0100715 if (!fconn) {
716 TRACE_ERROR("fconn allocation failure", FCGI_EV_FCONN_NEW|FCGI_EV_FCONN_END|FCGI_EV_FCONN_ERR);
Christopher Faulet99eff652019-08-11 23:11:30 +0200717 goto fail_conn;
Christopher Faulet73518be2021-01-27 12:06:54 +0100718 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200719
720 fconn->shut_timeout = fconn->timeout = px->timeout.server;
721 if (tick_isset(px->timeout.serverfin))
722 fconn->shut_timeout = px->timeout.serverfin;
723
724 fconn->flags = FCGI_CF_NONE;
725
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500726 /* Retrieve useful info from the FCGI app */
Christopher Faulet99eff652019-08-11 23:11:30 +0200727 if (app->flags & FCGI_APP_FL_KEEP_CONN)
728 fconn->flags |= FCGI_CF_KEEP_CONN;
729 if (app->flags & FCGI_APP_FL_GET_VALUES)
730 fconn->flags |= FCGI_CF_GET_VALUES;
731 if (app->flags & FCGI_APP_FL_MPXS_CONNS)
732 fconn->flags |= FCGI_CF_MPXS_CONNS;
733
734 fconn->proxy = px;
735 fconn->app = app;
736 fconn->task = NULL;
737 if (tick_isset(fconn->timeout)) {
Willy Tarreaubeeabf52021-10-01 18:23:30 +0200738 t = task_new_here();
Christopher Faulet73518be2021-01-27 12:06:54 +0100739 if (!t) {
740 TRACE_ERROR("fconn task allocation failure", FCGI_EV_FCONN_NEW|FCGI_EV_FCONN_END|FCGI_EV_FCONN_ERR);
Christopher Faulet99eff652019-08-11 23:11:30 +0200741 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +0100742 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200743
744 fconn->task = t;
745 t->process = fcgi_timeout_task;
746 t->context = fconn;
747 t->expire = tick_add(now_ms, fconn->timeout);
748 }
749
750 fconn->wait_event.tasklet = tasklet_new();
751 if (!fconn->wait_event.tasklet)
752 goto fail;
753 fconn->wait_event.tasklet->process = fcgi_io_cb;
754 fconn->wait_event.tasklet->context = fconn;
755 fconn->wait_event.events = 0;
756
757 /* Initialise the context. */
758 fconn->state = FCGI_CS_INIT;
759 fconn->conn = conn;
760 fconn->streams_limit = app->maxreqs;
761 fconn->max_id = -1;
762 fconn->nb_streams = 0;
763 fconn->nb_cs = 0;
764 fconn->nb_reserved = 0;
765 fconn->stream_cnt = 0;
766
767 fconn->dbuf = *input;
768 fconn->dsi = -1;
769
770 br_init(fconn->mbuf, sizeof(fconn->mbuf) / sizeof(fconn->mbuf[0]));
771 fconn->streams_by_id = EB_ROOT;
772 LIST_INIT(&fconn->send_list);
Willy Tarreau90f366b2021-02-20 11:49:49 +0100773 LIST_INIT(&fconn->buf_wait.list);
Christopher Faulet99eff652019-08-11 23:11:30 +0200774
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200775 conn->ctx = fconn;
776
Christopher Faulet99eff652019-08-11 23:11:30 +0200777 if (t)
778 task_queue(t);
779
780 /* FIXME: this is temporary, for outgoing connections we need to
781 * immediately allocate a stream until the code is modified so that the
782 * caller calls ->attach(). For now the outgoing cs is stored as
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200783 * conn->ctx by the caller and saved in conn_ctx.
Christopher Faulet99eff652019-08-11 23:11:30 +0200784 */
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200785 fstrm = fcgi_conn_stream_new(fconn, conn_ctx, sess);
Christopher Faulet99eff652019-08-11 23:11:30 +0200786 if (!fstrm)
787 goto fail;
788
Christopher Faulet99eff652019-08-11 23:11:30 +0200789
790 /* Repare to read something */
791 fcgi_conn_restart_reading(fconn, 1);
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200792 TRACE_LEAVE(FCGI_EV_FCONN_NEW, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +0200793 return 0;
794
795 fail:
796 task_destroy(t);
797 if (fconn->wait_event.tasklet)
798 tasklet_free(fconn->wait_event.tasklet);
799 pool_free(pool_head_fcgi_conn, fconn);
800 fail_conn:
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200801 conn->ctx = conn_ctx; // restore saved ctx
802 TRACE_DEVEL("leaving in error", FCGI_EV_FCONN_NEW|FCGI_EV_FCONN_END|FCGI_EV_FCONN_ERR);
Christopher Faulet99eff652019-08-11 23:11:30 +0200803 return -1;
804}
805
806/* Returns the next allocatable outgoing stream ID for the FCGI connection, or
807 * -1 if no more is allocatable.
808 */
809static inline int32_t fcgi_conn_get_next_sid(const struct fcgi_conn *fconn)
810{
811 int32_t id = (fconn->max_id + 1) | 1;
812
813 if ((id & 0x80000000U))
814 id = -1;
815 return id;
816}
817
818/* Returns the stream associated with id <id> or NULL if not found */
819static inline struct fcgi_strm *fcgi_conn_st_by_id(struct fcgi_conn *fconn, int id)
820{
821 struct eb32_node *node;
822
823 if (id == 0)
824 return (struct fcgi_strm *)fcgi_mgmt_stream;
825
826 if (id > fconn->max_id)
827 return (struct fcgi_strm *)fcgi_unknown_stream;
828
829 node = eb32_lookup(&fconn->streams_by_id, id);
830 if (!node)
831 return (struct fcgi_strm *)fcgi_unknown_stream;
832 return container_of(node, struct fcgi_strm, by_id);
833}
834
835
836/* Release function. This one should be called to free all resources allocated
837 * to the mux.
838 */
839static void fcgi_release(struct fcgi_conn *fconn)
840{
William Dauchy477757c2020-08-07 22:19:23 +0200841 struct connection *conn = NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +0200842
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200843 TRACE_POINT(FCGI_EV_FCONN_END);
844
Christopher Faulet99eff652019-08-11 23:11:30 +0200845 if (fconn) {
846 /* The connection must be attached to this mux to be released */
847 if (fconn->conn && fconn->conn->ctx == fconn)
848 conn = fconn->conn;
849
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200850 TRACE_DEVEL("freeing fconn", FCGI_EV_FCONN_END, conn);
851
Willy Tarreau2b718102021-04-21 07:32:39 +0200852 if (LIST_INLIST(&fconn->buf_wait.list))
Willy Tarreau90f366b2021-02-20 11:49:49 +0100853 LIST_DEL_INIT(&fconn->buf_wait.list);
Christopher Faulet99eff652019-08-11 23:11:30 +0200854
855 fcgi_release_buf(fconn, &fconn->dbuf);
856 fcgi_release_mbuf(fconn);
857
858 if (fconn->task) {
859 fconn->task->context = NULL;
860 task_wakeup(fconn->task, TASK_WOKEN_OTHER);
861 fconn->task = NULL;
862 }
863 if (fconn->wait_event.tasklet)
864 tasklet_free(fconn->wait_event.tasklet);
Christopher Fauleta99db932019-09-18 11:11:46 +0200865 if (conn && fconn->wait_event.events != 0)
Christopher Faulet99eff652019-08-11 23:11:30 +0200866 conn->xprt->unsubscribe(conn, conn->xprt_ctx, fconn->wait_event.events,
867 &fconn->wait_event);
Christopher Faulet8694f252020-05-02 09:17:52 +0200868
869 pool_free(pool_head_fcgi_conn, fconn);
Christopher Faulet99eff652019-08-11 23:11:30 +0200870 }
871
872 if (conn) {
873 conn->mux = NULL;
874 conn->ctx = NULL;
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200875 TRACE_DEVEL("freeing conn", FCGI_EV_FCONN_END, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +0200876
877 conn_stop_tracking(conn);
878 conn_full_close(conn);
879 if (conn->destroy_cb)
880 conn->destroy_cb(conn);
881 conn_free(conn);
882 }
883}
884
Christopher Faulet6670e3e2020-10-08 15:26:33 +0200885/* Detect a pending read0 for a FCGI connection. It happens if a read0 is
886 * pending on the connection AND if there is no more data in the demux
887 * buffer. The function returns 1 to report a read0 or 0 otherwise.
888 */
889static int fcgi_conn_read0_pending(struct fcgi_conn *fconn)
890{
891 if (conn_xprt_read0_pending(fconn->conn) && !b_data(&fconn->dbuf))
892 return 1;
893 return 0;
894}
895
Christopher Faulet99eff652019-08-11 23:11:30 +0200896
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500897/* Returns true if the FCGI connection must be release */
Christopher Faulet99eff652019-08-11 23:11:30 +0200898static inline int fcgi_conn_is_dead(struct fcgi_conn *fconn)
899{
900 if (eb_is_empty(&fconn->streams_by_id) && /* don't close if streams exist */
901 (!(fconn->flags & FCGI_CF_KEEP_CONN) || /* don't keep the connection alive */
902 (fconn->conn->flags & CO_FL_ERROR) || /* errors close immediately */
903 (fconn->state == FCGI_CS_CLOSED && !fconn->task) ||/* a timeout stroke earlier */
904 (!(fconn->conn->owner)) || /* Nobody's left to take care of the connection, drop it now */
905 (!br_data(fconn->mbuf) && /* mux buffer empty, also process clean events below */
906 conn_xprt_read0_pending(fconn->conn))))
907 return 1;
908 return 0;
909}
910
911
912/********************************************************/
913/* functions below are for the FCGI protocol processing */
914/********************************************************/
915
Christopher Faulet99eff652019-08-11 23:11:30 +0200916/* Marks an error on the stream. */
917static inline void fcgi_strm_error(struct fcgi_strm *fstrm)
918{
919 if (fstrm->id && fstrm->state != FCGI_SS_ERROR) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200920 TRACE_POINT(FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
921 if (fstrm->state < FCGI_SS_ERROR) {
Christopher Faulet99eff652019-08-11 23:11:30 +0200922 fstrm->state = FCGI_SS_ERROR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200923 TRACE_STATE("switching to ERROR", FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
924 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200925 if (fstrm->cs)
926 cs_set_error(fstrm->cs);
927 }
928}
929
930/* Attempts to notify the data layer of recv availability */
931static void fcgi_strm_notify_recv(struct fcgi_strm *fstrm)
932{
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100933 if (fstrm->subs && (fstrm->subs->events & SUB_RETRY_RECV)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200934 TRACE_POINT(FCGI_EV_STRM_WAKE, fstrm->fconn->conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100935 tasklet_wakeup(fstrm->subs->tasklet);
936 fstrm->subs->events &= ~SUB_RETRY_RECV;
937 if (!fstrm->subs->events)
938 fstrm->subs = NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +0200939 }
940}
941
942/* Attempts to notify the data layer of send availability */
943static void fcgi_strm_notify_send(struct fcgi_strm *fstrm)
944{
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100945 if (fstrm->subs && (fstrm->subs->events & SUB_RETRY_SEND)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200946 TRACE_POINT(FCGI_EV_STRM_WAKE, fstrm->fconn->conn, fstrm);
Willy Tarreauf11be0e2020-01-16 16:59:45 +0100947 fstrm->flags |= FCGI_SF_NOTIFIED;
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100948 tasklet_wakeup(fstrm->subs->tasklet);
949 fstrm->subs->events &= ~SUB_RETRY_SEND;
950 if (!fstrm->subs->events)
951 fstrm->subs = NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +0200952 }
Willy Tarreau7aad7032020-01-16 17:20:57 +0100953 else if (fstrm->flags & (FCGI_SF_WANT_SHUTR | FCGI_SF_WANT_SHUTW)) {
954 TRACE_POINT(FCGI_EV_STRM_WAKE, fstrm->fconn->conn, fstrm);
955 tasklet_wakeup(fstrm->shut_tl);
956 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200957}
958
959/* Alerts the data layer, trying to wake it up by all means, following
960 * this sequence :
961 * - if the fcgi stream' data layer is subscribed to recv, then it's woken up
962 * for recv
963 * - if its subscribed to send, then it's woken up for send
964 * - if it was subscribed to neither, its ->wake() callback is called
965 * It is safe to call this function with a closed stream which doesn't have a
966 * conn_stream anymore.
967 */
968static void fcgi_strm_alert(struct fcgi_strm *fstrm)
969{
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200970 TRACE_POINT(FCGI_EV_STRM_WAKE, fstrm->fconn->conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +0100971 if (fstrm->subs ||
Willy Tarreau7aad7032020-01-16 17:20:57 +0100972 (fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW))) {
Christopher Faulet99eff652019-08-11 23:11:30 +0200973 fcgi_strm_notify_recv(fstrm);
974 fcgi_strm_notify_send(fstrm);
975 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200976 else if (fstrm->cs && fstrm->cs->data_cb->wake != NULL) {
977 TRACE_POINT(FCGI_EV_STRM_WAKE, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +0200978 fstrm->cs->data_cb->wake(fstrm->cs);
Christopher Faulet5c0f8592019-10-04 15:21:17 +0200979 }
Christopher Faulet99eff652019-08-11 23:11:30 +0200980}
981
982/* Writes the 16-bit record size <len> at address <record> */
983static inline void fcgi_set_record_size(void *record, uint16_t len)
984{
985 uint8_t *out = (record + 4);
986
987 *out = (len >> 8);
988 *(out + 1) = (len & 0xff);
989}
990
991/* Writes the 16-bit stream id <id> at address <record> */
992static inline void fcgi_set_record_id(void *record, uint16_t id)
993{
994 uint8_t *out = (record + 2);
995
996 *out = (id >> 8);
997 *(out + 1) = (id & 0xff);
998}
999
1000/* Marks a FCGI stream as CLOSED and decrement the number of active streams for
1001 * its connection if the stream was not yet closed. Please use this exclusively
1002 * before closing a stream to ensure stream count is well maintained.
1003 */
1004static inline void fcgi_strm_close(struct fcgi_strm *fstrm)
1005{
1006 if (fstrm->state != FCGI_SS_CLOSED) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001007 TRACE_ENTER(FCGI_EV_FSTRM_END, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001008 fstrm->fconn->nb_streams--;
1009 if (!fstrm->id)
1010 fstrm->fconn->nb_reserved--;
1011 if (fstrm->cs) {
1012 if (!(fstrm->cs->flags & CS_FL_EOS) && !b_data(&fstrm->rxbuf))
1013 fcgi_strm_notify_recv(fstrm);
1014 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001015 fstrm->state = FCGI_SS_CLOSED;
1016 TRACE_STATE("switching to CLOSED", FCGI_EV_FSTRM_END, fstrm->fconn->conn, fstrm);
1017 TRACE_LEAVE(FCGI_EV_FSTRM_END, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001018 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001019}
1020
1021/* Detaches a FCGI stream from its FCGI connection and releases it to the
1022 * fcgi_strm pool.
1023 */
1024static void fcgi_strm_destroy(struct fcgi_strm *fstrm)
1025{
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001026 struct connection *conn = fstrm->fconn->conn;
1027
1028 TRACE_ENTER(FCGI_EV_FSTRM_END, conn, fstrm);
1029
Christopher Faulet99eff652019-08-11 23:11:30 +02001030 fcgi_strm_close(fstrm);
1031 eb32_delete(&fstrm->by_id);
1032 if (b_size(&fstrm->rxbuf)) {
1033 b_free(&fstrm->rxbuf);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01001034 offer_buffers(NULL, 1);
Christopher Faulet99eff652019-08-11 23:11:30 +02001035 }
Willy Tarreau8907e4d2020-01-16 17:55:37 +01001036 if (fstrm->subs)
1037 fstrm->subs->events = 0;
Christopher Faulet99eff652019-08-11 23:11:30 +02001038 /* There's no need to explicitly call unsubscribe here, the only
1039 * reference left would be in the fconn send_list/fctl_list, and if
1040 * we're in it, we're getting out anyway
1041 */
1042 LIST_DEL_INIT(&fstrm->send_list);
Willy Tarreau7aad7032020-01-16 17:20:57 +01001043 tasklet_free(fstrm->shut_tl);
Christopher Faulet99eff652019-08-11 23:11:30 +02001044 pool_free(pool_head_fcgi_strm, fstrm);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001045
1046 TRACE_LEAVE(FCGI_EV_FSTRM_END, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001047}
1048
1049/* Allocates a new stream <id> for connection <fconn> and adds it into fconn's
1050 * stream tree. In case of error, nothing is added and NULL is returned. The
1051 * causes of errors can be any failed memory allocation. The caller is
1052 * responsible for checking if the connection may support an extra stream prior
1053 * to calling this function.
1054 */
1055static struct fcgi_strm *fcgi_strm_new(struct fcgi_conn *fconn, int id)
1056{
1057 struct fcgi_strm *fstrm;
1058
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001059 TRACE_ENTER(FCGI_EV_FSTRM_NEW, fconn->conn);
1060
Christopher Faulet99eff652019-08-11 23:11:30 +02001061 fstrm = pool_alloc(pool_head_fcgi_strm);
Christopher Faulet73518be2021-01-27 12:06:54 +01001062 if (!fstrm) {
1063 TRACE_ERROR("fstrm allocation failure", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR|FCGI_EV_FSTRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001064 goto out;
Christopher Faulet73518be2021-01-27 12:06:54 +01001065 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001066
Willy Tarreau7aad7032020-01-16 17:20:57 +01001067 fstrm->shut_tl = tasklet_new();
1068 if (!fstrm->shut_tl) {
Christopher Faulet73518be2021-01-27 12:06:54 +01001069 TRACE_ERROR("fstrm shut tasklet allocation failure", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR|FCGI_EV_FSTRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001070 pool_free(pool_head_fcgi_strm, fstrm);
1071 goto out;
1072 }
Willy Tarreau8907e4d2020-01-16 17:55:37 +01001073 fstrm->subs = NULL;
Willy Tarreau7aad7032020-01-16 17:20:57 +01001074 fstrm->shut_tl->process = fcgi_deferred_shut;
1075 fstrm->shut_tl->context = fstrm;
Christopher Faulet99eff652019-08-11 23:11:30 +02001076 LIST_INIT(&fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02001077 fstrm->fconn = fconn;
1078 fstrm->cs = NULL;
1079 fstrm->flags = FCGI_SF_NONE;
1080 fstrm->proto_status = 0;
1081 fstrm->state = FCGI_SS_IDLE;
1082 fstrm->rxbuf = BUF_NULL;
1083
1084 h1m_init_res(&fstrm->h1m);
1085 fstrm->h1m.err_pos = -1; // don't care about errors on the request path
1086 fstrm->h1m.flags |= (H1_MF_NO_PHDR|H1_MF_CLEAN_CONN_HDR);
1087
1088 fstrm->by_id.key = fstrm->id = id;
1089 if (id > 0)
1090 fconn->max_id = id;
1091 else
1092 fconn->nb_reserved++;
1093
1094 eb32_insert(&fconn->streams_by_id, &fstrm->by_id);
1095 fconn->nb_streams++;
1096 fconn->stream_cnt++;
1097
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001098 TRACE_LEAVE(FCGI_EV_FSTRM_NEW, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001099 return fstrm;
1100
1101 out:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001102 TRACE_DEVEL("leaving in error", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR|FCGI_EV_FSTRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001103 return NULL;
1104}
1105
1106/* Allocates a new stream associated to conn_stream <cs> on the FCGI connection
1107 * <fconn> and returns it, or NULL in case of memory allocation error or if the
1108 * highest possible stream ID was reached.
1109 */
1110static struct fcgi_strm *fcgi_conn_stream_new(struct fcgi_conn *fconn, struct conn_stream *cs,
1111 struct session *sess)
1112{
1113 struct fcgi_strm *fstrm = NULL;
1114
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001115 TRACE_ENTER(FCGI_EV_FSTRM_NEW, fconn->conn);
1116 if (fconn->nb_streams >= fconn->streams_limit) {
Christopher Faulet73518be2021-01-27 12:06:54 +01001117 TRACE_ERROR("streams_limit reached", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_END|FCGI_EV_FSTRM_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001118 goto out;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001119 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001120
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001121 if (fcgi_streams_left(fconn) < 1) {
Christopher Faulet73518be2021-01-27 12:06:54 +01001122 TRACE_ERROR("!streams_left", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_END|FCGI_EV_FSTRM_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001123 goto out;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001124 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001125
1126 /* Defer choosing the ID until we send the first message to create the stream */
1127 fstrm = fcgi_strm_new(fconn, 0);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001128 if (!fstrm) {
Christopher Faulet73518be2021-01-27 12:06:54 +01001129 TRACE_ERROR("fstream allocation failure", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_END|FCGI_EV_FSTRM_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001130 goto out;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001131 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001132
1133 fstrm->cs = cs;
1134 fstrm->sess = sess;
1135 cs->ctx = fstrm;
1136 fconn->nb_cs++;
1137
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001138 TRACE_LEAVE(FCGI_EV_FSTRM_NEW, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001139 return fstrm;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001140
1141 out:
Christopher Faulet73518be2021-01-27 12:06:54 +01001142 TRACE_DEVEL("leaving on error", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_END|FCGI_EV_FSTRM_ERR, fconn->conn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001143 return NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +02001144}
1145
1146/* Wakes a specific stream and assign its conn_stream some CS_FL_* flags among
1147 * CS_FL_ERR_PENDING and CS_FL_ERROR if needed. The stream's state is
1148 * automatically updated accordingly. If the stream is orphaned, it is
1149 * destroyed.
1150 */
1151static void fcgi_strm_wake_one_stream(struct fcgi_strm *fstrm)
1152{
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001153 struct fcgi_conn *fconn = fstrm->fconn;
1154
1155 TRACE_ENTER(FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
1156
Christopher Faulet99eff652019-08-11 23:11:30 +02001157 if (!fstrm->cs) {
1158 /* this stream was already orphaned */
1159 fcgi_strm_destroy(fstrm);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001160 TRACE_DEVEL("leaving with no fstrm", FCGI_EV_STRM_WAKE, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001161 return;
1162 }
1163
Christopher Faulet6670e3e2020-10-08 15:26:33 +02001164 if (fcgi_conn_read0_pending(fconn)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001165 if (fstrm->state == FCGI_SS_OPEN) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001166 fstrm->state = FCGI_SS_HREM;
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05001167 TRACE_STATE("switching to HREM", FCGI_EV_STRM_WAKE|FCGI_EV_FSTRM_END, fconn->conn, fstrm);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001168 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001169 else if (fstrm->state == FCGI_SS_HLOC)
1170 fcgi_strm_close(fstrm);
1171 }
1172
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001173 if ((fconn->state == FCGI_CS_CLOSED || fconn->conn->flags & CO_FL_ERROR)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001174 fstrm->cs->flags |= CS_FL_ERR_PENDING;
1175 if (fstrm->cs->flags & CS_FL_EOS)
1176 fstrm->cs->flags |= CS_FL_ERROR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001177
1178 if (fstrm->state < FCGI_SS_ERROR) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001179 fstrm->state = FCGI_SS_ERROR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001180 TRACE_STATE("switching to ERROR", FCGI_EV_STRM_WAKE|FCGI_EV_FSTRM_END, fconn->conn, fstrm);
1181 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001182 }
1183
1184 fcgi_strm_alert(fstrm);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001185
1186 TRACE_LEAVE(FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001187}
1188
1189/* Wakes unassigned streams (ID == 0) attached to the connection. */
1190static void fcgi_wake_unassigned_streams(struct fcgi_conn *fconn)
1191{
1192 struct eb32_node *node;
1193 struct fcgi_strm *fstrm;
1194
1195 node = eb32_lookup(&fconn->streams_by_id, 0);
1196 while (node) {
1197 fstrm = container_of(node, struct fcgi_strm, by_id);
1198 if (fstrm->id > 0)
1199 break;
1200 node = eb32_next(node);
1201 fcgi_strm_wake_one_stream(fstrm);
1202 }
1203}
1204
1205/* Wakes the streams attached to the connection, whose id is greater than <last>
1206 * or unassigned.
1207 */
1208static void fcgi_wake_some_streams(struct fcgi_conn *fconn, int last)
1209{
1210 struct eb32_node *node;
1211 struct fcgi_strm *fstrm;
1212
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001213 TRACE_ENTER(FCGI_EV_STRM_WAKE, fconn->conn);
1214
Christopher Faulet99eff652019-08-11 23:11:30 +02001215 /* Wake all streams with ID > last */
1216 node = eb32_lookup_ge(&fconn->streams_by_id, last + 1);
1217 while (node) {
1218 fstrm = container_of(node, struct fcgi_strm, by_id);
1219 node = eb32_next(node);
1220 fcgi_strm_wake_one_stream(fstrm);
1221 }
1222 fcgi_wake_unassigned_streams(fconn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001223
1224 TRACE_LEAVE(FCGI_EV_STRM_WAKE, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001225}
1226
1227static int fcgi_set_default_param(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
1228 struct htx *htx, struct htx_sl *sl,
1229 struct fcgi_strm_params *params)
1230{
1231 struct connection *cli_conn = objt_conn(fstrm->sess->origin);
Christopher Faulet568008d2021-10-25 07:56:51 +02001232 const struct sockaddr_storage *src = si_src(si_opposite(fstrm->cs->data));
1233 const struct sockaddr_storage *dst = si_dst(si_opposite(fstrm->cs->data));
Christopher Faulet99eff652019-08-11 23:11:30 +02001234 struct ist p;
1235
1236 if (!sl)
1237 goto error;
1238
1239 if (!(params->mask & FCGI_SP_DOC_ROOT))
1240 params->docroot = fconn->app->docroot;
1241
1242 if (!(params->mask & FCGI_SP_REQ_METH)) {
1243 p = htx_sl_req_meth(sl);
1244 params->meth = ist2(b_tail(params->p), p.len);
1245 chunk_memcat(params->p, p.ptr, p.len);
1246 }
1247 if (!(params->mask & FCGI_SP_REQ_URI)) {
Christopher Fauletfb38c912021-04-26 09:38:55 +02001248 p = h1_get_uri(sl);
Christopher Faulet99eff652019-08-11 23:11:30 +02001249 params->uri = ist2(b_tail(params->p), p.len);
1250 chunk_memcat(params->p, p.ptr, p.len);
1251 }
1252 if (!(params->mask & FCGI_SP_SRV_PROTO)) {
1253 p = htx_sl_req_vsn(sl);
1254 params->vsn = ist2(b_tail(params->p), p.len);
1255 chunk_memcat(params->p, p.ptr, p.len);
1256 }
1257 if (!(params->mask & FCGI_SP_SRV_PORT)) {
1258 char *end;
1259 int port = 0;
Christopher Faulet568008d2021-10-25 07:56:51 +02001260 if (dst)
1261 port = get_host_port(dst);
Christopher Faulet99eff652019-08-11 23:11:30 +02001262 end = ultoa_o(port, b_tail(params->p), b_room(params->p));
1263 if (!end)
1264 goto error;
1265 params->srv_port = ist2(b_tail(params->p), end - b_tail(params->p));
1266 params->p->data += params->srv_port.len;
1267 }
1268 if (!(params->mask & FCGI_SP_SRV_NAME)) {
1269 /* If no Host header found, use the server address to fill
1270 * srv_name */
1271 if (!istlen(params->srv_name)) {
1272 char *ptr = NULL;
1273
Christopher Faulet568008d2021-10-25 07:56:51 +02001274 if (dst)
1275 if (addr_to_str(dst, b_tail(params->p), b_room(params->p)) != -1)
Christopher Faulet99eff652019-08-11 23:11:30 +02001276 ptr = b_tail(params->p);
1277 if (ptr) {
Tim Duesterhusdcf753a2021-03-04 17:31:47 +01001278 params->srv_name = ist(ptr);
Christopher Faulet99eff652019-08-11 23:11:30 +02001279 params->p->data += params->srv_name.len;
1280 }
1281 }
1282 }
1283 if (!(params->mask & FCGI_SP_REM_ADDR)) {
1284 char *ptr = NULL;
1285
Christopher Faulet568008d2021-10-25 07:56:51 +02001286 if (src)
1287 if (addr_to_str(src, b_tail(params->p), b_room(params->p)) != -1)
Christopher Faulet99eff652019-08-11 23:11:30 +02001288 ptr = b_tail(params->p);
1289 if (ptr) {
Tim Duesterhusdcf753a2021-03-04 17:31:47 +01001290 params->rem_addr = ist(ptr);
Christopher Faulet99eff652019-08-11 23:11:30 +02001291 params->p->data += params->rem_addr.len;
1292 }
1293 }
1294 if (!(params->mask & FCGI_SP_REM_PORT)) {
1295 char *end;
1296 int port = 0;
Christopher Faulet568008d2021-10-25 07:56:51 +02001297 if (src)
1298 port = get_host_port(src);
Christopher Faulet99eff652019-08-11 23:11:30 +02001299 end = ultoa_o(port, b_tail(params->p), b_room(params->p));
1300 if (!end)
1301 goto error;
1302 params->rem_port = ist2(b_tail(params->p), end - b_tail(params->p));
1303 params->p->data += params->rem_port.len;
1304 }
1305 if (!(params->mask & FCGI_SP_CONT_LEN)) {
1306 struct htx_blk *blk;
1307 enum htx_blk_type type;
1308 char *end;
1309 size_t len = 0;
1310
1311 for (blk = htx_get_head_blk(htx); blk; blk = htx_get_next_blk(htx, blk)) {
1312 type = htx_get_blk_type(blk);
1313
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001314 if (type == HTX_BLK_TLR || type == HTX_BLK_EOT)
Christopher Faulet99eff652019-08-11 23:11:30 +02001315 break;
1316 if (type == HTX_BLK_DATA)
1317 len += htx_get_blksz(blk);
1318 }
1319 end = ultoa_o(len, b_tail(params->p), b_room(params->p));
1320 if (!end)
1321 goto error;
1322 params->cont_len = ist2(b_tail(params->p), end - b_tail(params->p));
1323 params->p->data += params->cont_len.len;
1324 }
Willy Tarreaud2ae3852021-10-06 11:40:11 +02001325
Christopher Faulet99eff652019-08-11 23:11:30 +02001326 if (!(params->mask & FCGI_SP_HTTPS)) {
Christopher Fauletbb86a0f2020-04-24 07:19:04 +02001327 if (cli_conn)
Willy Tarreau1057bee2021-10-06 11:38:44 +02001328 params->https = conn_is_ssl(cli_conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001329 }
Willy Tarreaud2ae3852021-10-06 11:40:11 +02001330
Christopher Faulet99eff652019-08-11 23:11:30 +02001331 if ((params->mask & FCGI_SP_URI_MASK) != FCGI_SP_URI_MASK) {
1332 /* one of scriptname, pathinfo or query_string is no set */
Amaury Denoyellec453f952021-07-06 11:40:12 +02001333 struct http_uri_parser parser = http_uri_parser_init(params->uri);
1334 struct ist path = http_parse_path(&parser);
Christopher Faulet99eff652019-08-11 23:11:30 +02001335 int len;
1336
Christopher Faulet99eff652019-08-11 23:11:30 +02001337 /* No scrit_name set but no valid path ==> error */
1338 if (!(params->mask & FCGI_SP_SCRIPT_NAME) && !istlen(path))
1339 goto error;
1340
Christopher Faulet99eff652019-08-11 23:11:30 +02001341 /* If there is a query-string, Set it if not already set */
Christopher Faulet0f17a442020-07-23 15:44:37 +02001342 if (!(params->mask & FCGI_SP_REQ_QS)) {
1343 struct ist qs = istfind(path, '?');
1344
1345 /* Update the path length */
1346 path.len -= qs.len;
1347
1348 /* Set the query-string skipping the '?', if any */
1349 if (istlen(qs))
1350 params->qs = istnext(qs);
1351 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001352
1353 /* If the script_name is set, don't try to deduce the path_info
1354 * too. The opposite is not true.
1355 */
1356 if (params->mask & FCGI_SP_SCRIPT_NAME) {
1357 params->mask |= FCGI_SP_PATH_INFO;
1358 goto end;
1359 }
1360
Christopher Faulet0f17a442020-07-23 15:44:37 +02001361 /* Decode the path. it must first be copied to keep the URI
1362 * untouched.
1363 */
1364 chunk_memcat(params->p, path.ptr, path.len);
1365 path.ptr = b_tail(params->p) - path.len;
1366 len = url_decode(ist0(path), 0);
1367 if (len < 0)
1368 goto error;
1369 path.len = len;
1370
Christopher Faulet99eff652019-08-11 23:11:30 +02001371 /* script_name not set, preset it with the path for now */
Christopher Faulet0f17a442020-07-23 15:44:37 +02001372 params->scriptname = path;
Christopher Faulet99eff652019-08-11 23:11:30 +02001373
1374 /* If there is no regex to match the pathinfo, just to the last
1375 * part and see if the index must be used.
1376 */
1377 if (!fconn->app->pathinfo_re)
1378 goto check_index;
1379
Christopher Faulet28cb3662020-02-14 14:47:37 +01001380 /* If some special characters are found in the decoded path (\n
Ilya Shipitsin01881082021-08-07 14:41:56 +05001381 * or \0), the PATH_INFO regex cannot match. This is theoretically
Christopher Faulet28cb3662020-02-14 14:47:37 +01001382 * valid, but probably unexpected, to have such characters. So,
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05001383 * to avoid any surprises, an error is triggered in this
Christopher Faulet28cb3662020-02-14 14:47:37 +01001384 * case.
1385 */
1386 if (istchr(path, '\n') || istchr(path, '\0'))
1387 goto error;
1388
Christopher Faulet99eff652019-08-11 23:11:30 +02001389 /* The regex does not match, just to the last part and see if
1390 * the index must be used.
1391 */
1392 if (!regex_exec_match2(fconn->app->pathinfo_re, path.ptr, len, MAX_MATCH, pmatch, 0))
1393 goto check_index;
1394
Christopher Faulet6c57f2d2020-02-14 16:55:52 +01001395 /* We must have at least 1 capture for the script name,
1396 * otherwise we do nothing and jump to the last part.
Christopher Faulet99eff652019-08-11 23:11:30 +02001397 */
Christopher Faulet6c57f2d2020-02-14 16:55:52 +01001398 if (pmatch[1].rm_so == -1 || pmatch[1].rm_eo == -1)
Christopher Faulet99eff652019-08-11 23:11:30 +02001399 goto check_index;
1400
Christopher Faulet6c57f2d2020-02-14 16:55:52 +01001401 /* Finally we can set the script_name and the path_info. The
1402 * path_info is set if not already defined, and if it was
1403 * captured
1404 */
Christopher Faulet99eff652019-08-11 23:11:30 +02001405 params->scriptname = ist2(path.ptr + pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so);
Christopher Faulet6c57f2d2020-02-14 16:55:52 +01001406 if (!(params->mask & FCGI_SP_PATH_INFO) && (pmatch[2].rm_so == -1 || pmatch[2].rm_eo == -1))
1407 params->pathinfo = ist2(path.ptr + pmatch[2].rm_so, pmatch[2].rm_eo - pmatch[2].rm_so);
Christopher Faulet99eff652019-08-11 23:11:30 +02001408
1409 check_index:
1410 len = params->scriptname.len;
1411 /* the script_name if finished by a '/' so we can add the index
1412 * part, if any.
1413 */
1414 if (istlen(fconn->app->index) && params->scriptname.ptr[len-1] == '/') {
1415 struct ist sn = params->scriptname;
1416
1417 params->scriptname = ist2(b_tail(params->p), len+fconn->app->index.len);
1418 chunk_memcat(params->p, sn.ptr, sn.len);
1419 chunk_memcat(params->p, fconn->app->index.ptr, fconn->app->index.len);
1420 }
1421 }
1422
Christopher Faulet5cd0e522021-06-11 13:34:42 +02001423 if (!(params->mask & FCGI_SP_SRV_SOFT)) {
1424 params->srv_soft = ist2(b_tail(params->p), 0);
1425 chunk_appendf(params->p, "HAProxy %s", haproxy_version);
1426 params->srv_soft.len = b_tail(params->p) - params->srv_soft.ptr;
1427 }
1428
Christopher Faulet99eff652019-08-11 23:11:30 +02001429 end:
1430 return 1;
1431 error:
1432 return 0;
1433}
1434
1435static int fcgi_encode_default_param(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
1436 struct fcgi_strm_params *params, struct buffer *outbuf, int flag)
1437{
1438 struct fcgi_param p;
1439
1440 if (params->mask & flag)
1441 return 1;
1442
1443 chunk_reset(&trash);
1444
1445 switch (flag) {
1446 case FCGI_SP_CGI_GATEWAY:
1447 p.n = ist("GATEWAY_INTERFACE");
1448 p.v = ist("CGI/1.1");
1449 goto encode;
1450 case FCGI_SP_DOC_ROOT:
1451 p.n = ist("DOCUMENT_ROOT");
1452 p.v = params->docroot;
1453 goto encode;
1454 case FCGI_SP_SCRIPT_NAME:
1455 p.n = ist("SCRIPT_NAME");
1456 p.v = params->scriptname;
1457 goto encode;
1458 case FCGI_SP_PATH_INFO:
1459 p.n = ist("PATH_INFO");
1460 p.v = params->pathinfo;
1461 goto encode;
1462 case FCGI_SP_REQ_URI:
1463 p.n = ist("REQUEST_URI");
1464 p.v = params->uri;
1465 goto encode;
1466 case FCGI_SP_REQ_METH:
1467 p.n = ist("REQUEST_METHOD");
1468 p.v = params->meth;
1469 goto encode;
1470 case FCGI_SP_REQ_QS:
1471 p.n = ist("QUERY_STRING");
1472 p.v = params->qs;
1473 goto encode;
1474 case FCGI_SP_SRV_NAME:
1475 p.n = ist("SERVER_NAME");
1476 p.v = params->srv_name;
1477 goto encode;
1478 case FCGI_SP_SRV_PORT:
1479 p.n = ist("SERVER_PORT");
1480 p.v = params->srv_port;
1481 goto encode;
1482 case FCGI_SP_SRV_PROTO:
1483 p.n = ist("SERVER_PROTOCOL");
1484 p.v = params->vsn;
1485 goto encode;
1486 case FCGI_SP_REM_ADDR:
1487 p.n = ist("REMOTE_ADDR");
1488 p.v = params->rem_addr;
1489 goto encode;
1490 case FCGI_SP_REM_PORT:
1491 p.n = ist("REMOTE_PORT");
1492 p.v = params->rem_port;
1493 goto encode;
1494 case FCGI_SP_SCRIPT_FILE:
1495 p.n = ist("SCRIPT_FILENAME");
1496 chunk_memcat(&trash, params->docroot.ptr, params->docroot.len);
1497 chunk_memcat(&trash, params->scriptname.ptr, params->scriptname.len);
1498 p.v = ist2(b_head(&trash), b_data(&trash));
1499 goto encode;
1500 case FCGI_SP_PATH_TRANS:
1501 if (!istlen(params->pathinfo))
1502 goto skip;
1503 p.n = ist("PATH_TRANSLATED");
1504 chunk_memcat(&trash, params->docroot.ptr, params->docroot.len);
1505 chunk_memcat(&trash, params->pathinfo.ptr, params->pathinfo.len);
1506 p.v = ist2(b_head(&trash), b_data(&trash));
1507 goto encode;
1508 case FCGI_SP_CONT_LEN:
1509 p.n = ist("CONTENT_LENGTH");
1510 p.v = params->cont_len;
1511 goto encode;
1512 case FCGI_SP_HTTPS:
1513 if (!params->https)
1514 goto skip;
1515 p.n = ist("HTTPS");
1516 p.v = ist("on");
1517 goto encode;
Christopher Faulet5cd0e522021-06-11 13:34:42 +02001518 case FCGI_SP_SRV_SOFT:
1519 p.n = ist("SERVER_SOFTWARE");
1520 p.v = params->srv_soft;
1521 goto encode;
Christopher Faulet99eff652019-08-11 23:11:30 +02001522 default:
1523 goto skip;
1524 }
1525
1526 encode:
1527 if (!istlen(p.v))
1528 goto skip;
1529 if (!fcgi_encode_param(outbuf, &p))
1530 return 0;
1531 skip:
1532 params->mask |= flag;
1533 return 1;
1534}
1535
1536/* Sends a GET_VALUES record. Returns > 0 on success, 0 if it couldn't do
1537 * anything. It is highly unexpected, but if the record is larger than a buffer
1538 * and cannot be encoded in one time, an error is triggered and the connection is
1539 * closed. GET_VALUES record cannot be split.
1540 */
1541static int fcgi_conn_send_get_values(struct fcgi_conn *fconn)
1542{
1543 struct buffer outbuf;
1544 struct buffer *mbuf;
1545 struct fcgi_param max_reqs = { .n = ist("FCGI_MAX_REQS"), .v = ist("")};
1546 struct fcgi_param mpxs_conns = { .n = ist("FCGI_MPXS_CONNS"), .v = ist("")};
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001547 int ret = 0;
1548
1549 TRACE_ENTER(FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001550
1551 mbuf = br_tail(fconn->mbuf);
1552 retry:
1553 if (!fcgi_get_buf(fconn, mbuf)) {
1554 fconn->flags |= FCGI_CF_MUX_MALLOC;
1555 fconn->flags |= FCGI_CF_DEM_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001556 TRACE_STATE("waiting for fconn mbuf ring allocation", FCGI_EV_TX_RECORD|FCGI_EV_FCONN_BLK, fconn->conn);
1557 ret = 0;
1558 goto end;
Christopher Faulet99eff652019-08-11 23:11:30 +02001559 }
1560
1561 while (1) {
1562 outbuf = b_make(b_tail(mbuf), b_contig_space(mbuf), 0, 0);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001563 if (outbuf.size >= FCGI_RECORD_HEADER_SZ || !b_space_wraps(mbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02001564 break;
1565 realign_again:
1566 b_slow_realign(mbuf, trash.area, b_data(mbuf));
1567 }
1568
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001569 if (outbuf.size < FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02001570 goto full;
1571
1572 /* vsn: 1(FCGI_VERSION), type: (9)FCGI_GET_VALUES, id: 0x0000,
1573 * len: 0x0000 (fill later), padding: 0x00, rsv: 0x00 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001574 memcpy(outbuf.area, "\x01\x09\x00\x00\x00\x00\x00\x00", FCGI_RECORD_HEADER_SZ);
1575 outbuf.data = FCGI_RECORD_HEADER_SZ;
Christopher Faulet99eff652019-08-11 23:11:30 +02001576
1577 /* Note: Don't send the param FCGI_MAX_CONNS because its value cannot be
1578 * handled by HAProxy.
1579 */
1580 if (!fcgi_encode_param(&outbuf, &max_reqs) || !fcgi_encode_param(&outbuf, &mpxs_conns))
1581 goto full;
1582
1583 /* update the record's size now */
Willy Tarreau022e5e52020-09-10 09:33:15 +02001584 TRACE_PROTO("FCGI GET_VALUES record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn, 0, 0, (size_t[]){outbuf.data-8});
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001585 fcgi_set_record_size(outbuf.area, outbuf.data - FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02001586 b_add(mbuf, outbuf.data);
1587 ret = 1;
1588
1589 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001590 TRACE_LEAVE(FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001591 return ret;
1592 full:
1593 /* Too large to be encoded. For GET_VALUES records, it is an error */
Christopher Faulet73518be2021-01-27 12:06:54 +01001594 if (!b_data(mbuf)) {
1595 TRACE_ERROR("GET_VALUES record too large", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001596 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +01001597 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001598
1599 if ((mbuf = br_tail_add(fconn->mbuf)) != NULL)
1600 goto retry;
1601 fconn->flags |= FCGI_CF_MUX_MFULL;
1602 fconn->flags |= FCGI_CF_DEM_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001603 TRACE_STATE("mbuf ring full", FCGI_EV_TX_RECORD|FCGI_EV_FCONN_BLK, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001604 ret = 0;
1605 goto end;
1606 fail:
1607 fconn->state = FCGI_CS_CLOSED;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001608 TRACE_STATE("switching to CLOSED", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL|FCGI_EV_FCONN_END, fconn->conn);
1609 TRACE_DEVEL("leaving on error", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
1610 return 0;
Christopher Faulet99eff652019-08-11 23:11:30 +02001611}
1612
1613/* Processes a GET_VALUES_RESULT record. Returns > 0 on success, 0 if it
1614 * couldn't do anything. It is highly unexpected, but if the record is larger
1615 * than a buffer and cannot be decoded in one time, an error is triggered and
1616 * the connection is closed. GET_VALUES_RESULT record cannot be split.
1617 */
1618static int fcgi_conn_handle_values_result(struct fcgi_conn *fconn)
1619{
1620 struct buffer inbuf;
1621 struct buffer *dbuf;
1622 size_t offset;
1623
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001624 TRACE_ENTER(FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
1625
Christopher Faulet99eff652019-08-11 23:11:30 +02001626 dbuf = &fconn->dbuf;
1627
1628 /* Record too large to be fully decoded */
1629 if (b_size(dbuf) < (fconn->drl + fconn->drp))
1630 goto fail;
1631
1632 /* process full record only */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001633 if (b_data(dbuf) < (fconn->drl + fconn->drp)) {
1634 TRACE_DEVEL("leaving on missing data", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001635 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001636 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001637
1638 if (unlikely(b_contig_data(dbuf, b_head_ofs(dbuf)) < fconn->drl)) {
1639 /* Realign the dmux buffer if the record wraps. It is unexpected
1640 * at this stage because it should be the first record received
1641 * from the FCGI application.
1642 */
Christopher Faulet00d7cde2021-02-04 11:01:51 +01001643 b_slow_realign_ofs(dbuf, trash.area, 0);
Christopher Faulet99eff652019-08-11 23:11:30 +02001644 }
1645
1646 inbuf = b_make(b_head(dbuf), b_data(dbuf), 0, fconn->drl);
1647
1648 for (offset = 0; offset < b_data(&inbuf); ) {
1649 struct fcgi_param p;
1650 size_t ret;
1651
1652 ret = fcgi_aligned_decode_param(&inbuf, offset, &p);
1653 if (!ret) {
1654 /* name or value too large to be decoded at once */
Christopher Faulet73518be2021-01-27 12:06:54 +01001655 TRACE_ERROR("error decoding GET_VALUES_RESULT param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001656 goto fail;
1657 }
1658 offset += ret;
1659
1660 if (isteqi(p.n, ist("FCGI_MPXS_CONNS"))) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001661 if (isteq(p.v, ist("1"))) {
Willy Tarreau022e5e52020-09-10 09:33:15 +02001662 TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){1});
Christopher Faulet99eff652019-08-11 23:11:30 +02001663 fconn->flags |= FCGI_CF_MPXS_CONNS;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001664 }
1665 else {
Willy Tarreau022e5e52020-09-10 09:33:15 +02001666 TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){0});
Christopher Faulet99eff652019-08-11 23:11:30 +02001667 fconn->flags &= ~FCGI_CF_MPXS_CONNS;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001668 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001669 }
1670 else if (isteqi(p.n, ist("FCGI_MAX_REQS"))) {
1671 fconn->streams_limit = strl2ui(p.v.ptr, p.v.len);
Willy Tarreau022e5e52020-09-10 09:33:15 +02001672 TRACE_STATE("set streams_limit", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){fconn->streams_limit});
Christopher Faulet99eff652019-08-11 23:11:30 +02001673 }
1674 /*
1675 * Ignore all other params
1676 */
1677 }
1678
1679 /* Reset the number of concurrent streams supported if the FCGI
1680 * application does not support connection multiplexing
1681 */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001682 if (!(fconn->flags & FCGI_CF_MPXS_CONNS)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001683 fconn->streams_limit = 1;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001684 TRACE_STATE("no mpxs for streams_limit to 1", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
1685 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001686
1687 /* We must be sure to have read exactly the announced record length, no
1688 * more no less
1689 */
Christopher Faulet73518be2021-01-27 12:06:54 +01001690 if (offset != fconn->drl) {
1691 TRACE_ERROR("invalid GET_VALUES_RESULT record length", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001692 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +01001693 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001694
Willy Tarreau022e5e52020-09-10 09:33:15 +02001695 TRACE_PROTO("FCGI GET_VALUES_RESULT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){fconn->drl});
Christopher Faulet99eff652019-08-11 23:11:30 +02001696 b_del(&fconn->dbuf, fconn->drl + fconn->drp);
1697 fconn->drl = 0;
1698 fconn->drp = 0;
1699 fconn->state = FCGI_CS_RECORD_H;
1700 fcgi_wake_unassigned_streams(fconn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001701 TRACE_STATE("switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
1702 TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001703 return 1;
1704 fail:
1705 fconn->state = FCGI_CS_CLOSED;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001706 TRACE_STATE("switching to CLOSED", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
1707 TRACE_DEVEL("leaving on error", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001708 return 0;
1709}
1710
1711/* Sends an ABORT_REQUEST record for each active streams. Closed streams are
1712 * excluded, as the streams which already received the end-of-stream. It returns
1713 * > 0 if the record was sent tp all streams. Otherwise it returns 0.
1714 */
1715static int fcgi_conn_send_aborts(struct fcgi_conn *fconn)
1716{
1717 struct eb32_node *node;
1718 struct fcgi_strm *fstrm;
1719
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001720 TRACE_ENTER(FCGI_EV_TX_RECORD, fconn->conn);
1721
Christopher Faulet99eff652019-08-11 23:11:30 +02001722 node = eb32_lookup_ge(&fconn->streams_by_id, 1);
1723 while (node) {
1724 fstrm = container_of(node, struct fcgi_strm, by_id);
1725 node = eb32_next(node);
1726 if (fstrm->state != FCGI_SS_CLOSED &&
1727 !(fstrm->flags & (FCGI_SF_ES_RCVD|FCGI_SF_ABRT_SENT)) &&
1728 !fcgi_strm_send_abort(fconn, fstrm))
1729 return 0;
1730 }
1731 fconn->flags |= FCGI_CF_ABRTS_SENT;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001732 TRACE_STATE("aborts sent to all fstrms", FCGI_EV_TX_RECORD, fconn->conn);
1733 TRACE_LEAVE(FCGI_EV_TX_RECORD, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001734 return 1;
1735}
1736
1737/* Sends a BEGIN_REQUEST record. It returns > 0 on success, 0 if it couldn't do
1738 * anything. BEGIN_REQUEST record cannot be split. So we wait to have enough
1739 * space to proceed. It is small enough to be encoded in an empty buffer.
1740 */
1741static int fcgi_strm_send_begin_request(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
1742{
1743 struct buffer outbuf;
1744 struct buffer *mbuf;
1745 struct fcgi_begin_request rec = { .role = FCGI_RESPONDER, .flags = 0};
1746 int ret;
1747
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001748 TRACE_ENTER(FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm);
1749
Christopher Faulet99eff652019-08-11 23:11:30 +02001750 mbuf = br_tail(fconn->mbuf);
1751 retry:
1752 if (!fcgi_get_buf(fconn, mbuf)) {
1753 fconn->flags |= FCGI_CF_MUX_MALLOC;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001754 fstrm->flags |= FCGI_SF_BLK_MROOM;
1755 TRACE_STATE("waiting for fconn mbuf ring allocation", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
1756 ret = 0;
1757 goto end;
Christopher Faulet99eff652019-08-11 23:11:30 +02001758 }
1759
1760 while (1) {
1761 outbuf = b_make(b_tail(mbuf), b_contig_space(mbuf), 0, 0);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001762 if (outbuf.size >= FCGI_RECORD_HEADER_SZ || !b_space_wraps(mbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02001763 break;
1764 realign_again:
1765 b_slow_realign(mbuf, trash.area, b_data(mbuf));
1766 }
1767
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001768 if (outbuf.size < FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02001769 goto full;
1770
1771 /* vsn: 1(FCGI_VERSION), type: (1)FCGI_BEGIN_REQUEST, id: fstrm->id,
1772 * len: 0x0008, padding: 0x00, rsv: 0x00 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001773 memcpy(outbuf.area, "\x01\x01\x00\x00\x00\x08\x00\x00", FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02001774 fcgi_set_record_id(outbuf.area, fstrm->id);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001775 outbuf.data = FCGI_RECORD_HEADER_SZ;
Christopher Faulet99eff652019-08-11 23:11:30 +02001776
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001777 if (fconn->flags & FCGI_CF_KEEP_CONN) {
1778 TRACE_STATE("keep connection opened", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001779 rec.flags |= FCGI_KEEP_CONN;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001780 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001781 if (!fcgi_encode_begin_request(&outbuf, &rec))
1782 goto full;
1783
1784 /* commit the record */
Willy Tarreau022e5e52020-09-10 09:33:15 +02001785 TRACE_PROTO("FCGI BEGIN_REQUEST record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm, 0, (size_t[]){0});
Christopher Faulet99eff652019-08-11 23:11:30 +02001786 b_add(mbuf, outbuf.data);
1787 fstrm->flags |= FCGI_SF_BEGIN_SENT;
1788 fstrm->state = FCGI_SS_OPEN;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001789 TRACE_STATE("switching to OPEN", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001790 ret = 1;
1791
1792 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001793 TRACE_LEAVE(FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001794 return ret;
1795 full:
1796 if ((mbuf = br_tail_add(fconn->mbuf)) != NULL)
1797 goto retry;
1798 fconn->flags |= FCGI_CF_MUX_MFULL;
1799 fstrm->flags |= FCGI_SF_BLK_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001800 TRACE_STATE("mbuf ring full", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02001801 ret = 0;
1802 goto end;
1803}
1804
1805/* Sends an empty record of type <rtype>. It returns > 0 on success, 0 if it
1806 * couldn't do anything. Empty record cannot be split. So we wait to have enough
1807 * space to proceed. It is small enough to be encoded in an empty buffer.
1808 */
1809static int fcgi_strm_send_empty_record(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
1810 enum fcgi_record_type rtype)
1811{
1812 struct buffer outbuf;
1813 struct buffer *mbuf;
1814 int ret;
1815
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001816 TRACE_ENTER(FCGI_EV_TX_RECORD, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001817 mbuf = br_tail(fconn->mbuf);
1818 retry:
1819 if (!fcgi_get_buf(fconn, mbuf)) {
1820 fconn->flags |= FCGI_CF_MUX_MALLOC;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001821 fstrm->flags |= FCGI_SF_BLK_MROOM;
1822 TRACE_STATE("waiting for fconn mbuf ring allocation", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
1823 ret = 0;
1824 goto end;
Christopher Faulet99eff652019-08-11 23:11:30 +02001825 }
1826
1827 while (1) {
1828 outbuf = b_make(b_tail(mbuf), b_contig_space(mbuf), 0, 0);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001829 if (outbuf.size >= FCGI_RECORD_HEADER_SZ || !b_space_wraps(mbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02001830 break;
1831 realign_again:
1832 b_slow_realign(mbuf, trash.area, b_data(mbuf));
1833 }
1834
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001835 if (outbuf.size < FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02001836 goto full;
1837
1838 /* vsn: 1(FCGI_VERSION), type: rtype, id: fstrm->id,
1839 * len: 0x0000, padding: 0x00, rsv: 0x00 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001840 memcpy(outbuf.area, "\x01\x05\x00\x00\x00\x00\x00\x00", FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02001841 outbuf.area[1] = rtype;
1842 fcgi_set_record_id(outbuf.area, fstrm->id);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001843 outbuf.data = FCGI_RECORD_HEADER_SZ;
Christopher Faulet99eff652019-08-11 23:11:30 +02001844
1845 /* commit the record */
1846 b_add(mbuf, outbuf.data);
1847 ret = 1;
1848
1849 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001850 TRACE_LEAVE(FCGI_EV_TX_RECORD, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001851 return ret;
1852 full:
1853 if ((mbuf = br_tail_add(fconn->mbuf)) != NULL)
1854 goto retry;
1855 fconn->flags |= FCGI_CF_MUX_MFULL;
1856 fstrm->flags |= FCGI_SF_BLK_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001857 TRACE_STATE("mbuf ring full", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001858 ret = 0;
1859 goto end;
1860}
1861
1862
1863/* Sends an empty PARAMS record. It relies on fcgi_strm_send_empty_record(). It
1864 * marks the end of params.
1865 */
1866static int fcgi_strm_send_empty_params(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
1867{
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001868 int ret;
1869
1870 TRACE_POINT(FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm);
1871 ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_PARAMS);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001872 if (ret) {
1873 fstrm->flags |= FCGI_SF_EP_SENT;
Willy Tarreau022e5e52020-09-10 09:33:15 +02001874 TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){0});
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001875 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001876 return ret;
Christopher Faulet99eff652019-08-11 23:11:30 +02001877}
1878
1879/* Sends an empty STDIN record. It relies on fcgi_strm_send_empty_record(). It
1880 * marks the end of input. On success, all the request was successfully sent.
1881 */
1882static int fcgi_strm_send_empty_stdin(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
1883{
1884 int ret;
1885
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001886 TRACE_POINT(FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN|FCGI_EV_TX_EOI, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001887 ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_STDIN);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001888 if (ret) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001889 fstrm->flags |= FCGI_SF_ES_SENT;
Willy Tarreau022e5e52020-09-10 09:33:15 +02001890 TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){0});
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001891 TRACE_USER("FCGI request fully xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN|FCGI_EV_TX_EOI, fconn->conn, fstrm);
1892 TRACE_STATE("stdin data fully sent", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN|FCGI_EV_TX_EOI, fconn->conn, fstrm);
1893 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001894 return ret;
1895}
1896
1897/* Sends an ABORT_REQUEST record. It relies on fcgi_strm_send_empty_record(). It
1898 * stops the request processing.
1899 */
1900static int fcgi_strm_send_abort(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
1901{
1902 int ret;
1903
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001904 TRACE_POINT(FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02001905 ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_ABORT_REQUEST);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001906 if (ret) {
Christopher Faulet99eff652019-08-11 23:11:30 +02001907 fstrm->flags |= FCGI_SF_ABRT_SENT;
Willy Tarreau022e5e52020-09-10 09:33:15 +02001908 TRACE_PROTO("FCGI ABORT record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm, 0, (size_t[]){0});
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001909 TRACE_USER("FCGI request aborted", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm);
1910 TRACE_STATE("abort sent", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm);
1911 }
Christopher Faulet99eff652019-08-11 23:11:30 +02001912 return ret;
1913}
1914
1915/* Sends a PARAMS record. Returns > 0 on success, 0 if it couldn't do
1916 * anything. If there are too much K/V params to be encoded in a PARAMS record,
1917 * several records are sent. However, a K/V param cannot be split between 2
1918 * records.
1919 */
1920static size_t fcgi_strm_send_params(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
1921 struct htx *htx)
1922{
1923 struct buffer outbuf;
1924 struct buffer *mbuf;
1925 struct htx_blk *blk;
1926 struct htx_sl *sl = NULL;
1927 struct fcgi_strm_params params;
1928 size_t total = 0;
1929
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001930 TRACE_ENTER(FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, htx);
1931
Christopher Faulet99eff652019-08-11 23:11:30 +02001932 memset(&params, 0, sizeof(params));
1933 params.p = get_trash_chunk();
1934
1935 mbuf = br_tail(fconn->mbuf);
1936 retry:
1937 if (!fcgi_get_buf(fconn, mbuf)) {
1938 fconn->flags |= FCGI_CF_MUX_MALLOC;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02001939 fstrm->flags |= FCGI_SF_BLK_MROOM;
1940 TRACE_STATE("waiting for fconn mbuf ring allocation", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
1941 goto end;
Christopher Faulet99eff652019-08-11 23:11:30 +02001942 }
1943
1944 while (1) {
1945 outbuf = b_make(b_tail(mbuf), b_contig_space(mbuf), 0, 0);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001946 if (outbuf.size >= FCGI_RECORD_HEADER_SZ || !b_space_wraps(mbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02001947 break;
1948 realign_again:
1949 b_slow_realign(mbuf, trash.area, b_data(mbuf));
1950 }
1951
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001952 if (outbuf.size < FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02001953 goto full;
1954
1955 /* vsn: 1(FCGI_VERSION), type: (4)FCGI_PARAMS, id: fstrm->id,
1956 * len: 0x0000 (fill later), padding: 0x00, rsv: 0x00 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001957 memcpy(outbuf.area, "\x01\x04\x00\x00\x00\x00\x00\x00", FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02001958 fcgi_set_record_id(outbuf.area, fstrm->id);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01001959 outbuf.data = FCGI_RECORD_HEADER_SZ;
Christopher Faulet99eff652019-08-11 23:11:30 +02001960
1961 blk = htx_get_head_blk(htx);
1962 while (blk) {
1963 enum htx_blk_type type;
1964 uint32_t size = htx_get_blksz(blk);
1965 struct fcgi_param p;
1966
1967 type = htx_get_blk_type(blk);
1968 switch (type) {
1969 case HTX_BLK_REQ_SL:
1970 sl = htx_get_blk_ptr(htx, blk);
1971 if (sl->info.req.meth == HTTP_METH_HEAD)
1972 fstrm->h1m.flags |= H1_MF_METH_HEAD;
1973 if (sl->flags & HTX_SL_F_VER_11)
1974 fstrm->h1m.flags |= H1_MF_VER_11;
1975 break;
1976
1977 case HTX_BLK_HDR:
1978 p.n = htx_get_blk_name(htx, blk);
1979 p.v = htx_get_blk_value(htx, blk);
1980
1981 if (istmatch(p.n, ist(":fcgi-"))) {
1982 p.n.ptr += 6;
1983 p.n.len -= 6;
1984 if (isteq(p.n, ist("gateway_interface")))
1985 params.mask |= FCGI_SP_CGI_GATEWAY;
1986 else if (isteq(p.n, ist("document_root"))) {
1987 params.mask |= FCGI_SP_DOC_ROOT;
1988 params.docroot = p.v;
1989 }
1990 else if (isteq(p.n, ist("script_name"))) {
1991 params.mask |= FCGI_SP_SCRIPT_NAME;
1992 params.scriptname = p.v;
1993 }
1994 else if (isteq(p.n, ist("path_info"))) {
1995 params.mask |= FCGI_SP_PATH_INFO;
1996 params.pathinfo = p.v;
1997 }
1998 else if (isteq(p.n, ist("request_uri"))) {
1999 params.mask |= FCGI_SP_REQ_URI;
2000 params.uri = p.v;
2001 }
2002 else if (isteq(p.n, ist("request_meth")))
2003 params.mask |= FCGI_SP_REQ_METH;
2004 else if (isteq(p.n, ist("query_string")))
2005 params.mask |= FCGI_SP_REQ_QS;
2006 else if (isteq(p.n, ist("server_name")))
2007 params.mask |= FCGI_SP_SRV_NAME;
2008 else if (isteq(p.n, ist("server_port")))
2009 params.mask |= FCGI_SP_SRV_PORT;
2010 else if (isteq(p.n, ist("server_protocol")))
2011 params.mask |= FCGI_SP_SRV_PROTO;
2012 else if (isteq(p.n, ist("remote_addr")))
2013 params.mask |= FCGI_SP_REM_ADDR;
2014 else if (isteq(p.n, ist("remote_port")))
2015 params.mask |= FCGI_SP_REM_PORT;
2016 else if (isteq(p.n, ist("script_filename")))
2017 params.mask |= FCGI_SP_SCRIPT_FILE;
2018 else if (isteq(p.n, ist("path_translated")))
2019 params.mask |= FCGI_SP_PATH_TRANS;
2020 else if (isteq(p.n, ist("https")))
2021 params.mask |= FCGI_SP_HTTPS;
Christopher Faulet5cd0e522021-06-11 13:34:42 +02002022 else if (isteq(p.n, ist("server_software")))
2023 params.mask |= FCGI_SP_SRV_SOFT;
Christopher Faulet99eff652019-08-11 23:11:30 +02002024 }
2025 else if (isteq(p.n, ist("content-length"))) {
2026 p.n = ist("CONTENT_LENGTH");
2027 params.mask |= FCGI_SP_CONT_LEN;
2028 }
2029 else if (isteq(p.n, ist("content-type")))
2030 p.n = ist("CONTENT_TYPE");
2031 else {
2032 if (isteq(p.n, ist("host")))
2033 params.srv_name = p.v;
Christopher Fauletf56e8462021-09-28 10:56:36 +02002034 else if (isteq(p.n, ist("te"))) {
2035 /* "te" may only be sent with "trailers" if this value
2036 * is present, otherwise it must be deleted.
2037 */
2038 p.v = istist(p.v, ist("trailers"));
2039 if (!isttest(p.v) || (p.v.len > 8 && p.v.ptr[8] != ','))
2040 break;
2041 p.v = ist("trailers");
2042 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002043
Christopher Faulet67d58092019-10-02 10:51:38 +02002044 /* Skip header if same name is used to add the server name */
2045 if (fconn->proxy->server_id_hdr_name &&
2046 isteq(p.n, ist2(fconn->proxy->server_id_hdr_name, fconn->proxy->server_id_hdr_len)))
2047 break;
2048
Christopher Faulet99eff652019-08-11 23:11:30 +02002049 memcpy(trash.area, "http_", 5);
2050 memcpy(trash.area+5, p.n.ptr, p.n.len);
2051 p.n = ist2(trash.area, p.n.len+5);
2052 }
2053
2054 if (!fcgi_encode_param(&outbuf, &p)) {
2055 if (b_space_wraps(mbuf))
2056 goto realign_again;
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002057 if (outbuf.data == FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02002058 goto full;
2059 goto done;
2060 }
2061 break;
2062
2063 case HTX_BLK_EOH:
Christopher Faulet72ba6cd2019-09-24 16:20:05 +02002064 if (fconn->proxy->server_id_hdr_name) {
2065 struct server *srv = objt_server(fconn->conn->target);
2066
2067 if (!srv)
2068 goto done;
2069
2070 memcpy(trash.area, "http_", 5);
2071 memcpy(trash.area+5, fconn->proxy->server_id_hdr_name, fconn->proxy->server_id_hdr_len);
2072 p.n = ist2(trash.area, fconn->proxy->server_id_hdr_len+5);
2073 p.v = ist(srv->id);
2074
2075 if (!fcgi_encode_param(&outbuf, &p)) {
2076 if (b_space_wraps(mbuf))
2077 goto realign_again;
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002078 if (outbuf.data == FCGI_RECORD_HEADER_SZ)
Christopher Faulet72ba6cd2019-09-24 16:20:05 +02002079 goto full;
2080 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002081 TRACE_STATE("add server name header", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm);
Christopher Faulet72ba6cd2019-09-24 16:20:05 +02002082 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002083 goto done;
2084
2085 default:
2086 break;
2087 }
2088 total += size;
2089 blk = htx_remove_blk(htx, blk);
2090 }
2091
2092 done:
Christopher Faulet73518be2021-01-27 12:06:54 +01002093 if (!fcgi_set_default_param(fconn, fstrm, htx, sl, &params)) {
2094 TRACE_ERROR("error setting default params", FCGI_EV_TX_RECORD|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002095 goto error;
Christopher Faulet73518be2021-01-27 12:06:54 +01002096 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002097
2098 if (!fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_CGI_GATEWAY) ||
2099 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_DOC_ROOT) ||
2100 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SCRIPT_NAME) ||
2101 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_PATH_INFO) ||
2102 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_REQ_URI) ||
2103 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_REQ_METH) ||
2104 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_REQ_QS) ||
2105 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SRV_NAME) ||
2106 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SRV_PORT) ||
2107 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SRV_PROTO) ||
2108 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_REM_ADDR) ||
2109 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_REM_PORT) ||
2110 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SCRIPT_FILE) ||
2111 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_PATH_TRANS) ||
2112 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_CONT_LEN) ||
Christopher Faulet5cd0e522021-06-11 13:34:42 +02002113 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_SRV_SOFT) ||
Christopher Faulet73518be2021-01-27 12:06:54 +01002114 !fcgi_encode_default_param(fconn, fstrm, &params, &outbuf, FCGI_SP_HTTPS)) {
2115 TRACE_ERROR("error encoding default params", FCGI_EV_TX_RECORD|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002116 goto error;
Christopher Faulet73518be2021-01-27 12:06:54 +01002117 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002118
2119 /* update the record's size */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002120 TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, 0, (size_t[]){outbuf.data - FCGI_RECORD_HEADER_SZ});
2121 fcgi_set_record_size(outbuf.area, outbuf.data - FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02002122 b_add(mbuf, outbuf.data);
2123
2124 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002125 TRACE_LEAVE(FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, htx, (size_t[]){total});
Christopher Faulet99eff652019-08-11 23:11:30 +02002126 return total;
2127 full:
2128 if ((mbuf = br_tail_add(fconn->mbuf)) != NULL)
2129 goto retry;
2130 fconn->flags |= FCGI_CF_MUX_MFULL;
2131 fstrm->flags |= FCGI_SF_BLK_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002132 TRACE_STATE("mbuf ring full", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002133 if (total)
2134 goto error;
2135 goto end;
2136
2137 error:
2138 htx->flags |= HTX_FL_PROCESSING_ERROR;
Christopher Faulet73518be2021-01-27 12:06:54 +01002139 TRACE_ERROR("processing error sending PARAMS record", FCGI_EV_TX_RECORD|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002140 fcgi_strm_error(fstrm);
2141 goto end;
2142}
2143
2144/* Sends a STDIN record. Returns > 0 on success, 0 if it couldn't do
2145 * anything. STDIN records contain the request body.
2146 */
2147static size_t fcgi_strm_send_stdin(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
2148 struct htx *htx, size_t count, struct buffer *buf)
2149{
2150 struct buffer outbuf;
2151 struct buffer *mbuf;
2152 struct htx_blk *blk;
2153 enum htx_blk_type type;
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002154 uint32_t size, extra_bytes;
Christopher Faulet99eff652019-08-11 23:11:30 +02002155 size_t total = 0;
2156
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002157 extra_bytes = 0;
2158
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002159 TRACE_ENTER(FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx, (size_t[]){count});
Christopher Faulet99eff652019-08-11 23:11:30 +02002160 if (!count)
2161 goto end;
2162
2163 mbuf = br_tail(fconn->mbuf);
2164 retry:
2165 if (!fcgi_get_buf(fconn, mbuf)) {
2166 fconn->flags |= FCGI_CF_MUX_MALLOC;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002167 fstrm->flags |= FCGI_SF_BLK_MROOM;
2168 TRACE_STATE("waiting for fconn mbuf ring allocation", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
2169 goto end;
Christopher Faulet99eff652019-08-11 23:11:30 +02002170 }
2171
2172 /* Perform some optimizations to reduce the number of buffer copies.
2173 * First, if the mux's buffer is empty and the htx area contains exactly
2174 * one data block of the same size as the requested count, and this
2175 * count fits within the record size, then it's possible to simply swap
2176 * the caller's buffer with the mux's output buffer and adjust offsets
2177 * and length to match the entire DATA HTX block in the middle. In this
2178 * case we perform a true zero-copy operation from end-to-end. This is
2179 * the situation that happens all the time with large files. Second, if
2180 * this is not possible, but the mux's output buffer is empty, we still
2181 * have an opportunity to avoid the copy to the intermediary buffer, by
2182 * making the intermediary buffer's area point to the output buffer's
2183 * area. In this case we want to skip the HTX header to make sure that
2184 * copies remain aligned and that this operation remains possible all
2185 * the time. This goes for headers, data blocks and any data extracted
2186 * from the HTX blocks.
2187 */
2188 blk = htx_get_head_blk(htx);
2189 if (!blk)
2190 goto end;
2191 type = htx_get_blk_type(blk);
2192 size = htx_get_blksz(blk);
2193 if (unlikely(size == count && htx_nbblks(htx) == 1 && type == HTX_BLK_DATA)) {
2194 void *old_area = mbuf->area;
2195
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002196 /* Last block of the message: Reserve the size for the empty stdin record */
2197 if (htx->flags & HTX_FL_EOM)
2198 extra_bytes = FCGI_RECORD_HEADER_SZ;
2199
Christopher Faulet99eff652019-08-11 23:11:30 +02002200 if (b_data(mbuf)) {
2201 /* Too bad there are data left there. We're willing to memcpy/memmove
2202 * up to 1/4 of the buffer, which means that it's OK to copy a large
2203 * record into a buffer containing few data if it needs to be realigned,
2204 * and that it's also OK to copy few data without realigning. Otherwise
2205 * we'll pretend the mbuf is full and wait for it to become empty.
2206 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002207 if (size + FCGI_RECORD_HEADER_SZ + extra_bytes <= b_room(mbuf) &&
Christopher Faulet99eff652019-08-11 23:11:30 +02002208 (b_data(mbuf) <= b_size(mbuf) / 4 ||
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002209 (size <= b_size(mbuf) / 4 && size + FCGI_RECORD_HEADER_SZ + extra_bytes <= b_contig_space(mbuf))))
Christopher Faulet99eff652019-08-11 23:11:30 +02002210 goto copy;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002211 goto full;
Christopher Faulet99eff652019-08-11 23:11:30 +02002212 }
2213
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002214 TRACE_PROTO("sending stding data (zero-copy)", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx, (size_t[]){size});
Christopher Faulet99eff652019-08-11 23:11:30 +02002215 /* map a FCGI record to the HTX block so that we can put the
2216 * record header there.
2217 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002218 *mbuf = b_make(buf->area, buf->size, sizeof(struct htx) + blk->addr - FCGI_RECORD_HEADER_SZ, size + FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02002219 outbuf.area = b_head(mbuf);
2220
2221 /* prepend a FCGI record header just before the DATA block */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002222 memcpy(outbuf.area, "\x01\x05\x00\x00\x00\x00\x00\x00", FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02002223 fcgi_set_record_id(outbuf.area, fstrm->id);
2224 fcgi_set_record_size(outbuf.area, size);
2225
2226 /* and exchange with our old area */
2227 buf->area = old_area;
2228 buf->data = buf->head = 0;
2229 total += size;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002230
2231 htx = (struct htx *)buf->area;
2232 htx_reset(htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02002233 goto end;
2234 }
2235
2236 copy:
2237 while (1) {
2238 outbuf = b_make(b_tail(mbuf), b_contig_space(mbuf), 0, 0);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002239 if (outbuf.size >= FCGI_RECORD_HEADER_SZ + extra_bytes || !b_space_wraps(mbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02002240 break;
2241 realign_again:
2242 b_slow_realign(mbuf, trash.area, b_data(mbuf));
2243 }
2244
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002245 if (outbuf.size < FCGI_RECORD_HEADER_SZ + extra_bytes)
Christopher Faulet99eff652019-08-11 23:11:30 +02002246 goto full;
2247
2248 /* vsn: 1(FCGI_VERSION), type: (5)FCGI_STDIN, id: fstrm->id,
2249 * len: 0x0000 (fill later), padding: 0x00, rsv: 0x00 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002250 memcpy(outbuf.area, "\x01\x05\x00\x00\x00\x00\x00\x00", FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02002251 fcgi_set_record_id(outbuf.area, fstrm->id);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002252 outbuf.data = FCGI_RECORD_HEADER_SZ;
Christopher Faulet99eff652019-08-11 23:11:30 +02002253
2254 blk = htx_get_head_blk(htx);
2255 while (blk && count) {
2256 enum htx_blk_type type = htx_get_blk_type(blk);
2257 uint32_t size = htx_get_blksz(blk);
2258 struct ist v;
2259
2260 switch (type) {
2261 case HTX_BLK_DATA:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002262 TRACE_PROTO("sending stding data", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx, (size_t[]){size});
Christopher Faulet99eff652019-08-11 23:11:30 +02002263 v = htx_get_blk_value(htx, blk);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002264
2265 if (htx_is_unique_blk(htx, blk) && (htx->flags & HTX_FL_EOM))
2266 extra_bytes = FCGI_RECORD_HEADER_SZ; /* Last block of the message */
2267
2268 if (v.len > count) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002269 v.len = count;
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002270 extra_bytes = 0;
2271 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002272
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002273 if (v.len + FCGI_RECORD_HEADER_SZ + extra_bytes > b_room(&outbuf)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002274 /* It doesn't fit at once. If it at least fits once split and
2275 * the amount of data to move is low, let's defragment the
2276 * buffer now.
2277 */
2278 if (b_space_wraps(mbuf) &&
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002279 b_data(&outbuf) + v.len + extra_bytes <= b_room(mbuf) &&
Christopher Faulet99eff652019-08-11 23:11:30 +02002280 b_data(mbuf) <= MAX_DATA_REALIGN)
2281 goto realign_again;
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002282 v.len = b_room(&outbuf) - FCGI_RECORD_HEADER_SZ - extra_bytes;
Christopher Faulet99eff652019-08-11 23:11:30 +02002283 }
2284 if (!v.len || !chunk_memcat(&outbuf, v.ptr, v.len)) {
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002285 if (outbuf.data == FCGI_RECORD_HEADER_SZ)
Christopher Faulet99eff652019-08-11 23:11:30 +02002286 goto full;
2287 goto done;
2288 }
2289 if (v.len != size) {
2290 total += v.len;
2291 count -= v.len;
2292 htx_cut_data_blk(htx, blk, v.len);
2293 goto done;
2294 }
2295 break;
2296
Christopher Faulet99eff652019-08-11 23:11:30 +02002297 default:
2298 break;
2299 }
2300 total += size;
2301 count -= size;
2302 blk = htx_remove_blk(htx, blk);
2303 }
2304
2305 done:
2306 /* update the record's size */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002307 TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){outbuf.data - FCGI_RECORD_HEADER_SZ});
2308 fcgi_set_record_size(outbuf.area, outbuf.data - FCGI_RECORD_HEADER_SZ);
Christopher Faulet99eff652019-08-11 23:11:30 +02002309 b_add(mbuf, outbuf.data);
2310
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002311 /* Send the empty stding here to finish the message */
2312 if (htx_is_empty(htx) && (htx->flags & HTX_FL_EOM)) {
2313 TRACE_PROTO("sending FCGI STDIN record", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx);
2314 if (!fcgi_strm_send_empty_stdin(fconn, fstrm)) {
2315 /* bytes already reserved for this record. It should not fail */
2316 htx->flags |= HTX_FL_PROCESSING_ERROR;
Christopher Faulet73518be2021-01-27 12:06:54 +01002317 TRACE_ERROR("processing error sending empty STDIN record", FCGI_EV_TX_RECORD|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002318 fcgi_strm_error(fstrm);
2319 }
2320 }
2321
Christopher Faulet99eff652019-08-11 23:11:30 +02002322 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002323 TRACE_LEAVE(FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx, (size_t[]){total});
Christopher Faulet99eff652019-08-11 23:11:30 +02002324 return total;
2325 full:
2326 if ((mbuf = br_tail_add(fconn->mbuf)) != NULL)
2327 goto retry;
2328 fconn->flags |= FCGI_CF_MUX_MFULL;
2329 fstrm->flags |= FCGI_SF_BLK_MROOM;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002330 TRACE_STATE("mbuf ring full", FCGI_EV_TX_RECORD|FCGI_EV_FSTRM_BLK|FCGI_EV_FCONN_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002331 goto end;
2332}
2333
2334/* Processes a STDOUT record. Returns > 0 on success, 0 if it couldn't do
2335 * anything. STDOUT records contain the entire response. All the content is
2336 * copied in the stream's rxbuf. The parsing will be handled in fcgi_rcv_buf().
2337 */
2338static int fcgi_strm_handle_stdout(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
2339{
2340 struct buffer *dbuf;
2341 size_t ret;
2342 size_t max;
2343
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002344 TRACE_ENTER(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
2345
Christopher Faulet99eff652019-08-11 23:11:30 +02002346 dbuf = &fconn->dbuf;
2347
2348 /* Only padding remains */
2349 if (fconn->state == FCGI_CS_RECORD_P)
2350 goto end_transfer;
2351
2352 if (b_data(dbuf) < (fconn->drl + fconn->drp) &&
2353 b_size(dbuf) > (fconn->drl + fconn->drp) &&
2354 buf_room_for_htx_data(dbuf))
2355 goto fail; // incomplete record
2356
2357 if (!fcgi_get_buf(fconn, &fstrm->rxbuf)) {
2358 fconn->flags |= FCGI_CF_DEM_SALLOC;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002359 TRACE_STATE("waiting for fstrm rxbuf allocation", FCGI_EV_RX_RECORD|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
2360 goto fail;
Christopher Faulet99eff652019-08-11 23:11:30 +02002361 }
2362
2363 /*max = MIN(b_room(&fstrm->rxbuf), fconn->drl);*/
2364 max = buf_room_for_htx_data(&fstrm->rxbuf);
2365 if (!b_data(&fstrm->rxbuf))
2366 fstrm->rxbuf.head = sizeof(struct htx);
2367 if (max > fconn->drl)
2368 max = fconn->drl;
2369
2370 ret = b_xfer(&fstrm->rxbuf, dbuf, max);
2371 if (!ret)
2372 goto fail;
2373 fconn->drl -= ret;
Willy Tarreau022e5e52020-09-10 09:33:15 +02002374 TRACE_DATA("move some data to fstrm rxbuf", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){ret});
2375 TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02002376
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002377 if (!buf_room_for_htx_data(&fstrm->rxbuf)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002378 fconn->flags |= FCGI_CF_DEM_SFULL;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002379 TRACE_STATE("fstrm rxbuf full", FCGI_EV_RX_RECORD|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
2380 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002381
2382 if (fconn->drl)
2383 goto fail;
2384
2385 end_transfer:
Christopher Faulet6c99d3b2020-07-15 15:55:52 +02002386 fconn->state = FCGI_CS_RECORD_P;
Christopher Faulet99eff652019-08-11 23:11:30 +02002387 fconn->drl += fconn->drp;
2388 fconn->drp = 0;
2389 ret = MIN(b_data(&fconn->dbuf), fconn->drl);
2390 b_del(&fconn->dbuf, ret);
2391 fconn->drl -= ret;
2392 if (fconn->drl)
2393 goto fail;
2394
2395 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002396 TRACE_STATE("switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn, fstrm);
2397 TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002398 return 1;
2399 fail:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002400 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002401 return 0;
2402}
2403
2404
2405/* Processes an empty STDOUT. Returns > 0 on success, 0 if it couldn't do
2406 * anything. It only skip the padding in fact, there is no payload for such
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05002407 * records. It marks the end of the response.
Christopher Faulet99eff652019-08-11 23:11:30 +02002408 */
2409static int fcgi_strm_handle_empty_stdout(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
2410{
2411 int ret;
2412
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002413 TRACE_ENTER(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
2414
Christopher Faulet99eff652019-08-11 23:11:30 +02002415 fconn->state = FCGI_CS_RECORD_P;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002416 TRACE_STATE("switching to RECORD_P", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002417 fconn->drl += fconn->drp;
2418 fconn->drp = 0;
2419 ret = MIN(b_data(&fconn->dbuf), fconn->drl);
2420 b_del(&fconn->dbuf, ret);
2421 fconn->drl -= ret;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002422 if (fconn->drl) {
2423 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002424 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002425 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002426 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet3b3096e2020-07-15 16:04:49 +02002427 fstrm->flags |= FCGI_SF_ES_RCVD;
Willy Tarreau022e5e52020-09-10 09:33:15 +02002428 TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){0});
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002429 TRACE_STATE("stdout data fully send, switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR|FCGI_EV_RX_EOI, fconn->conn, fstrm);
2430 TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002431 return 1;
2432}
2433
2434/* Processes a STDERR record. Returns > 0 on success, 0 if it couldn't do
2435 * anything.
2436 */
2437static int fcgi_strm_handle_stderr(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
2438{
2439 struct buffer *dbuf;
2440 struct buffer tag;
2441 size_t ret;
2442
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002443 TRACE_ENTER(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002444 dbuf = &fconn->dbuf;
2445
2446 /* Only padding remains */
Christopher Faulet7f854332020-07-15 15:46:30 +02002447 if (fconn->state == FCGI_CS_RECORD_P || !fconn->drl)
Christopher Faulet99eff652019-08-11 23:11:30 +02002448 goto end_transfer;
2449
2450 if (b_data(dbuf) < (fconn->drl + fconn->drp) &&
2451 b_size(dbuf) > (fconn->drl + fconn->drp) &&
2452 buf_room_for_htx_data(dbuf))
2453 goto fail; // incomplete record
2454
2455 chunk_reset(&trash);
2456 ret = b_xfer(&trash, dbuf, MIN(b_room(&trash), fconn->drl));
2457 if (!ret)
2458 goto fail;
2459 fconn->drl -= ret;
Willy Tarreau022e5e52020-09-10 09:33:15 +02002460 TRACE_PROTO("FCGI STDERR record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02002461
2462 trash.area[ret] = '\n';
2463 trash.area[ret+1] = '\0';
2464 tag.area = fconn->app->name; tag.data = strlen(fconn->app->name);
Christopher Fauletc45791a2019-09-24 14:30:46 +02002465 app_log(&fconn->app->logsrvs, &tag, LOG_ERR, "%s", trash.area);
Christopher Faulet99eff652019-08-11 23:11:30 +02002466
2467 if (fconn->drl)
2468 goto fail;
2469
2470 end_transfer:
Christopher Faulet6c99d3b2020-07-15 15:55:52 +02002471 fconn->state = FCGI_CS_RECORD_P;
Christopher Faulet99eff652019-08-11 23:11:30 +02002472 fconn->drl += fconn->drp;
2473 fconn->drp = 0;
2474 ret = MIN(b_data(&fconn->dbuf), fconn->drl);
2475 b_del(&fconn->dbuf, ret);
2476 fconn->drl -= ret;
2477 if (fconn->drl)
2478 goto fail;
2479 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002480 TRACE_STATE("switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn, fstrm);
2481 TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002482 return 1;
2483 fail:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002484 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002485 return 0;
2486}
2487
2488/* Processes an END_REQUEST record. Returns > 0 on success, 0 if it couldn't do
2489 * anything. If the empty STDOUT record is not already received, this one marks
2490 * the end of the response. It is highly unexpected, but if the record is larger
2491 * than a buffer and cannot be decoded in one time, an error is triggered and
2492 * the connection is closed. END_REQUEST record cannot be split.
2493 */
2494static int fcgi_strm_handle_end_request(struct fcgi_conn *fconn, struct fcgi_strm *fstrm)
2495{
2496 struct buffer inbuf;
2497 struct buffer *dbuf;
2498 struct fcgi_end_request endreq;
2499
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002500 TRACE_ENTER(FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002501 dbuf = &fconn->dbuf;
2502
2503 /* Record too large to be fully decoded */
Christopher Faulet73518be2021-01-27 12:06:54 +01002504 if (b_size(dbuf) < (fconn->drl + fconn->drp)) {
2505 TRACE_ERROR("END_REQUEST record too large", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_FSTRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002506 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +01002507 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002508
2509 /* process full record only */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002510 if (b_data(dbuf) < (fconn->drl + fconn->drp)) {
2511 TRACE_DEVEL("leaving on missing data", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002512 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002513 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002514
2515 if (unlikely(b_contig_data(dbuf, b_head_ofs(dbuf)) < fconn->drl)) {
2516 /* Realign the dmux buffer if the record wraps. It is unexpected
2517 * at this stage because it should be the first record received
2518 * from the FCGI application.
2519 */
Christopher Faulet00d7cde2021-02-04 11:01:51 +01002520 b_slow_realign_ofs(dbuf, trash.area, 0);
Christopher Faulet99eff652019-08-11 23:11:30 +02002521 }
2522
2523 inbuf = b_make(b_head(dbuf), b_data(dbuf), 0, fconn->drl);
2524
Christopher Faulet73518be2021-01-27 12:06:54 +01002525 if (!fcgi_decode_end_request(&inbuf, 0, &endreq)) {
2526 TRACE_ERROR("END_REQUEST record decoding failure", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_FSTRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002527 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +01002528 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002529
2530 fstrm->flags |= FCGI_SF_ES_RCVD;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002531 TRACE_STATE("end of script reported", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_RX_EOI, fconn->conn, fstrm);
Willy Tarreau022e5e52020-09-10 09:33:15 +02002532 TRACE_PROTO("FCGI END_REQUEST record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm, 0, (size_t[]){fconn->drl});
Christopher Faulet99eff652019-08-11 23:11:30 +02002533 fstrm->proto_status = endreq.errcode;
2534 fcgi_strm_close(fstrm);
2535
2536 b_del(&fconn->dbuf, fconn->drl + fconn->drp);
2537 fconn->drl = 0;
2538 fconn->drp = 0;
2539 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002540 TRACE_STATE("switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn, fstrm);
2541 TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002542 return 1;
2543
2544 fail:
2545 fcgi_strm_error(fstrm);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002546 TRACE_DEVEL("leaving on error", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_FSTRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002547 return 0;
2548}
2549
2550/* process Rx records to be demultiplexed */
2551static void fcgi_process_demux(struct fcgi_conn *fconn)
2552{
2553 struct fcgi_strm *fstrm = NULL, *tmp_fstrm;
2554 struct fcgi_header hdr;
2555 int ret;
2556
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002557 TRACE_ENTER(FCGI_EV_FCONN_WAKE, fconn->conn);
2558
Christopher Faulet99eff652019-08-11 23:11:30 +02002559 if (fconn->state == FCGI_CS_CLOSED)
2560 return;
2561
2562 if (unlikely(fconn->state < FCGI_CS_RECORD_H)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002563 if (fconn->state == FCGI_CS_INIT) {
2564 TRACE_STATE("waiting FCGI GET_VALUES to be sent", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR|FCGI_EV_RX_GETVAL, fconn->conn);
2565 return;
2566 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002567 if (fconn->state == FCGI_CS_SETTINGS) {
2568 /* ensure that what is pending is a valid GET_VALUES_RESULT record. */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002569 TRACE_STATE("receiving FCGI record header", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002570 ret = fcgi_decode_record_hdr(&fconn->dbuf, 0, &hdr);
Christopher Faulet73518be2021-01-27 12:06:54 +01002571 if (!ret) {
2572 TRACE_ERROR("header record decoding failure", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_FSTRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002573 goto fail;
Christopher Faulet73518be2021-01-27 12:06:54 +01002574 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002575 b_del(&fconn->dbuf, ret);
2576
2577 if (hdr.id || (hdr.type != FCGI_GET_VALUES_RESULT && hdr.type != FCGI_UNKNOWN_TYPE)) {
2578 fconn->state = FCGI_CS_CLOSED;
Christopher Faulet73518be2021-01-27 12:06:54 +01002579 TRACE_ERROR("unexpected record type or flags", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR|FCGI_EV_RX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002580 TRACE_STATE("switching to CLOSED", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR|FCGI_EV_RX_GETVAL|FCGI_EV_FCONN_ERR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002581 goto fail;
2582 }
2583 goto new_record;
2584 }
2585 }
2586
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002587 /* process as many incoming records as possible below */
2588 while (1) {
2589 if (!b_data(&fconn->dbuf)) {
2590 TRACE_DEVEL("no more Rx data", FCGI_EV_RX_RECORD, fconn->conn);
2591 break;
2592 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002593
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002594 if (fconn->state == FCGI_CS_CLOSED) {
2595 TRACE_STATE("end of connection reported", FCGI_EV_RX_RECORD|FCGI_EV_RX_EOI, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002596 break;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002597 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002598
2599 if (fconn->state == FCGI_CS_RECORD_H) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002600 TRACE_PROTO("receiving FCGI record header", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002601 ret = fcgi_decode_record_hdr(&fconn->dbuf, 0, &hdr);
2602 if (!ret)
2603 break;
2604 b_del(&fconn->dbuf, ret);
2605
2606 new_record:
2607 fconn->dsi = hdr.id;
2608 fconn->drt = hdr.type;
2609 fconn->drl = hdr.len;
2610 fconn->drp = hdr.padding;
2611 fconn->state = FCGI_CS_RECORD_D;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002612 TRACE_STATE("FCGI record header rcvd, switching to RECORD_D", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002613 }
2614
2615 /* Only FCGI_CS_RECORD_D or FCGI_CS_RECORD_P */
2616 tmp_fstrm = fcgi_conn_st_by_id(fconn, fconn->dsi);
2617
2618 if (tmp_fstrm != fstrm && fstrm && fstrm->cs &&
2619 (b_data(&fstrm->rxbuf) ||
Christopher Faulet6670e3e2020-10-08 15:26:33 +02002620 fcgi_conn_read0_pending(fconn) ||
Christopher Faulet99eff652019-08-11 23:11:30 +02002621 fstrm->state == FCGI_SS_CLOSED ||
2622 (fstrm->flags & FCGI_SF_ES_RCVD) ||
2623 (fstrm->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
2624 /* we may have to signal the upper layers */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002625 TRACE_DEVEL("notifying stream before switching SID", FCGI_EV_RX_RECORD|FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002626 fstrm->cs->flags |= CS_FL_RCV_MORE;
2627 fcgi_strm_notify_recv(fstrm);
2628 }
2629 fstrm = tmp_fstrm;
2630
2631 if (fstrm->state == FCGI_SS_CLOSED && fconn->dsi != 0) {
2632 /* ignore all record for closed streams */
2633 goto ignore_record;
2634 }
2635 if (fstrm->state == FCGI_SS_IDLE) {
2636 /* ignore all record for unknown streams */
2637 goto ignore_record;
2638 }
2639
2640 switch (fconn->drt) {
2641 case FCGI_GET_VALUES_RESULT:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002642 TRACE_PROTO("receiving FCGI GET_VALUES_RESULT record", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002643 ret = fcgi_conn_handle_values_result(fconn);
2644 break;
2645
2646 case FCGI_STDOUT:
2647 if (fstrm->flags & FCGI_SF_ES_RCVD)
2648 goto ignore_record;
2649
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002650 TRACE_PROTO("receiving FCGI STDOUT record", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002651 if (fconn->drl)
2652 ret = fcgi_strm_handle_stdout(fconn, fstrm);
2653 else
2654 ret = fcgi_strm_handle_empty_stdout(fconn, fstrm);
2655 break;
2656
2657 case FCGI_STDERR:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002658 TRACE_PROTO("receiving FCGI STDERR record", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002659 ret = fcgi_strm_handle_stderr(fconn, fstrm);
2660 break;
2661
2662 case FCGI_END_REQUEST:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002663 TRACE_PROTO("receiving FCGI END_REQUEST record", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002664 ret = fcgi_strm_handle_end_request(fconn, fstrm);
2665 break;
2666
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002667 /* implement all extra record types here */
Christopher Faulet99eff652019-08-11 23:11:30 +02002668 default:
2669 ignore_record:
2670 /* drop records that we ignore. They may be
2671 * larger than the buffer so we drain all of
2672 * their contents until we reach the end.
2673 */
2674 fconn->state = FCGI_CS_RECORD_P;
2675 fconn->drl += fconn->drp;
2676 fconn->drp = 0;
2677 ret = MIN(b_data(&fconn->dbuf), fconn->drl);
Willy Tarreau022e5e52020-09-10 09:33:15 +02002678 TRACE_PROTO("receiving FCGI ignored record", FCGI_EV_RX_RECORD, fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002679 TRACE_STATE("switching to RECORD_P", FCGI_EV_RX_RECORD, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002680 b_del(&fconn->dbuf, ret);
2681 fconn->drl -= ret;
2682 ret = (fconn->drl == 0);
2683 }
2684
2685 /* error or missing data condition met above ? */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002686 if (ret <= 0) {
2687 TRACE_DEVEL("insufficient data to proceed", FCGI_EV_RX_RECORD, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002688 break;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002689 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002690
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002691 if (fconn->state != FCGI_CS_RECORD_H && !(fconn->drl+fconn->drp)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002692 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002693 TRACE_STATE("switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
2694 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002695 }
2696
2697 fail:
2698 /* we can go here on missing data, blocked response or error */
2699 if (fstrm && fstrm->cs &&
2700 (b_data(&fstrm->rxbuf) ||
Christopher Faulet6670e3e2020-10-08 15:26:33 +02002701 fcgi_conn_read0_pending(fconn) ||
Christopher Faulet99eff652019-08-11 23:11:30 +02002702 fstrm->state == FCGI_SS_CLOSED ||
2703 (fstrm->flags & FCGI_SF_ES_RCVD) ||
2704 (fstrm->cs->flags & (CS_FL_ERROR|CS_FL_ERR_PENDING|CS_FL_EOS)))) {
2705 /* we may have to signal the upper layers */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002706 TRACE_DEVEL("notifying stream before switching SID", FCGI_EV_RX_RECORD|FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02002707 fstrm->cs->flags |= CS_FL_RCV_MORE;
2708 fcgi_strm_notify_recv(fstrm);
2709 }
2710
2711 fcgi_conn_restart_reading(fconn, 0);
2712}
2713
2714/* process Tx records from streams to be multiplexed. Returns > 0 if it reached
2715 * the end.
2716 */
2717static int fcgi_process_mux(struct fcgi_conn *fconn)
2718{
2719 struct fcgi_strm *fstrm, *fstrm_back;
2720
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002721 TRACE_ENTER(FCGI_EV_FCONN_WAKE, fconn->conn);
2722
Christopher Faulet99eff652019-08-11 23:11:30 +02002723 if (unlikely(fconn->state < FCGI_CS_RECORD_H)) {
2724 if (unlikely(fconn->state == FCGI_CS_INIT)) {
2725 if (!(fconn->flags & FCGI_CF_GET_VALUES)) {
2726 fconn->state = FCGI_CS_RECORD_H;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002727 TRACE_STATE("switching to RECORD_H", FCGI_EV_TX_RECORD|FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002728 fcgi_wake_unassigned_streams(fconn);
2729 goto mux;
2730 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002731 TRACE_PROTO("sending FCGI GET_VALUES record", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002732 if (unlikely(!fcgi_conn_send_get_values(fconn)))
2733 goto fail;
2734 fconn->state = FCGI_CS_SETTINGS;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002735 TRACE_STATE("switching to SETTINGS", FCGI_EV_TX_RECORD|FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002736 }
2737 /* need to wait for the other side */
2738 if (fconn->state < FCGI_CS_RECORD_H)
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002739 goto done;
Christopher Faulet99eff652019-08-11 23:11:30 +02002740 }
2741
2742 mux:
2743 list_for_each_entry_safe(fstrm, fstrm_back, &fconn->send_list, send_list) {
2744 if (fconn->state == FCGI_CS_CLOSED || fconn->flags & FCGI_CF_MUX_BLOCK_ANY)
2745 break;
2746
Willy Tarreauf11be0e2020-01-16 16:59:45 +01002747 if (fstrm->flags & FCGI_SF_NOTIFIED)
Christopher Faulet99eff652019-08-11 23:11:30 +02002748 continue;
2749
Willy Tarreau7aad7032020-01-16 17:20:57 +01002750 /* If the sender changed his mind and unsubscribed, let's just
2751 * remove the stream from the send_list.
Christopher Faulet99eff652019-08-11 23:11:30 +02002752 */
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002753 if (!(fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW)) &&
2754 (!fstrm->subs || !(fstrm->subs->events & SUB_RETRY_SEND))) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002755 LIST_DEL_INIT(&fstrm->send_list);
2756 continue;
2757 }
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002758
2759 if (fstrm->subs && fstrm->subs->events & SUB_RETRY_SEND) {
Willy Tarreau7aad7032020-01-16 17:20:57 +01002760 TRACE_POINT(FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
2761 fstrm->flags &= ~FCGI_SF_BLK_ANY;
Willy Tarreau7aad7032020-01-16 17:20:57 +01002762 fstrm->flags |= FCGI_SF_NOTIFIED;
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002763 tasklet_wakeup(fstrm->subs->tasklet);
2764 fstrm->subs->events &= ~SUB_RETRY_SEND;
2765 if (!fstrm->subs->events)
2766 fstrm->subs = NULL;
Willy Tarreau7aad7032020-01-16 17:20:57 +01002767 } else {
2768 /* it's the shut request that was queued */
2769 TRACE_POINT(FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
2770 tasklet_wakeup(fstrm->shut_tl);
2771 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002772 }
2773
2774 fail:
2775 if (fconn->state == FCGI_CS_CLOSED) {
2776 if (fconn->stream_cnt - fconn->nb_reserved > 0) {
2777 fcgi_conn_send_aborts(fconn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002778 if (fconn->flags & FCGI_CF_MUX_BLOCK_ANY) {
2779 TRACE_DEVEL("leaving in blocked situation", FCGI_EV_FCONN_WAKE|FCGI_EV_FCONN_BLK, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002780 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002781 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002782 }
2783 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002784
2785 done:
2786 TRACE_LEAVE(FCGI_EV_FCONN_WAKE, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002787 return 1;
2788}
2789
2790
2791/* Attempt to read data, and subscribe if none available.
2792 * The function returns 1 if data has been received, otherwise zero.
2793 */
2794static int fcgi_recv(struct fcgi_conn *fconn)
2795{
2796 struct connection *conn = fconn->conn;
2797 struct buffer *buf;
2798 int max;
2799 size_t ret;
2800
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002801 TRACE_ENTER(FCGI_EV_FCONN_RECV, conn);
2802
2803 if (fconn->wait_event.events & SUB_RETRY_RECV) {
2804 TRACE_DEVEL("leaving on sub_recv", FCGI_EV_FCONN_RECV, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002805 return (b_data(&fconn->dbuf));
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002806 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002807
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002808 if (!fcgi_recv_allowed(fconn)) {
2809 TRACE_DEVEL("leaving on !recv_allowed", FCGI_EV_FCONN_RECV, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002810 return 1;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002811 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002812
2813 buf = fcgi_get_buf(fconn, &fconn->dbuf);
2814 if (!buf) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002815 TRACE_DEVEL("waiting for fconn dbuf allocation", FCGI_EV_FCONN_RECV|FCGI_EV_FCONN_BLK, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002816 fconn->flags |= FCGI_CF_DEM_DALLOC;
2817 return 0;
2818 }
2819
Christopher Faulet99eff652019-08-11 23:11:30 +02002820 if (!b_data(buf)) {
2821 /* try to pre-align the buffer like the
2822 * rxbufs will be to optimize memory copies. We'll make
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002823 * sure that the record header lands at the end of the
Christopher Faulet99eff652019-08-11 23:11:30 +02002824 * HTX block to alias it upon recv. We cannot use the
2825 * head because rcv_buf() will realign the buffer if
2826 * it's empty. Thus we cheat and pretend we already
2827 * have a few bytes there.
2828 */
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01002829 max = buf_room_for_htx_data(buf) + (fconn->state == FCGI_CS_RECORD_H ? FCGI_RECORD_HEADER_SZ : 0);
2830 buf->head = sizeof(struct htx) - (fconn->state == FCGI_CS_RECORD_H ? FCGI_RECORD_HEADER_SZ : 0);
Christopher Faulet99eff652019-08-11 23:11:30 +02002831 }
2832 else
2833 max = buf_room_for_htx_data(buf);
2834
2835 ret = max ? conn->xprt->rcv_buf(conn, conn->xprt_ctx, buf, max, 0) : 0;
2836
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002837 if (max && !ret && fcgi_recv_allowed(fconn)) {
2838 TRACE_DATA("failed to receive data, subscribing", FCGI_EV_FCONN_RECV, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002839 conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &fconn->wait_event);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002840 }
2841 else
Willy Tarreau022e5e52020-09-10 09:33:15 +02002842 TRACE_DATA("recv data", FCGI_EV_FCONN_RECV, conn, 0, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02002843
2844 if (!b_data(buf)) {
2845 fcgi_release_buf(fconn, &fconn->dbuf);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002846 TRACE_LEAVE(FCGI_EV_FCONN_RECV, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002847 return (conn->flags & CO_FL_ERROR || conn_xprt_read0_pending(conn));
2848 }
2849
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002850 if (ret == max) {
2851 TRACE_DEVEL("fconn dbuf full", FCGI_EV_FCONN_RECV|FCGI_EV_FCONN_BLK, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002852 fconn->flags |= FCGI_CF_DEM_DFULL;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002853 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002854
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002855 TRACE_LEAVE(FCGI_EV_FCONN_RECV, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002856 return !!ret || (conn->flags & CO_FL_ERROR) || conn_xprt_read0_pending(conn);
2857}
2858
2859
2860/* Try to send data if possible.
2861 * The function returns 1 if data have been sent, otherwise zero.
2862 */
2863static int fcgi_send(struct fcgi_conn *fconn)
2864{
2865 struct connection *conn = fconn->conn;
2866 int done;
2867 int sent = 0;
2868
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002869 TRACE_ENTER(FCGI_EV_FCONN_SEND, conn);
2870
2871 if (conn->flags & CO_FL_ERROR) {
2872 TRACE_DEVEL("leaving on connection error", FCGI_EV_FCONN_SEND, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002873 return 1;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002874 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002875
2876
Willy Tarreau911db9b2020-01-23 16:27:54 +01002877 if (conn->flags & CO_FL_WAIT_XPRT) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002878 /* a handshake was requested */
2879 goto schedule;
2880 }
2881
2882 /* This loop is quite simple : it tries to fill as much as it can from
2883 * pending streams into the existing buffer until it's reportedly full
2884 * or the end of send requests is reached. Then it tries to send this
2885 * buffer's contents out, marks it not full if at least one byte could
2886 * be sent, and tries again.
2887 *
2888 * The snd_buf() function normally takes a "flags" argument which may
2889 * be made of a combination of CO_SFL_MSG_MORE to indicate that more
2890 * data immediately comes and CO_SFL_STREAMER to indicate that the
2891 * connection is streaming lots of data (used to increase TLS record
2892 * size at the expense of latency). The former can be sent any time
2893 * there's a buffer full flag, as it indicates at least one stream
2894 * attempted to send and failed so there are pending data. An
2895 * alternative would be to set it as long as there's an active stream
2896 * but that would be problematic for ACKs until we have an absolute
2897 * guarantee that all waiters have at least one byte to send. The
2898 * latter should possibly not be set for now.
2899 */
2900
2901 done = 0;
2902 while (!done) {
2903 unsigned int flags = 0;
2904 unsigned int released = 0;
2905 struct buffer *buf;
2906
2907 /* fill as much as we can into the current buffer */
2908 while (((fconn->flags & (FCGI_CF_MUX_MFULL|FCGI_CF_MUX_MALLOC)) == 0) && !done)
2909 done = fcgi_process_mux(fconn);
2910
2911 if (fconn->flags & FCGI_CF_MUX_MALLOC)
2912 done = 1; // we won't go further without extra buffers
2913
2914 if (conn->flags & CO_FL_ERROR)
2915 break;
2916
2917 if (fconn->flags & (FCGI_CF_MUX_MFULL | FCGI_CF_DEM_MROOM))
2918 flags |= CO_SFL_MSG_MORE;
2919
2920 for (buf = br_head(fconn->mbuf); b_size(buf); buf = br_del_head(fconn->mbuf)) {
2921 if (b_data(buf)) {
2922 int ret;
2923
2924 ret = conn->xprt->snd_buf(conn, conn->xprt_ctx, buf, b_data(buf), flags);
2925 if (!ret) {
2926 done = 1;
2927 break;
2928 }
2929 sent = 1;
Willy Tarreau022e5e52020-09-10 09:33:15 +02002930 TRACE_DATA("send data", FCGI_EV_FCONN_SEND, conn, 0, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02002931 b_del(buf, ret);
2932 if (b_data(buf)) {
2933 done = 1;
2934 break;
2935 }
2936 }
2937 b_free(buf);
2938 released++;
2939 }
2940
2941 if (released)
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01002942 offer_buffers(NULL, released);
Christopher Faulet99eff652019-08-11 23:11:30 +02002943
2944 /* wrote at least one byte, the buffer is not full anymore */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002945 if (fconn->flags & (FCGI_CF_MUX_MFULL | FCGI_CF_DEM_MROOM))
2946 TRACE_STATE("fconn mbuf ring not fill anymore", FCGI_EV_FCONN_SEND|FCGI_EV_FCONN_BLK, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002947 fconn->flags &= ~(FCGI_CF_MUX_MFULL | FCGI_CF_DEM_MROOM);
2948 }
2949
2950 if (conn->flags & CO_FL_SOCK_WR_SH) {
2951 /* output closed, nothing to send, clear the buffer to release it */
2952 b_reset(br_tail(fconn->mbuf));
2953 }
2954 /* We're not full anymore, so we can wake any task that are waiting
2955 * for us.
2956 */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002957 if (!(fconn->flags & (FCGI_CF_MUX_MFULL | FCGI_CF_DEM_MROOM)) && fconn->state >= FCGI_CS_RECORD_H) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002958 struct fcgi_strm *fstrm;
2959
2960 list_for_each_entry(fstrm, &fconn->send_list, send_list) {
2961 if (fconn->state == FCGI_CS_CLOSED || fconn->flags & FCGI_CF_MUX_BLOCK_ANY)
2962 break;
2963
Willy Tarreauf11be0e2020-01-16 16:59:45 +01002964 if (fstrm->flags & FCGI_SF_NOTIFIED)
Christopher Faulet99eff652019-08-11 23:11:30 +02002965 continue;
2966
Willy Tarreau7aad7032020-01-16 17:20:57 +01002967 /* If the sender changed his mind and unsubscribed, let's just
2968 * remove the stream from the send_list.
Christopher Faulet99eff652019-08-11 23:11:30 +02002969 */
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002970 if (!(fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW)) &&
2971 (!fstrm->subs || !(fstrm->subs->events & SUB_RETRY_SEND))) {
Christopher Faulet99eff652019-08-11 23:11:30 +02002972 LIST_DEL_INIT(&fstrm->send_list);
2973 continue;
2974 }
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002975
2976 if (fstrm->subs && fstrm->subs->events & SUB_RETRY_SEND) {
Willy Tarreau7aad7032020-01-16 17:20:57 +01002977 TRACE_DEVEL("waking up pending stream", FCGI_EV_FCONN_SEND|FCGI_EV_STRM_WAKE, conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002978 fstrm->flags &= ~FCGI_SF_BLK_ANY;
Willy Tarreau7aad7032020-01-16 17:20:57 +01002979 fstrm->flags |= FCGI_SF_NOTIFIED;
Willy Tarreau8907e4d2020-01-16 17:55:37 +01002980 tasklet_wakeup(fstrm->subs->tasklet);
2981 fstrm->subs->events &= ~SUB_RETRY_SEND;
2982 if (!fstrm->subs->events)
2983 fstrm->subs = NULL;
Willy Tarreau7aad7032020-01-16 17:20:57 +01002984 } else {
2985 /* it's the shut request that was queued */
2986 TRACE_POINT(FCGI_EV_STRM_WAKE, fconn->conn, fstrm);
2987 tasklet_wakeup(fstrm->shut_tl);
2988 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002989 }
2990 }
2991 /* We're done, no more to send */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002992 if (!br_data(fconn->mbuf)) {
2993 TRACE_DEVEL("leaving with everything sent", FCGI_EV_FCONN_SEND, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002994 return sent;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002995 }
Christopher Faulet99eff652019-08-11 23:11:30 +02002996schedule:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02002997 if (!(conn->flags & CO_FL_ERROR) && !(fconn->wait_event.events & SUB_RETRY_SEND)) {
2998 TRACE_STATE("more data to send, subscribing", FCGI_EV_FCONN_SEND, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02002999 conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_SEND, &fconn->wait_event);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003000 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003001
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003002 TRACE_DEVEL("leaving with some data left to send", FCGI_EV_FCONN_SEND, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003003 return sent;
3004}
3005
3006/* this is the tasklet referenced in fconn->wait_event.tasklet */
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003007struct task *fcgi_io_cb(struct task *t, void *ctx, unsigned int state)
Christopher Faulet99eff652019-08-11 23:11:30 +02003008{
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003009 struct connection *conn;
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003010 struct fcgi_conn *fconn = ctx;
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003011 struct tasklet *tl = (struct tasklet *)t;
3012 int conn_in_list;
Christopher Faulet99eff652019-08-11 23:11:30 +02003013 int ret = 0;
3014
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003015 if (state & TASK_F_USR1) {
3016 /* the tasklet was idling on an idle connection, it might have
3017 * been stolen, let's be careful!
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003018 */
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003019 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
3020 if (tl->context == NULL) {
3021 /* The connection has been taken over by another thread,
3022 * we're no longer responsible for it, so just free the
3023 * tasklet, and do nothing.
3024 */
3025 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
3026 tasklet_free(tl);
3027 return NULL;
3028 }
3029 conn = fconn->conn;
3030 TRACE_POINT(FCGI_EV_FCONN_WAKE, conn);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003031
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003032 conn_in_list = conn->flags & CO_FL_LIST_MASK;
3033 if (conn_in_list)
3034 conn_delete_from_tree(&conn->hash_node->node);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003035
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003036 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
3037 } else {
3038 /* we're certain the connection was not in an idle list */
3039 conn = fconn->conn;
3040 TRACE_ENTER(FCGI_EV_FCONN_WAKE, conn);
3041 conn_in_list = 0;
3042 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003043
Christopher Faulet99eff652019-08-11 23:11:30 +02003044 if (!(fconn->wait_event.events & SUB_RETRY_SEND))
3045 ret = fcgi_send(fconn);
3046 if (!(fconn->wait_event.events & SUB_RETRY_RECV))
3047 ret |= fcgi_recv(fconn);
3048 if (ret || b_data(&fconn->dbuf))
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003049 ret = fcgi_process(fconn);
3050
3051 /* If we were in an idle list, we want to add it back into it,
3052 * unless fcgi_process() returned -1, which mean it has destroyed
3053 * the connection (testing !ret is enough, if fcgi_process() wasn't
3054 * called then ret will be 0 anyway.
3055 */
Willy Tarreau74163142021-03-13 11:30:19 +01003056 if (ret < 0)
3057 t = NULL;
3058
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003059 if (!ret && conn_in_list) {
3060 struct server *srv = objt_server(conn->target);
3061
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003062 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003063 if (conn_in_list == CO_FL_SAFE_LIST)
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003064 ebmb_insert(&srv->per_thr[tid].safe_conns, &conn->hash_node->node, sizeof(conn->hash_node->hash));
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003065 else
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003066 ebmb_insert(&srv->per_thr[tid].idle_conns, &conn->hash_node->node, sizeof(conn->hash_node->hash));
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003067 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003068 }
Willy Tarreau74163142021-03-13 11:30:19 +01003069 return t;
Christopher Faulet99eff652019-08-11 23:11:30 +02003070}
3071
3072/* callback called on any event by the connection handler.
3073 * It applies changes and returns zero, or < 0 if it wants immediate
3074 * destruction of the connection (which normally doesn not happen in FCGI).
3075 */
3076static int fcgi_process(struct fcgi_conn *fconn)
3077{
3078 struct connection *conn = fconn->conn;
3079
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003080 TRACE_POINT(FCGI_EV_FCONN_WAKE, conn);
3081
Christopher Faulet99eff652019-08-11 23:11:30 +02003082 if (b_data(&fconn->dbuf) && !(fconn->flags & FCGI_CF_DEM_BLOCK_ANY)) {
3083 fcgi_process_demux(fconn);
3084
3085 if (fconn->state == FCGI_CS_CLOSED || conn->flags & CO_FL_ERROR)
3086 b_reset(&fconn->dbuf);
3087
3088 if (buf_room_for_htx_data(&fconn->dbuf))
3089 fconn->flags &= ~FCGI_CF_DEM_DFULL;
3090 }
3091 fcgi_send(fconn);
3092
Christopher Fauletdfd10ab2021-10-06 14:24:19 +02003093 if (unlikely(fconn->proxy->flags & (PR_FL_DISABLED|PR_FL_STOPPED))) {
Christopher Faulet99eff652019-08-11 23:11:30 +02003094 /* frontend is stopping, reload likely in progress, let's try
3095 * to announce a graceful shutdown if not yet done. We don't
3096 * care if it fails, it will be tried again later.
3097 */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003098 TRACE_STATE("proxy stopped, sending ABORT to all streams", FCGI_EV_FCONN_WAKE|FCGI_EV_TX_RECORD, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003099 if (!(fconn->flags & (FCGI_CF_ABRTS_SENT|FCGI_CF_ABRTS_FAILED))) {
3100 if (fconn->stream_cnt - fconn->nb_reserved > 0)
3101 fcgi_conn_send_aborts(fconn);
3102 }
3103 }
3104
3105 /*
3106 * If we received early data, and the handshake is done, wake
3107 * any stream that was waiting for it.
3108 */
3109 if (!(fconn->flags & FCGI_CF_WAIT_FOR_HS) &&
Willy Tarreau911db9b2020-01-23 16:27:54 +01003110 (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_WAIT_XPRT | CO_FL_EARLY_DATA)) == CO_FL_EARLY_DATA) {
Christopher Faulet99eff652019-08-11 23:11:30 +02003111 struct eb32_node *node;
3112 struct fcgi_strm *fstrm;
3113
3114 fconn->flags |= FCGI_CF_WAIT_FOR_HS;
3115 node = eb32_lookup_ge(&fconn->streams_by_id, 1);
3116
3117 while (node) {
3118 fstrm = container_of(node, struct fcgi_strm, by_id);
3119 if (fstrm->cs && fstrm->cs->flags & CS_FL_WAIT_FOR_HS)
3120 fcgi_strm_notify_recv(fstrm);
3121 node = eb32_next(node);
3122 }
3123 }
3124
Christopher Faulet6670e3e2020-10-08 15:26:33 +02003125 if ((conn->flags & CO_FL_ERROR) || fcgi_conn_read0_pending(fconn) ||
Christopher Faulet99eff652019-08-11 23:11:30 +02003126 fconn->state == FCGI_CS_CLOSED || (fconn->flags & FCGI_CF_ABRTS_FAILED) ||
3127 eb_is_empty(&fconn->streams_by_id)) {
3128 fcgi_wake_some_streams(fconn, 0);
3129
3130 if (eb_is_empty(&fconn->streams_by_id)) {
3131 /* no more stream, kill the connection now */
3132 fcgi_release(fconn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003133 TRACE_DEVEL("leaving after releasing the connection", FCGI_EV_FCONN_WAKE);
Christopher Faulet99eff652019-08-11 23:11:30 +02003134 return -1;
3135 }
3136 }
3137
3138 if (!b_data(&fconn->dbuf))
3139 fcgi_release_buf(fconn, &fconn->dbuf);
3140
3141 if ((conn->flags & CO_FL_SOCK_WR_SH) ||
3142 fconn->state == FCGI_CS_CLOSED || (fconn->flags & FCGI_CF_ABRTS_FAILED) ||
3143 (!br_data(fconn->mbuf) && ((fconn->flags & FCGI_CF_MUX_BLOCK_ANY) || LIST_ISEMPTY(&fconn->send_list))))
3144 fcgi_release_mbuf(fconn);
3145
3146 if (fconn->task) {
3147 fconn->task->expire = tick_add(now_ms, (fconn->state == FCGI_CS_CLOSED ? fconn->shut_timeout : fconn->timeout));
3148 task_queue(fconn->task);
3149 }
3150
3151 fcgi_send(fconn);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003152 TRACE_LEAVE(FCGI_EV_FCONN_WAKE, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003153 return 0;
3154}
3155
3156
3157/* wake-up function called by the connection layer (mux_ops.wake) */
3158static int fcgi_wake(struct connection *conn)
3159{
3160 struct fcgi_conn *fconn = conn->ctx;
3161
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003162 TRACE_POINT(FCGI_EV_FCONN_WAKE, conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003163 return (fcgi_process(fconn));
3164}
3165
Olivier Houchard9b8e11e2019-10-25 16:19:26 +02003166
3167static int fcgi_ctl(struct connection *conn, enum mux_ctl_type mux_ctl, void *output)
3168{
3169 int ret = 0;
3170 switch (mux_ctl) {
3171 case MUX_STATUS:
Willy Tarreau911db9b2020-01-23 16:27:54 +01003172 if (!(conn->flags & CO_FL_WAIT_XPRT))
Olivier Houchard9b8e11e2019-10-25 16:19:26 +02003173 ret |= MUX_STATUS_READY;
3174 return ret;
Christopher Faulet4c8ad842020-10-06 14:59:17 +02003175 case MUX_EXIT_STATUS:
3176 return MUX_ES_UNKNOWN;
Olivier Houchard9b8e11e2019-10-25 16:19:26 +02003177 default:
3178 return -1;
3179 }
3180}
3181
Christopher Faulet99eff652019-08-11 23:11:30 +02003182/* Connection timeout management. The principle is that if there's no receipt
3183 * nor sending for a certain amount of time, the connection is closed. If the
3184 * MUX buffer still has lying data or is not allocatable, the connection is
3185 * immediately killed. If it's allocatable and empty, we attempt to send a
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003186 * ABORT records.
Christopher Faulet99eff652019-08-11 23:11:30 +02003187 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01003188struct task *fcgi_timeout_task(struct task *t, void *context, unsigned int state)
Christopher Faulet99eff652019-08-11 23:11:30 +02003189{
3190 struct fcgi_conn *fconn = context;
3191 int expired = tick_is_expired(t->expire, now_ms);
3192
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003193 TRACE_ENTER(FCGI_EV_FCONN_WAKE, (fconn ? fconn->conn : NULL));
3194
Willy Tarreau60814ff2020-06-30 11:19:23 +02003195 if (fconn) {
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003196 HA_SPIN_LOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Olivier Houchard48ce6a32020-07-02 11:58:05 +02003197
3198 /* Somebody already stole the connection from us, so we should not
3199 * free it, we just have to free the task.
3200 */
3201 if (!t->context) {
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003202 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Olivier Houchard48ce6a32020-07-02 11:58:05 +02003203 fconn = NULL;
3204 goto do_leave;
3205 }
3206
Willy Tarreau60814ff2020-06-30 11:19:23 +02003207 if (!expired) {
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003208 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Willy Tarreau60814ff2020-06-30 11:19:23 +02003209 TRACE_DEVEL("leaving (not expired)", FCGI_EV_FCONN_WAKE, fconn->conn);
3210 return t;
3211 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003212
Willy Tarreau60814ff2020-06-30 11:19:23 +02003213 /* We're about to destroy the connection, so make sure nobody attempts
3214 * to steal it from us.
3215 */
Willy Tarreau60814ff2020-06-30 11:19:23 +02003216 if (fconn->conn->flags & CO_FL_LIST_MASK)
Amaury Denoyelle8990b012021-02-19 15:29:16 +01003217 conn_delete_from_tree(&fconn->conn->hash_node->node);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003218
Amaury Denoyelle5c7086f2021-01-11 09:21:52 +01003219 HA_SPIN_UNLOCK(IDLE_CONNS_LOCK, &idle_conns[tid].idle_conns_lock);
Willy Tarreau60814ff2020-06-30 11:19:23 +02003220 }
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01003221
Olivier Houchard48ce6a32020-07-02 11:58:05 +02003222do_leave:
Christopher Faulet99eff652019-08-11 23:11:30 +02003223 task_destroy(t);
3224
3225 if (!fconn) {
3226 /* resources were already deleted */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003227 TRACE_DEVEL("leaving (not more fconn)", FCGI_EV_FCONN_WAKE);
Christopher Faulet99eff652019-08-11 23:11:30 +02003228 return NULL;
3229 }
3230
3231 fconn->task = NULL;
3232 fconn->state = FCGI_CS_CLOSED;
3233 fcgi_wake_some_streams(fconn, 0);
3234
3235 if (br_data(fconn->mbuf)) {
3236 /* don't even try to send aborts, the buffer is stuck */
3237 fconn->flags |= FCGI_CF_ABRTS_FAILED;
3238 goto end;
3239 }
3240
3241 /* try to send but no need to insist */
3242 if (!fcgi_conn_send_aborts(fconn))
3243 fconn->flags |= FCGI_CF_ABRTS_FAILED;
3244
3245 if (br_data(fconn->mbuf) && !(fconn->flags & FCGI_CF_ABRTS_FAILED) &&
3246 conn_xprt_ready(fconn->conn)) {
3247 unsigned int released = 0;
3248 struct buffer *buf;
3249
3250 for (buf = br_head(fconn->mbuf); b_size(buf); buf = br_del_head(fconn->mbuf)) {
3251 if (b_data(buf)) {
3252 int ret = fconn->conn->xprt->snd_buf(fconn->conn, fconn->conn->xprt_ctx,
3253 buf, b_data(buf), 0);
3254 if (!ret)
3255 break;
3256 b_del(buf, ret);
3257 if (b_data(buf))
3258 break;
3259 b_free(buf);
3260 released++;
3261 }
3262 }
3263
3264 if (released)
Willy Tarreau4d77bbf2021-02-20 12:02:46 +01003265 offer_buffers(NULL, released);
Christopher Faulet99eff652019-08-11 23:11:30 +02003266 }
3267
3268 end:
3269 /* either we can release everything now or it will be done later once
3270 * the last stream closes.
3271 */
3272 if (eb_is_empty(&fconn->streams_by_id))
3273 fcgi_release(fconn);
3274
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003275 TRACE_LEAVE(FCGI_EV_FCONN_WAKE);
Christopher Faulet99eff652019-08-11 23:11:30 +02003276 return NULL;
3277}
3278
3279
3280/*******************************************/
3281/* functions below are used by the streams */
3282/*******************************************/
3283
3284/* Append the description of what is present in error snapshot <es> into <out>.
3285 * The description must be small enough to always fit in a buffer. The output
3286 * buffer may be the trash so the trash must not be used inside this function.
3287 */
3288static void fcgi_show_error_snapshot(struct buffer *out, const struct error_snapshot *es)
3289{
3290 chunk_appendf(out,
3291 " FCGI connection flags 0x%08x, FCGI stream flags 0x%08x\n"
3292 " H1 msg state %s(%d), H1 msg flags 0x%08x\n"
3293 " H1 chunk len %lld bytes, H1 body len %lld bytes :\n",
3294 es->ctx.h1.c_flags, es->ctx.h1.s_flags,
3295 h1m_state_str(es->ctx.h1.state), es->ctx.h1.state,
3296 es->ctx.h1.m_flags, es->ctx.h1.m_clen, es->ctx.h1.m_blen);
3297}
3298/*
3299 * Capture a bad response and archive it in the proxy's structure. By default
3300 * it tries to report the error position as h1m->err_pos. However if this one is
3301 * not set, it will then report h1m->next, which is the last known parsing
3302 * point. The function is able to deal with wrapping buffers. It always displays
3303 * buffers as a contiguous area starting at buf->p. The direction is determined
3304 * thanks to the h1m's flags.
3305 */
3306static void fcgi_strm_capture_bad_message(struct fcgi_conn *fconn, struct fcgi_strm *fstrm,
3307 struct h1m *h1m, struct buffer *buf)
3308{
3309 struct session *sess = fstrm->sess;
3310 struct proxy *proxy = fconn->proxy;
Olivier Houchardbdb00c52020-03-12 15:30:17 +01003311 struct proxy *other_end;
Christopher Faulet99eff652019-08-11 23:11:30 +02003312 union error_snapshot_ctx ctx;
3313
Olivier Houchardbdb00c52020-03-12 15:30:17 +01003314 if (fstrm->cs && fstrm->cs->data) {
3315 if (sess == NULL)
3316 sess = si_strm(fstrm->cs->data)->sess;
3317 if (!(h1m->flags & H1_MF_RESP))
3318 other_end = si_strm(fstrm->cs->data)->be;
3319 else
3320 other_end = sess->fe;
3321 } else
3322 other_end = NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +02003323 /* http-specific part now */
3324 ctx.h1.state = h1m->state;
3325 ctx.h1.c_flags = fconn->flags;
3326 ctx.h1.s_flags = fstrm->flags;
3327 ctx.h1.m_flags = h1m->flags;
3328 ctx.h1.m_clen = h1m->curr_len;
3329 ctx.h1.m_blen = h1m->body_len;
3330
3331 proxy_capture_error(proxy, 1, other_end, fconn->conn->target, sess, buf, 0, 0,
3332 (h1m->err_pos >= 0) ? h1m->err_pos : h1m->next,
3333 &ctx, fcgi_show_error_snapshot);
3334}
3335
3336static size_t fcgi_strm_parse_headers(struct fcgi_strm *fstrm, struct h1m *h1m, struct htx *htx,
3337 struct buffer *buf, size_t *ofs, size_t max)
3338{
Christopher Fauletde471a42021-02-01 16:37:28 +01003339 size_t ret;
Christopher Faulet99eff652019-08-11 23:11:30 +02003340
Willy Tarreau022e5e52020-09-10 09:33:15 +02003341 TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
Christopher Faulet99eff652019-08-11 23:11:30 +02003342 ret = h1_parse_msg_hdrs(h1m, NULL, htx, buf, *ofs, max);
3343 if (!ret) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003344 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003345 if (htx->flags & HTX_FL_PARSING_ERROR) {
Christopher Faulet73518be2021-01-27 12:06:54 +01003346 TRACE_ERROR("parsing error, reject H1 response", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS|FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003347 fcgi_strm_error(fstrm);
3348 fcgi_strm_capture_bad_message(fstrm->fconn, fstrm, h1m, buf);
3349 }
3350 goto end;
3351 }
3352
Christopher Fauletda3adeb2021-09-28 09:50:07 +02003353 /* Reject any message with an unknown transfer-encoding. In fact if any
3354 * encoding other than "chunked". A 422-Unprocessable-Content is
3355 * returned for an invalid request, a 502-Bad-Gateway for an invalid
3356 * response.
3357 */
3358 if (h1m->flags & H1_MF_TE_OTHER) {
3359 htx->flags |= HTX_FL_PARSING_ERROR;
3360 TRACE_ERROR("Unknown transfer-encoding", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS|FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
3361 fcgi_strm_error(fstrm);
3362 fcgi_strm_capture_bad_message(fstrm->fconn, fstrm, h1m, buf);
3363 ret = 0;
3364 goto end;
3365 }
3366
Christopher Faulet99eff652019-08-11 23:11:30 +02003367 *ofs += ret;
3368 end:
Willy Tarreau022e5e52020-09-10 09:33:15 +02003369 TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02003370 return ret;
3371
3372}
3373
Christopher Fauletaf542632019-10-01 21:52:49 +02003374static size_t fcgi_strm_parse_data(struct fcgi_strm *fstrm, struct h1m *h1m, struct htx **htx,
Christopher Faulet99eff652019-08-11 23:11:30 +02003375 struct buffer *buf, size_t *ofs, size_t max, struct buffer *htxbuf)
3376{
Christopher Fauletde471a42021-02-01 16:37:28 +01003377 size_t ret;
Christopher Faulet99eff652019-08-11 23:11:30 +02003378
Willy Tarreau022e5e52020-09-10 09:33:15 +02003379 TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
Christopher Faulet99eff652019-08-11 23:11:30 +02003380 ret = h1_parse_msg_data(h1m, htx, buf, *ofs, max, htxbuf);
Christopher Faulet76014fd2019-12-10 11:47:22 +01003381 if (!ret) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003382 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm);
Christopher Fauletaf542632019-10-01 21:52:49 +02003383 if ((*htx)->flags & HTX_FL_PARSING_ERROR) {
Christopher Faulet73518be2021-01-27 12:06:54 +01003384 TRACE_ERROR("parsing error, reject H1 response", FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY|FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003385 fcgi_strm_error(fstrm);
3386 fcgi_strm_capture_bad_message(fstrm->fconn, fstrm, h1m, buf);
3387 }
3388 goto end;
3389 }
3390 *ofs += ret;
3391 end:
Willy Tarreau022e5e52020-09-10 09:33:15 +02003392 TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02003393 return ret;
3394}
3395
3396static size_t fcgi_strm_parse_trailers(struct fcgi_strm *fstrm, struct h1m *h1m, struct htx *htx,
3397 struct buffer *buf, size_t *ofs, size_t max)
3398{
Christopher Fauletde471a42021-02-01 16:37:28 +01003399 size_t ret;
Christopher Faulet99eff652019-08-11 23:11:30 +02003400
Willy Tarreau022e5e52020-09-10 09:33:15 +02003401 TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
Christopher Faulet99eff652019-08-11 23:11:30 +02003402 ret = h1_parse_msg_tlrs(h1m, htx, buf, *ofs, max);
Christopher Faulet76014fd2019-12-10 11:47:22 +01003403 if (!ret) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003404 TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003405 if (htx->flags & HTX_FL_PARSING_ERROR) {
Christopher Faulet73518be2021-01-27 12:06:54 +01003406 TRACE_ERROR("parsing error, reject H1 response", FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS|FCGI_EV_FSTRM_ERR, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003407 fcgi_strm_error(fstrm);
3408 fcgi_strm_capture_bad_message(fstrm->fconn, fstrm, h1m, buf);
3409 }
3410 goto end;
3411 }
3412 *ofs += ret;
Christopher Faulet99eff652019-08-11 23:11:30 +02003413 end:
Willy Tarreau022e5e52020-09-10 09:33:15 +02003414 TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02003415 return ret;
3416}
3417
Christopher Faulet99eff652019-08-11 23:11:30 +02003418static size_t fcgi_strm_parse_response(struct fcgi_strm *fstrm, struct buffer *buf, size_t count)
3419{
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003420 struct fcgi_conn *fconn = fstrm->fconn;
Christopher Faulet99eff652019-08-11 23:11:30 +02003421 struct htx *htx;
3422 struct h1m *h1m = &fstrm->h1m;
3423 size_t ret, data, total = 0;
3424
3425 htx = htx_from_buf(buf);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003426 TRACE_ENTER(FCGI_EV_RSP_DATA, fconn->conn, fstrm, htx, (size_t[]){count});
3427
Christopher Faulet99eff652019-08-11 23:11:30 +02003428 data = htx->data;
3429 if (fstrm->state == FCGI_SS_ERROR)
3430 goto end;
3431
3432 do {
3433 size_t used = htx_used_space(htx);
3434
3435 if (h1m->state <= H1_MSG_LAST_LF) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003436 TRACE_PROTO("parsing response headers", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003437 ret = fcgi_strm_parse_headers(fstrm, h1m, htx, &fstrm->rxbuf, &total, count);
3438 if (!ret)
3439 break;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003440
3441 TRACE_USER("rcvd H1 response headers", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fconn->conn, fstrm, htx);
3442
Christopher Faulet99eff652019-08-11 23:11:30 +02003443 if ((h1m->flags & (H1_MF_VER_11|H1_MF_XFER_LEN)) == H1_MF_VER_11) {
3444 struct htx_blk *blk = htx_get_head_blk(htx);
3445 struct htx_sl *sl;
3446
3447 if (!blk)
3448 break;
3449 sl = htx_get_blk_ptr(htx, blk);
3450 sl->flags |= HTX_SL_F_XFER_LEN;
3451 htx->extra = 0;
3452 }
3453 }
3454 else if (h1m->state < H1_MSG_TRAILERS) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003455 TRACE_PROTO("parsing response payload", FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fconn->conn, fstrm);
Christopher Fauletbf774302021-06-02 12:04:40 +02003456 fcgi_strm_parse_data(fstrm, h1m, &htx, &fstrm->rxbuf, &total, count, buf);
Christopher Faulet1e857782020-12-08 10:38:22 +01003457
3458 if (!(h1m->flags & H1_MF_XFER_LEN) && fstrm->state != FCGI_SS_ERROR &&
3459 (fstrm->flags & FCGI_SF_ES_RCVD) && b_data(&fstrm->rxbuf) == total) {
3460 TRACE_DEVEL("end of data", FCGI_EV_RSP_DATA, fconn->conn, fstrm);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01003461 htx->flags |= HTX_FL_EOM;
Christopher Faulet1e857782020-12-08 10:38:22 +01003462 h1m->state = H1_MSG_DONE;
3463 TRACE_USER("H1 response fully rcvd", FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fconn->conn, fstrm, htx);
3464 }
3465
Christopher Faulet16a524c2021-02-02 21:16:03 +01003466 if (h1m->state < H1_MSG_TRAILERS)
Christopher Faulet99eff652019-08-11 23:11:30 +02003467 break;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003468
3469 TRACE_PROTO("rcvd response payload data", FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fconn->conn, fstrm, htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02003470 }
3471 else if (h1m->state == H1_MSG_TRAILERS) {
Christopher Faulet76014fd2019-12-10 11:47:22 +01003472 TRACE_PROTO("parsing response trailers", FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fconn->conn, fstrm);
Christopher Fauletbf774302021-06-02 12:04:40 +02003473 fcgi_strm_parse_trailers(fstrm, h1m, htx, &fstrm->rxbuf, &total, count);
Christopher Faulet16a524c2021-02-02 21:16:03 +01003474 if (h1m->state != H1_MSG_DONE)
Christopher Faulet99eff652019-08-11 23:11:30 +02003475 break;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003476
Christopher Faulet76014fd2019-12-10 11:47:22 +01003477 TRACE_PROTO("rcvd H1 response trailers", FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fconn->conn, fstrm, htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02003478 }
3479 else if (h1m->state == H1_MSG_DONE) {
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01003480 TRACE_USER("H1 response fully rcvd", FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fconn->conn, fstrm, htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02003481 if (b_data(&fstrm->rxbuf) > total) {
3482 htx->flags |= HTX_FL_PARSING_ERROR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003483 TRACE_PROTO("too much data, parsing error", FCGI_EV_RSP_DATA, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003484 fcgi_strm_error(fstrm);
3485 }
3486 break;
3487 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003488 else {
3489 htx->flags |= HTX_FL_PROCESSING_ERROR;
Christopher Faulet73518be2021-01-27 12:06:54 +01003490 TRACE_ERROR("unexpected processing error", FCGI_EV_RSP_DATA|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003491 fcgi_strm_error(fstrm);
3492 break;
3493 }
3494
3495 count -= htx_used_space(htx) - used;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003496 } while (fstrm->state != FCGI_SS_ERROR);
Christopher Faulet99eff652019-08-11 23:11:30 +02003497
3498 if (fstrm->state == FCGI_SS_ERROR) {
3499 b_reset(&fstrm->rxbuf);
3500 htx_to_buf(htx, buf);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003501 TRACE_DEVEL("leaving on error", FCGI_EV_RSP_DATA|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003502 return 0;
3503 }
3504
3505 b_del(&fstrm->rxbuf, total);
3506
3507 end:
3508 htx_to_buf(htx, buf);
3509 ret = htx->data - data;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003510 TRACE_LEAVE(FCGI_EV_RSP_DATA, fconn->conn, fstrm, htx, (size_t[]){ret});
Christopher Faulet99eff652019-08-11 23:11:30 +02003511 return ret;
3512}
3513
3514/*
3515 * Attach a new stream to a connection
3516 * (Used for outgoing connections)
3517 */
3518static struct conn_stream *fcgi_attach(struct connection *conn, struct session *sess)
3519{
3520 struct conn_stream *cs;
3521 struct fcgi_strm *fstrm;
3522 struct fcgi_conn *fconn = conn->ctx;
3523
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003524 TRACE_ENTER(FCGI_EV_FSTRM_NEW, conn);
Christopher Faulet236c93b2020-07-02 09:19:54 +02003525 cs = cs_new(conn, conn->target);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003526 if (!cs) {
Christopher Faulet73518be2021-01-27 12:06:54 +01003527 TRACE_ERROR("CS allocation failure", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR, conn);
3528 goto err;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003529 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003530 fstrm = fcgi_conn_stream_new(fconn, cs, sess);
3531 if (!fstrm) {
3532 cs_free(cs);
Christopher Faulet73518be2021-01-27 12:06:54 +01003533 goto err;
Christopher Faulet99eff652019-08-11 23:11:30 +02003534 }
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003535
3536 /* the connection is not idle anymore, let's mark this */
3537 HA_ATOMIC_AND(&fconn->wait_event.tasklet->state, ~TASK_F_USR1);
Willy Tarreau4f8cd432021-03-02 17:27:58 +01003538 xprt_set_used(conn, conn->xprt, conn->xprt_ctx);
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003539
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003540 TRACE_LEAVE(FCGI_EV_FSTRM_NEW, conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003541 return cs;
Christopher Faulet73518be2021-01-27 12:06:54 +01003542
3543 err:
3544 TRACE_DEVEL("leaving on error", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR, conn);
3545 return NULL;
Christopher Faulet99eff652019-08-11 23:11:30 +02003546}
3547
3548/* Retrieves the first valid conn_stream from this connection, or returns NULL.
3549 * We have to scan because we may have some orphan streams. It might be
3550 * beneficial to scan backwards from the end to reduce the likeliness to find
3551 * orphans.
3552 */
3553static const struct conn_stream *fcgi_get_first_cs(const struct connection *conn)
3554{
3555 struct fcgi_conn *fconn = conn->ctx;
3556 struct fcgi_strm *fstrm;
3557 struct eb32_node *node;
3558
3559 node = eb32_first(&fconn->streams_by_id);
3560 while (node) {
3561 fstrm = container_of(node, struct fcgi_strm, by_id);
3562 if (fstrm->cs)
3563 return fstrm->cs;
3564 node = eb32_next(node);
3565 }
3566 return NULL;
3567}
3568
3569/*
3570 * Destroy the mux and the associated connection, if it is no longer used
3571 */
3572static void fcgi_destroy(void *ctx)
3573{
3574 struct fcgi_conn *fconn = ctx;
3575
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003576 TRACE_POINT(FCGI_EV_FCONN_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003577 if (eb_is_empty(&fconn->streams_by_id) || !fconn->conn || fconn->conn->ctx != fconn)
3578 fcgi_release(fconn);
3579}
3580
3581/*
3582 * Detach the stream from the connection and possibly release the connection.
3583 */
3584static void fcgi_detach(struct conn_stream *cs)
3585{
3586 struct fcgi_strm *fstrm = cs->ctx;
3587 struct fcgi_conn *fconn;
3588 struct session *sess;
3589
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003590 TRACE_ENTER(FCGI_EV_STRM_END, (fstrm ? fstrm->fconn->conn : NULL), fstrm);
3591
Christopher Faulet99eff652019-08-11 23:11:30 +02003592 cs->ctx = NULL;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003593 if (!fstrm) {
3594 TRACE_LEAVE(FCGI_EV_STRM_END);
Christopher Faulet99eff652019-08-11 23:11:30 +02003595 return;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003596 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003597
Willy Tarreauf11be0e2020-01-16 16:59:45 +01003598 /* there's no txbuf so we're certain no to be able to send anything */
3599 fstrm->flags &= ~FCGI_SF_NOTIFIED;
Christopher Faulet99eff652019-08-11 23:11:30 +02003600
3601 sess = fstrm->sess;
3602 fconn = fstrm->fconn;
3603 fstrm->cs = NULL;
3604 fconn->nb_cs--;
3605
3606 if (fstrm->proto_status == FCGI_PS_CANT_MPX_CONN) {
3607 fconn->flags &= ~FCGI_CF_MPXS_CONNS;
3608 fconn->streams_limit = 1;
3609 }
3610 else if (fstrm->proto_status == FCGI_PS_OVERLOADED ||
3611 fstrm->proto_status == FCGI_PS_UNKNOWN_ROLE) {
3612 fconn->flags &= ~FCGI_CF_KEEP_CONN;
3613 fconn->state = FCGI_CS_CLOSED;
3614 }
3615
3616 /* this stream may be blocked waiting for some data to leave, so orphan
3617 * it in this case.
3618 */
3619 if (!(cs->conn->flags & CO_FL_ERROR) &&
3620 (fconn->state != FCGI_CS_CLOSED) &&
Willy Tarreau7aad7032020-01-16 17:20:57 +01003621 (fstrm->flags & (FCGI_SF_BLK_MBUSY|FCGI_SF_BLK_MROOM)) &&
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003622 (fstrm->subs || (fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW)))) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003623 TRACE_DEVEL("leaving on stream blocked", FCGI_EV_STRM_END|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003624 return;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003625 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003626
3627 if ((fconn->flags & FCGI_CF_DEM_BLOCK_ANY && fstrm->id == fconn->dsi)) {
3628 /* unblock the connection if it was blocked on this stream. */
3629 fconn->flags &= ~FCGI_CF_DEM_BLOCK_ANY;
3630 fcgi_conn_restart_reading(fconn, 1);
3631 }
3632
3633 fcgi_strm_destroy(fstrm);
3634
3635 if (!(fconn->conn->flags & (CO_FL_ERROR|CO_FL_SOCK_RD_SH|CO_FL_SOCK_WR_SH)) &&
Christopher Faulet9bcd9732020-05-02 09:21:24 +02003636 (fconn->flags & FCGI_CF_KEEP_CONN)) {
Christopher Faulet29ae7ff2020-07-01 15:51:46 +02003637 if (fconn->conn->flags & CO_FL_PRIVATE) {
Christopher Faulet08016ab2020-07-01 16:10:06 +02003638 /* Add the connection in the session serverlist, if not already done */
3639 if (!session_add_conn(sess, fconn->conn, fconn->conn->target)) {
3640 fconn->conn->owner = NULL;
3641 if (eb_is_empty(&fconn->streams_by_id)) {
3642 /* let's kill the connection right away */
3643 fconn->conn->mux->destroy(fconn);
3644 TRACE_DEVEL("outgoing connection killed", FCGI_EV_STRM_END|FCGI_EV_FCONN_ERR);
3645 return;
Christopher Faulet29ae7ff2020-07-01 15:51:46 +02003646 }
3647 }
Christopher Faulet08016ab2020-07-01 16:10:06 +02003648 if (eb_is_empty(&fconn->streams_by_id)) {
Christopher Faulet29ae7ff2020-07-01 15:51:46 +02003649 if (session_check_idle_conn(fconn->conn->owner, fconn->conn) != 0) {
3650 /* The connection is destroyed, let's leave */
Olivier Houchard2444aa52020-01-20 13:56:01 +01003651 TRACE_DEVEL("outgoing connection killed", FCGI_EV_STRM_END|FCGI_EV_FCONN_ERR);
Christopher Faulet66cd57e2020-05-02 09:08:54 +02003652 return;
Christopher Faulet99eff652019-08-11 23:11:30 +02003653 }
3654 }
3655 }
Christopher Faulet29ae7ff2020-07-01 15:51:46 +02003656 else {
3657 if (eb_is_empty(&fconn->streams_by_id)) {
Amaury Denoyelle46f041d2020-10-14 18:17:11 +02003658 /* If the connection is owned by the session, first remove it
3659 * from its list
3660 */
3661 if (fconn->conn->owner) {
3662 session_unown_conn(fconn->conn->owner, fconn->conn);
3663 fconn->conn->owner = NULL;
3664 }
3665
Willy Tarreaue388f2f2021-03-02 16:51:09 +01003666 /* mark that the tasklet may lose its context to another thread and
3667 * that the handler needs to check it under the idle conns lock.
3668 */
3669 HA_ATOMIC_OR(&fconn->wait_event.tasklet->state, TASK_F_USR1);
Willy Tarreau4f8cd432021-03-02 17:27:58 +01003670 xprt_set_idle(fconn->conn, fconn->conn->xprt, fconn->conn->xprt_ctx);
3671
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003672 if (!srv_add_to_idle_list(objt_server(fconn->conn->target), fconn->conn, 1)) {
Olivier Houchard2444aa52020-01-20 13:56:01 +01003673 /* The server doesn't want it, let's kill the connection right away */
3674 fconn->conn->mux->destroy(fconn);
3675 TRACE_DEVEL("outgoing connection killed", FCGI_EV_STRM_END|FCGI_EV_FCONN_ERR);
3676 return;
3677 }
Olivier Houchard199d4fa2020-03-22 23:25:51 +01003678 /* At this point, the connection has been added to the
3679 * server idle list, so another thread may already have
3680 * hijacked it, so we can't do anything with it.
3681 */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003682 TRACE_DEVEL("reusable idle connection", FCGI_EV_STRM_END, fconn->conn);
3683 return;
3684 }
Amaury Denoyelle8990b012021-02-19 15:29:16 +01003685 else if (!fconn->conn->hash_node->node.node.leaf_p &&
Amaury Denoyelle46f041d2020-10-14 18:17:11 +02003686 fcgi_avail_streams(fconn->conn) > 0 && objt_server(fconn->conn->target) &&
Willy Tarreau2b718102021-04-21 07:32:39 +02003687 !LIST_INLIST(&fconn->conn->session_list)) {
Willy Tarreau430bf4a2021-03-04 09:45:32 +01003688 ebmb_insert(&__objt_server(fconn->conn->target)->per_thr[tid].avail_conns,
Amaury Denoyelle8990b012021-02-19 15:29:16 +01003689 &fconn->conn->hash_node->node,
3690 sizeof(fconn->conn->hash_node->hash));
Olivier Houcharddc2f2752020-02-13 19:12:07 +01003691 }
Christopher Faulet29ae7ff2020-07-01 15:51:46 +02003692 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003693 }
3694
3695 /* We don't want to close right now unless we're removing the last
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003696 * stream and the connection is in error.
Christopher Faulet99eff652019-08-11 23:11:30 +02003697 */
3698 if (fcgi_conn_is_dead(fconn)) {
3699 /* no more stream will come, kill it now */
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003700 TRACE_DEVEL("leaving, killing dead connection", FCGI_EV_STRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003701 fcgi_release(fconn);
3702 }
3703 else if (fconn->task) {
3704 fconn->task->expire = tick_add(now_ms, (fconn->state == FCGI_CS_CLOSED ? fconn->shut_timeout : fconn->timeout));
3705 task_queue(fconn->task);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003706 TRACE_DEVEL("leaving, refreshing connection's timeout", FCGI_EV_STRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003707 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003708 else
3709 TRACE_DEVEL("leaving", FCGI_EV_STRM_END, fconn->conn);
Christopher Faulet99eff652019-08-11 23:11:30 +02003710}
3711
3712
3713/* Performs a synchronous or asynchronous shutr(). */
3714static void fcgi_do_shutr(struct fcgi_strm *fstrm)
3715{
3716 struct fcgi_conn *fconn = fstrm->fconn;
Christopher Faulet99eff652019-08-11 23:11:30 +02003717
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003718 TRACE_ENTER(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
3719
Christopher Faulet99eff652019-08-11 23:11:30 +02003720 if (fstrm->state == FCGI_SS_CLOSED)
3721 goto done;
3722
3723 /* a connstream may require us to immediately kill the whole connection
3724 * for example because of a "tcp-request content reject" rule that is
3725 * normally used to limit abuse.
3726 */
3727 if ((fstrm->flags & FCGI_SF_KILL_CONN) &&
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003728 !(fconn->flags & (FCGI_CF_ABRTS_SENT|FCGI_CF_ABRTS_FAILED))) {
3729 TRACE_STATE("stream wants to kill the connection", FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003730 fconn->state = FCGI_CS_CLOSED;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003731 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003732 else if (fstrm->flags & FCGI_SF_BEGIN_SENT) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003733 TRACE_STATE("no headers sent yet, trying a retryable abort", FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003734 if (!(fstrm->flags & (FCGI_SF_ES_SENT|FCGI_SF_ABRT_SENT)) &&
3735 !fcgi_strm_send_abort(fconn, fstrm))
3736 goto add_to_list;
3737 }
3738
3739 fcgi_strm_close(fstrm);
3740
3741 if (!(fconn->wait_event.events & SUB_RETRY_SEND))
3742 tasklet_wakeup(fconn->wait_event.tasklet);
3743 done:
3744 fstrm->flags &= ~FCGI_SF_WANT_SHUTR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003745 TRACE_LEAVE(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003746 return;
3747
3748 add_to_list:
Willy Tarreau7aad7032020-01-16 17:20:57 +01003749 /* Let the handler know we want to shutr, and add ourselves to the
3750 * send list if not yet done. fcgi_deferred_shut() will be
3751 * automatically called via the shut_tl tasklet when there's room
3752 * again.
3753 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003754 if (!LIST_INLIST(&fstrm->send_list)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02003755 if (fstrm->flags & (FCGI_SF_BLK_MBUSY|FCGI_SF_BLK_MROOM)) {
Willy Tarreau2b718102021-04-21 07:32:39 +02003756 LIST_APPEND(&fconn->send_list, &fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02003757 }
3758 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003759 fstrm->flags |= FCGI_SF_WANT_SHUTR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003760 TRACE_LEAVE(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003761 return;
3762}
3763
3764/* Performs a synchronous or asynchronous shutw(). */
3765static void fcgi_do_shutw(struct fcgi_strm *fstrm)
3766{
3767 struct fcgi_conn *fconn = fstrm->fconn;
Christopher Faulet99eff652019-08-11 23:11:30 +02003768
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003769 TRACE_ENTER(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
3770
Christopher Faulet99eff652019-08-11 23:11:30 +02003771 if (fstrm->state != FCGI_SS_HLOC || fstrm->state == FCGI_SS_CLOSED)
3772 goto done;
3773
3774 if (fstrm->state != FCGI_SS_ERROR && (fstrm->flags & FCGI_SF_BEGIN_SENT)) {
3775 if (!(fstrm->flags & (FCGI_SF_ES_SENT|FCGI_SF_ABRT_SENT)) &&
3776 !fcgi_strm_send_abort(fconn, fstrm))
3777 goto add_to_list;
3778
3779 if (fstrm->state == FCGI_SS_HREM)
3780 fcgi_strm_close(fstrm);
3781 else
3782 fstrm->state = FCGI_SS_HLOC;
3783 } else {
3784 /* a connstream may require us to immediately kill the whole connection
3785 * for example because of a "tcp-request content reject" rule that is
3786 * normally used to limit abuse.
3787 */
3788 if ((fstrm->flags & FCGI_SF_KILL_CONN) &&
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003789 !(fconn->flags & (FCGI_CF_ABRTS_SENT|FCGI_CF_ABRTS_FAILED))) {
3790 TRACE_STATE("stream wants to kill the connection", FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003791 fconn->state = FCGI_CS_CLOSED;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003792 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003793
3794 fcgi_strm_close(fstrm);
3795 }
3796
3797 if (!(fconn->wait_event.events & SUB_RETRY_SEND))
3798 tasklet_wakeup(fconn->wait_event.tasklet);
3799 done:
3800 fstrm->flags &= ~FCGI_SF_WANT_SHUTW;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003801 TRACE_LEAVE(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003802 return;
3803
3804 add_to_list:
Willy Tarreau7aad7032020-01-16 17:20:57 +01003805 /* Let the handler know we want to shutr, and add ourselves to the
3806 * send list if not yet done. fcgi_deferred_shut() will be
3807 * automatically called via the shut_tl tasklet when there's room
3808 * again.
3809 */
Willy Tarreau2b718102021-04-21 07:32:39 +02003810 if (!LIST_INLIST(&fstrm->send_list)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02003811 if (fstrm->flags & (FCGI_SF_BLK_MBUSY|FCGI_SF_BLK_MROOM)) {
Willy Tarreau2b718102021-04-21 07:32:39 +02003812 LIST_APPEND(&fconn->send_list, &fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02003813 }
3814 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003815 fstrm->flags |= FCGI_SF_WANT_SHUTW;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003816 TRACE_LEAVE(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003817 return;
3818}
3819
Willy Tarreau7aad7032020-01-16 17:20:57 +01003820/* This is the tasklet referenced in fstrm->shut_tl, it is used for
Christopher Faulet99eff652019-08-11 23:11:30 +02003821 * deferred shutdowns when the fcgi_detach() was done but the mux buffer was full
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003822 * and prevented the last record from being emitted.
Christopher Faulet99eff652019-08-11 23:11:30 +02003823 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01003824struct task *fcgi_deferred_shut(struct task *t, void *ctx, unsigned int state)
Christopher Faulet99eff652019-08-11 23:11:30 +02003825{
3826 struct fcgi_strm *fstrm = ctx;
3827 struct fcgi_conn *fconn = fstrm->fconn;
3828
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003829 TRACE_ENTER(FCGI_EV_STRM_SHUT, fconn->conn, fstrm);
3830
Willy Tarreau7aad7032020-01-16 17:20:57 +01003831 if (fstrm->flags & FCGI_SF_NOTIFIED) {
3832 /* some data processing remains to be done first */
3833 goto end;
3834 }
3835
Christopher Faulet99eff652019-08-11 23:11:30 +02003836 if (fstrm->flags & FCGI_SF_WANT_SHUTW)
3837 fcgi_do_shutw(fstrm);
3838
3839 if (fstrm->flags & FCGI_SF_WANT_SHUTR)
3840 fcgi_do_shutr(fstrm);
3841
3842 if (!(fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW))) {
3843 /* We're done trying to send, remove ourself from the send_list */
3844 LIST_DEL_INIT(&fstrm->send_list);
3845
3846 if (!fstrm->cs) {
3847 fcgi_strm_destroy(fstrm);
3848 if (fcgi_conn_is_dead(fconn))
3849 fcgi_release(fconn);
3850 }
3851 }
Willy Tarreau7aad7032020-01-16 17:20:57 +01003852 end:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003853 TRACE_LEAVE(FCGI_EV_STRM_SHUT);
Christopher Faulet99eff652019-08-11 23:11:30 +02003854 return NULL;
3855}
3856
3857/* shutr() called by the conn_stream (mux_ops.shutr) */
3858static void fcgi_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
3859{
3860 struct fcgi_strm *fstrm = cs->ctx;
3861
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003862 TRACE_POINT(FCGI_EV_STRM_SHUT, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003863 if (cs->flags & CS_FL_KILL_CONN)
3864 fstrm->flags |= FCGI_SF_KILL_CONN;
3865
3866 if (!mode)
3867 return;
3868
3869 fcgi_do_shutr(fstrm);
3870}
3871
3872/* shutw() called by the conn_stream (mux_ops.shutw) */
3873static void fcgi_shutw(struct conn_stream *cs, enum cs_shw_mode mode)
3874{
3875 struct fcgi_strm *fstrm = cs->ctx;
3876
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003877 TRACE_POINT(FCGI_EV_STRM_SHUT, fstrm->fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003878 if (cs->flags & CS_FL_KILL_CONN)
3879 fstrm->flags |= FCGI_SF_KILL_CONN;
3880
3881 fcgi_do_shutw(fstrm);
3882}
3883
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003884/* Called from the upper layer, to subscribe <es> to events <event_type>. The
3885 * event subscriber <es> is not allowed to change from a previous call as long
3886 * as at least one event is still subscribed. The <event_type> must only be a
3887 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0.
Christopher Faulet99eff652019-08-11 23:11:30 +02003888 */
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003889static int fcgi_subscribe(struct conn_stream *cs, int event_type, struct wait_event *es)
Christopher Faulet99eff652019-08-11 23:11:30 +02003890{
Christopher Faulet99eff652019-08-11 23:11:30 +02003891 struct fcgi_strm *fstrm = cs->ctx;
3892 struct fcgi_conn *fconn = fstrm->fconn;
3893
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003894 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003895 BUG_ON(fstrm->subs && fstrm->subs != es);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003896
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003897 es->events |= event_type;
3898 fstrm->subs = es;
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003899
3900 if (event_type & SUB_RETRY_RECV)
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003901 TRACE_DEVEL("unsubscribe(recv)", FCGI_EV_STRM_RECV, fconn->conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003902
Christopher Faulet99eff652019-08-11 23:11:30 +02003903 if (event_type & SUB_RETRY_SEND) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003904 TRACE_DEVEL("unsubscribe(send)", FCGI_EV_STRM_SEND, fconn->conn, fstrm);
Willy Tarreau2b718102021-04-21 07:32:39 +02003905 if (!LIST_INLIST(&fstrm->send_list))
3906 LIST_APPEND(&fconn->send_list, &fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02003907 }
Christopher Faulet99eff652019-08-11 23:11:30 +02003908 return 0;
3909}
3910
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003911/* Called from the upper layer, to unsubscribe <es> from events <event_type>
3912 * (undo fcgi_subscribe). The <es> pointer is not allowed to differ from the one
3913 * passed to the subscribe() call. It always returns zero.
Christopher Faulet99eff652019-08-11 23:11:30 +02003914 */
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003915static int fcgi_unsubscribe(struct conn_stream *cs, int event_type, struct wait_event *es)
Christopher Faulet99eff652019-08-11 23:11:30 +02003916{
Christopher Faulet99eff652019-08-11 23:11:30 +02003917 struct fcgi_strm *fstrm = cs->ctx;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003918 struct fcgi_conn *fconn = fstrm->fconn;
Christopher Faulet99eff652019-08-11 23:11:30 +02003919
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003920 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003921 BUG_ON(fstrm->subs && fstrm->subs != es);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003922
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01003923 es->events &= ~event_type;
3924 if (!es->events)
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003925 fstrm->subs = NULL;
3926
3927 if (event_type & SUB_RETRY_RECV)
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003928 TRACE_DEVEL("subscribe(recv)", FCGI_EV_STRM_RECV, fconn->conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003929
Christopher Faulet99eff652019-08-11 23:11:30 +02003930 if (event_type & SUB_RETRY_SEND) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003931 TRACE_DEVEL("subscribe(send)", FCGI_EV_STRM_SEND, fconn->conn, fstrm);
Willy Tarreau8907e4d2020-01-16 17:55:37 +01003932 fstrm->flags &= ~FCGI_SF_NOTIFIED;
Willy Tarreau7aad7032020-01-16 17:20:57 +01003933 if (!(fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW)))
3934 LIST_DEL_INIT(&fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02003935 }
3936 return 0;
3937}
3938
Christopher Faulet564e39c2021-09-21 15:50:55 +02003939/* Called from the upper layer, to receive data
3940 *
3941 * The caller is responsible for defragmenting <buf> if necessary. But <flags>
3942 * must be tested to know the calling context. If CO_RFL_BUF_FLUSH is set, it
3943 * means the caller wants to flush input data (from the mux buffer and the
3944 * channel buffer) to be able to use kernel splicing or any kind of mux-to-mux
3945 * xfer. If CO_RFL_KEEP_RECV is set, the mux must always subscribe for read
3946 * events before giving back. CO_RFL_BUF_WET is set if <buf> is congested with
3947 * data scheduled for leaving soon. CO_RFL_BUF_NOT_STUCK is set to instruct the
3948 * mux it may optimize the data copy to <buf> if necessary. Otherwise, it should
3949 * copy as much data as possible.
3950 */
Christopher Faulet99eff652019-08-11 23:11:30 +02003951static size_t fcgi_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags)
3952{
3953 struct fcgi_strm *fstrm = cs->ctx;
3954 struct fcgi_conn *fconn = fstrm->fconn;
3955 size_t ret = 0;
3956
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003957 TRACE_ENTER(FCGI_EV_STRM_RECV, fconn->conn, fstrm);
3958
Christopher Faulet99eff652019-08-11 23:11:30 +02003959 if (!(fconn->flags & FCGI_CF_DEM_SALLOC))
3960 ret = fcgi_strm_parse_response(fstrm, buf, count);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003961 else
3962 TRACE_STATE("fstrm rxbuf not allocated", FCGI_EV_STRM_RECV|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003963
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01003964 if (b_data(&fstrm->rxbuf))
Christopher Faulet99eff652019-08-11 23:11:30 +02003965 cs->flags |= (CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
3966 else {
3967 cs->flags &= ~(CS_FL_RCV_MORE | CS_FL_WANT_ROOM);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01003968 if (fstrm->state == FCGI_SS_ERROR || (fstrm->h1m.state == H1_MSG_DONE)) {
Christopher Faulet99eff652019-08-11 23:11:30 +02003969 cs->flags |= CS_FL_EOI;
3970 if (!(fstrm->h1m.flags & (H1_MF_VER_11|H1_MF_XFER_LEN)))
3971 cs->flags |= CS_FL_EOS;
3972 }
Christopher Faulet6670e3e2020-10-08 15:26:33 +02003973 if (fcgi_conn_read0_pending(fconn))
Christopher Faulet99eff652019-08-11 23:11:30 +02003974 cs->flags |= CS_FL_EOS;
3975 if (cs->flags & CS_FL_ERR_PENDING)
3976 cs->flags |= CS_FL_ERROR;
3977 fcgi_release_buf(fconn, &fstrm->rxbuf);
3978 }
3979
3980 if (ret && fconn->dsi == fstrm->id) {
3981 /* demux is blocking on this stream's buffer */
3982 fconn->flags &= ~FCGI_CF_DEM_SFULL;
3983 fcgi_conn_restart_reading(fconn, 1);
3984 }
3985
Christopher Faulet5c0f8592019-10-04 15:21:17 +02003986 TRACE_LEAVE(FCGI_EV_STRM_RECV, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02003987 return ret;
3988}
3989
3990
Christopher Faulet99eff652019-08-11 23:11:30 +02003991/* Called from the upper layer, to send data from buffer <buf> for no more than
3992 * <count> bytes. Returns the number of bytes effectively sent. Some status
3993 * flags may be updated on the conn_stream.
3994 */
3995static size_t fcgi_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t count, int flags)
3996{
3997 struct fcgi_strm *fstrm = cs->ctx;
3998 struct fcgi_conn *fconn = fstrm->fconn;
3999 size_t total = 0;
4000 size_t ret;
4001 struct htx *htx = NULL;
4002 struct htx_sl *sl;
4003 struct htx_blk *blk;
4004 uint32_t bsize;
4005
Willy Tarreau022e5e52020-09-10 09:33:15 +02004006 TRACE_ENTER(FCGI_EV_STRM_SEND, fconn->conn, fstrm, 0, (size_t[]){count});
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004007
Christopher Faulet99eff652019-08-11 23:11:30 +02004008 /* If we were not just woken because we wanted to send but couldn't,
4009 * and there's somebody else that is waiting to send, do nothing,
4010 * we will subscribe later and be put at the end of the list
4011 */
Willy Tarreauf11be0e2020-01-16 16:59:45 +01004012 if (!(fstrm->flags & FCGI_SF_NOTIFIED) && !LIST_ISEMPTY(&fconn->send_list)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004013 TRACE_STATE("other streams already waiting, going to the queue and leaving", FCGI_EV_STRM_SEND|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004014 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004015 }
Willy Tarreauf11be0e2020-01-16 16:59:45 +01004016 fstrm->flags &= ~FCGI_SF_NOTIFIED;
Christopher Faulet99eff652019-08-11 23:11:30 +02004017
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004018 if (fconn->state < FCGI_CS_RECORD_H) {
4019 TRACE_STATE("connection not ready, leaving", FCGI_EV_STRM_SEND|FCGI_EV_FSTRM_BLK, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004020 return 0;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004021 }
Christopher Faulet99eff652019-08-11 23:11:30 +02004022
4023 htx = htxbuf(buf);
4024 if (fstrm->id == 0) {
4025 int32_t id = fcgi_conn_get_next_sid(fconn);
4026
4027 if (id < 0) {
4028 fcgi_strm_close(fstrm);
4029 cs->flags |= CS_FL_ERROR;
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004030 TRACE_DEVEL("couldn't get a stream ID, leaving in error", FCGI_EV_STRM_SEND|FCGI_EV_FSTRM_ERR|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004031 return 0;
4032 }
4033
4034 eb32_delete(&fstrm->by_id);
4035 fstrm->by_id.key = fstrm->id = id;
4036 fconn->max_id = id;
4037 fconn->nb_reserved--;
4038 eb32_insert(&fconn->streams_by_id, &fstrm->by_id);
4039
4040
4041 /* Check if length of the body is known or if the message is
4042 * full. Otherwise, the request is invalid.
4043 */
4044 sl = http_get_stline(htx);
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01004045 if (!sl || (!(sl->flags & HTX_SL_F_CLEN) && !(htx->flags & HTX_FL_EOM))) {
Christopher Faulet99eff652019-08-11 23:11:30 +02004046 htx->flags |= HTX_FL_PARSING_ERROR;
4047 fcgi_strm_error(fstrm);
4048 goto done;
4049 }
4050 }
4051
4052 if (!(fstrm->flags & FCGI_SF_BEGIN_SENT)) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004053 TRACE_PROTO("sending FCGI BEGIN_REQUEST record", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004054 if (!fcgi_strm_send_begin_request(fconn, fstrm))
4055 goto done;
4056 }
4057
4058 if (!(fstrm->flags & FCGI_SF_OUTGOING_DATA) && count)
4059 fstrm->flags |= FCGI_SF_OUTGOING_DATA;
4060
Christopher Fauletfe410d62020-05-19 15:13:00 +02004061 while (fstrm->state < FCGI_SS_HLOC && !(fstrm->flags & FCGI_SF_BLK_ANY) &&
Christopher Faulet99eff652019-08-11 23:11:30 +02004062 count && !htx_is_empty(htx)) {
4063 blk = htx_get_head_blk(htx);
William Lallemand13ed9fa2019-09-25 21:21:57 +02004064 ALREADY_CHECKED(blk);
Christopher Faulet99eff652019-08-11 23:11:30 +02004065 bsize = htx_get_blksz(blk);
4066
4067 switch (htx_get_blk_type(blk)) {
4068 case HTX_BLK_REQ_SL:
4069 case HTX_BLK_HDR:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004070 TRACE_USER("sending FCGI PARAMS record", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02004071 ret = fcgi_strm_send_params(fconn, fstrm, htx);
4072 if (!ret) {
4073 goto done;
4074 }
4075 total += ret;
4076 count -= ret;
4077 break;
4078
4079 case HTX_BLK_EOH:
Christopher Fauletd1ac2b92020-12-02 19:12:22 +01004080 if (!(fstrm->flags & FCGI_SF_EP_SENT)) {
4081 TRACE_PROTO("sending FCGI PARAMS record", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, htx);
4082 ret = fcgi_strm_send_empty_params(fconn, fstrm);
4083 if (!ret)
4084 goto done;
4085 }
4086 if (htx_is_unique_blk(htx, blk) && (htx->flags & HTX_FL_EOM)) {
4087 TRACE_PROTO("sending FCGI STDIN record", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx);
4088 ret = fcgi_strm_send_empty_stdin(fconn, fstrm);
4089 if (!ret)
4090 goto done;
4091 }
Christopher Faulet99eff652019-08-11 23:11:30 +02004092 goto remove_blk;
4093
4094 case HTX_BLK_DATA:
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004095 TRACE_PROTO("sending FCGI STDIN record", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, htx);
Christopher Faulet99eff652019-08-11 23:11:30 +02004096 ret = fcgi_strm_send_stdin(fconn, fstrm, htx, count, buf);
4097 if (ret > 0) {
4098 htx = htx_from_buf(buf);
4099 total += ret;
4100 count -= ret;
4101 if (ret < bsize)
4102 goto done;
4103 }
4104 break;
4105
Christopher Faulet99eff652019-08-11 23:11:30 +02004106 default:
4107 remove_blk:
4108 htx_remove_blk(htx, blk);
4109 total += bsize;
4110 count -= bsize;
4111 break;
4112 }
4113 }
4114
4115 done:
4116 if (fstrm->state >= FCGI_SS_HLOC) {
4117 /* trim any possibly pending data after we close (extra CR-LF,
4118 * unprocessed trailers, abnormal extra data, ...)
4119 */
4120 total += count;
4121 count = 0;
4122 }
4123
4124 if (fstrm->state == FCGI_SS_ERROR) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004125 TRACE_DEVEL("reporting error to the app-layer stream", FCGI_EV_STRM_SEND|FCGI_EV_FSTRM_ERR|FCGI_EV_STRM_ERR, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004126 cs_set_error(cs);
4127 if (!(fstrm->flags & FCGI_SF_BEGIN_SENT) || fcgi_strm_send_abort(fconn, fstrm))
4128 fcgi_strm_close(fstrm);
4129 }
4130
4131 if (htx)
4132 htx_to_buf(htx, buf);
4133
Christopher Faulet99eff652019-08-11 23:11:30 +02004134 if (total > 0) {
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004135 if (!(fconn->wait_event.events & SUB_RETRY_SEND)) {
4136 TRACE_DEVEL("data queued, waking up fconn sender", FCGI_EV_STRM_SEND|FCGI_EV_FCONN_SEND|FCGI_EV_FCONN_WAKE, fconn->conn, fstrm);
Christopher Faulet99eff652019-08-11 23:11:30 +02004137 tasklet_wakeup(fconn->wait_event.tasklet);
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004138 }
Christopher Faulet99eff652019-08-11 23:11:30 +02004139
4140 /* Ok we managed to send something, leave the send_list */
Willy Tarreau7aad7032020-01-16 17:20:57 +01004141 if (!(fstrm->flags & (FCGI_SF_WANT_SHUTR|FCGI_SF_WANT_SHUTW)))
4142 LIST_DEL_INIT(&fstrm->send_list);
Christopher Faulet99eff652019-08-11 23:11:30 +02004143 }
Christopher Faulet5c0f8592019-10-04 15:21:17 +02004144
4145 TRACE_LEAVE(FCGI_EV_STRM_SEND, fconn->conn, fstrm, htx, (size_t[]){total});
Christopher Faulet99eff652019-08-11 23:11:30 +02004146 return total;
4147}
4148
4149/* for debugging with CLI's "show fd" command */
Willy Tarreau8050efe2021-01-21 08:26:06 +01004150static int fcgi_show_fd(struct buffer *msg, struct connection *conn)
Christopher Faulet99eff652019-08-11 23:11:30 +02004151{
4152 struct fcgi_conn *fconn = conn->ctx;
4153 struct fcgi_strm *fstrm = NULL;
4154 struct eb32_node *node;
4155 int send_cnt = 0;
4156 int tree_cnt = 0;
4157 int orph_cnt = 0;
4158 struct buffer *hmbuf, *tmbuf;
4159
4160 if (!fconn)
Willy Tarreau8050efe2021-01-21 08:26:06 +01004161 return 0;
Christopher Faulet99eff652019-08-11 23:11:30 +02004162
4163 list_for_each_entry(fstrm, &fconn->send_list, send_list)
4164 send_cnt++;
4165
4166 fstrm = NULL;
4167 node = eb32_first(&fconn->streams_by_id);
4168 while (node) {
4169 fstrm = container_of(node, struct fcgi_strm, by_id);
4170 tree_cnt++;
4171 if (!fstrm->cs)
4172 orph_cnt++;
4173 node = eb32_next(node);
4174 }
4175
4176 hmbuf = br_head(fconn->mbuf);
4177 tmbuf = br_tail(fconn->mbuf);
4178 chunk_appendf(msg, " fconn.st0=%d .maxid=%d .flg=0x%04x .nbst=%u"
4179 " .nbcs=%u .send_cnt=%d .tree_cnt=%d .orph_cnt=%d .sub=%d "
4180 ".dsi=%d .dbuf=%u@%p+%u/%u .mbuf=[%u..%u|%u],h=[%u@%p+%u/%u],t=[%u@%p+%u/%u]",
4181 fconn->state, fconn->max_id, fconn->flags,
4182 fconn->nb_streams, fconn->nb_cs, send_cnt, tree_cnt, orph_cnt,
4183 fconn->wait_event.events, fconn->dsi,
4184 (unsigned int)b_data(&fconn->dbuf), b_orig(&fconn->dbuf),
4185 (unsigned int)b_head_ofs(&fconn->dbuf), (unsigned int)b_size(&fconn->dbuf),
4186 br_head_idx(fconn->mbuf), br_tail_idx(fconn->mbuf), br_size(fconn->mbuf),
4187 (unsigned int)b_data(hmbuf), b_orig(hmbuf),
4188 (unsigned int)b_head_ofs(hmbuf), (unsigned int)b_size(hmbuf),
4189 (unsigned int)b_data(tmbuf), b_orig(tmbuf),
4190 (unsigned int)b_head_ofs(tmbuf), (unsigned int)b_size(tmbuf));
4191
4192 if (fstrm) {
4193 chunk_appendf(msg, " last_fstrm=%p .id=%d .flg=0x%04x .rxbuf=%u@%p+%u/%u .cs=%p",
4194 fstrm, fstrm->id, fstrm->flags,
4195 (unsigned int)b_data(&fstrm->rxbuf), b_orig(&fstrm->rxbuf),
4196 (unsigned int)b_head_ofs(&fstrm->rxbuf), (unsigned int)b_size(&fstrm->rxbuf),
4197 fstrm->cs);
4198 if (fstrm->cs)
4199 chunk_appendf(msg, " .cs.flg=0x%08x .cs.data=%p",
4200 fstrm->cs->flags, fstrm->cs->data);
Willy Tarreau1776ffb2021-01-20 17:10:46 +01004201 chunk_appendf(&trash, " .subs=%p", fstrm->subs);
4202 if (fstrm->subs) {
Christopher Faulet6c93c4e2021-02-25 10:06:29 +01004203 chunk_appendf(&trash, "(ev=%d tl=%p", fstrm->subs->events, fstrm->subs->tasklet);
4204 chunk_appendf(&trash, " tl.calls=%d tl.ctx=%p tl.fct=",
4205 fstrm->subs->tasklet->calls,
4206 fstrm->subs->tasklet->context);
4207 resolve_sym_name(&trash, NULL, fstrm->subs->tasklet->process);
4208 chunk_appendf(&trash, ")");
Willy Tarreau1776ffb2021-01-20 17:10:46 +01004209 }
Christopher Faulet99eff652019-08-11 23:11:30 +02004210 }
Willy Tarreau8050efe2021-01-21 08:26:06 +01004211 return 0;
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004212}
4213
4214/* Migrate the the connection to the current thread.
4215 * Return 0 if successful, non-zero otherwise.
4216 * Expected to be called with the old thread lock held.
4217 */
Olivier Houchard1662cdb2020-07-03 14:04:37 +02004218static int fcgi_takeover(struct connection *conn, int orig_tid)
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004219{
4220 struct fcgi_conn *fcgi = conn->ctx;
Willy Tarreau88d18f82020-07-01 16:39:33 +02004221 struct task *task;
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004222
4223 if (fd_takeover(conn->handle.fd, conn) != 0)
4224 return -1;
Olivier Houcharda74bb7e2020-07-03 14:01:21 +02004225
4226 if (conn->xprt->takeover && conn->xprt->takeover(conn, conn->xprt_ctx, orig_tid) != 0) {
4227 /* We failed to takeover the xprt, even if the connection may
4228 * still be valid, flag it as error'd, as we have already
4229 * taken over the fd, and wake the tasklet, so that it will
4230 * destroy it.
4231 */
4232 conn->flags |= CO_FL_ERROR;
4233 tasklet_wakeup_on(fcgi->wait_event.tasklet, orig_tid);
4234 return -1;
4235 }
4236
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004237 if (fcgi->wait_event.events)
4238 fcgi->conn->xprt->unsubscribe(fcgi->conn, fcgi->conn->xprt_ctx,
4239 fcgi->wait_event.events, &fcgi->wait_event);
4240 /* To let the tasklet know it should free itself, and do nothing else,
4241 * set its context to NULL;
4242 */
4243 fcgi->wait_event.tasklet->context = NULL;
Olivier Houchard1662cdb2020-07-03 14:04:37 +02004244 tasklet_wakeup_on(fcgi->wait_event.tasklet, orig_tid);
Willy Tarreau88d18f82020-07-01 16:39:33 +02004245
4246 task = fcgi->task;
4247 if (task) {
4248 task->context = NULL;
4249 fcgi->task = NULL;
4250 __ha_barrier_store();
4251 task_kill(task);
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004252
Willy Tarreaubeeabf52021-10-01 18:23:30 +02004253 fcgi->task = task_new_here();
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004254 if (!fcgi->task) {
4255 fcgi_release(fcgi);
4256 return -1;
4257 }
4258 fcgi->task->process = fcgi_timeout_task;
4259 fcgi->task->context = fcgi;
4260 }
4261 fcgi->wait_event.tasklet = tasklet_new();
4262 if (!fcgi->wait_event.tasklet) {
4263 fcgi_release(fcgi);
4264 return -1;
4265 }
4266 fcgi->wait_event.tasklet->process = fcgi_io_cb;
4267 fcgi->wait_event.tasklet->context = fcgi;
4268 fcgi->conn->xprt->subscribe(fcgi->conn, fcgi->conn->xprt_ctx,
4269 SUB_RETRY_RECV, &fcgi->wait_event);
4270
4271 return 0;
Christopher Faulet99eff652019-08-11 23:11:30 +02004272}
4273
4274/****************************************/
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +05004275/* MUX initialization and instantiation */
Christopher Faulet99eff652019-08-11 23:11:30 +02004276/****************************************/
4277
4278/* The mux operations */
4279static const struct mux_ops mux_fcgi_ops = {
4280 .init = fcgi_init,
4281 .wake = fcgi_wake,
4282 .attach = fcgi_attach,
4283 .get_first_cs = fcgi_get_first_cs,
4284 .detach = fcgi_detach,
4285 .destroy = fcgi_destroy,
4286 .avail_streams = fcgi_avail_streams,
4287 .used_streams = fcgi_used_streams,
4288 .rcv_buf = fcgi_rcv_buf,
4289 .snd_buf = fcgi_snd_buf,
4290 .subscribe = fcgi_subscribe,
4291 .unsubscribe = fcgi_unsubscribe,
4292 .shutr = fcgi_shutr,
4293 .shutw = fcgi_shutw,
Olivier Houchard9b8e11e2019-10-25 16:19:26 +02004294 .ctl = fcgi_ctl,
Christopher Faulet99eff652019-08-11 23:11:30 +02004295 .show_fd = fcgi_show_fd,
Olivier Houcharda41bb0b2020-03-10 18:46:06 +01004296 .takeover = fcgi_takeover,
Christopher Fauleta4600572021-03-08 15:28:28 +01004297 .flags = MX_FL_HTX|MX_FL_HOL_RISK|MX_FL_NO_UPG,
Christopher Faulet99eff652019-08-11 23:11:30 +02004298 .name = "FCGI",
4299};
4300
4301
4302/* this mux registers FCGI proto */
4303static struct mux_proto_list mux_proto_fcgi =
4304{ .token = IST("fcgi"), .mode = PROTO_MODE_HTTP, .side = PROTO_SIDE_BE, .mux = &mux_fcgi_ops };
4305
4306INITCALL1(STG_REGISTER, register_mux_proto, &mux_proto_fcgi);
4307
4308/*
4309 * Local variables:
4310 * c-indent-level: 8
4311 * c-basic-offset: 8
4312 * End:
4313 */