blob: 867cba8a59d0ac1ce32dfac46b603b5ffd101417 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreau87b09662015-04-03 00:22:06 +02002 * Stream management functions.
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 *
Willy Tarreaud28c3532012-04-19 19:28:33 +02004 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
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
13#include <stdlib.h>
Willy Tarreau81f9aa32010-06-01 17:45:26 +020014#include <unistd.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020015
Willy Tarreaua264d962020-06-04 22:29:18 +020016#include <import/ebistree.h>
17
Willy Tarreaudcc048a2020-06-04 19:11:43 +020018#include <haproxy/acl.h>
Willy Tarreau122eba92020-06-04 10:15:32 +020019#include <haproxy/action.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020020#include <haproxy/activity.h>
21#include <haproxy/api.h>
Willy Tarreau3f0f82e2020-06-04 19:42:41 +020022#include <haproxy/applet.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020023#include <haproxy/arg.h>
Willy Tarreau49801602020-06-04 22:50:02 +020024#include <haproxy/backend.h>
Willy Tarreau278161c2020-06-04 11:18:28 +020025#include <haproxy/capture.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020026#include <haproxy/cfgparse.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020027#include <haproxy/channel.h>
Willy Tarreau4aa573d2020-06-04 18:21:56 +020028#include <haproxy/check.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020029#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020030#include <haproxy/connection.h>
Willy Tarreau3afc4c42020-06-03 18:23:19 +020031#include <haproxy/dict.h>
Willy Tarreau2741c8c2020-06-02 11:28:02 +020032#include <haproxy/dynbuf.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020033#include <haproxy/fd.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +020034#include <haproxy/filters.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020035#include <haproxy/freq_ctr.h>
Willy Tarreau762d7a52020-06-04 11:23:07 +020036#include <haproxy/frontend.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020037#include <haproxy/global.h>
Willy Tarreau86416052020-06-04 09:20:54 +020038#include <haproxy/hlua.h>
Willy Tarreauc2b1ff02020-06-04 21:21:03 +020039#include <haproxy/http_ana.h>
Willy Tarreauc761f842020-06-04 11:40:28 +020040#include <haproxy/http_rules.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020041#include <haproxy/htx.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020042#include <haproxy/istbuf.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020043#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020044#include <haproxy/pipe.h>
Willy Tarreaud0ef4392020-06-02 09:38:52 +020045#include <haproxy/pool.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020046#include <haproxy/proxy.h>
Willy Tarreaua55c4542020-06-04 22:59:39 +020047#include <haproxy/queue.h>
Willy Tarreau5edca2f2022-05-27 09:25:10 +020048#include <haproxy/sc_strm.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +020049#include <haproxy/server.h>
Emeric Brunc9437992021-02-12 19:42:55 +010050#include <haproxy/resolvers.h>
Amaury Denoyelle12bada52020-12-10 13:43:57 +010051#include <haproxy/sample.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +020052#include <haproxy/session.h>
Willy Tarreau2eec9b52020-06-04 19:58:55 +020053#include <haproxy/stats-t.h>
Willy Tarreaucb086c62022-05-27 09:47:12 +020054#include <haproxy/stconn.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020055#include <haproxy/stick_table.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020056#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020057#include <haproxy/task.h>
Willy Tarreau8b550af2020-06-04 17:42:48 +020058#include <haproxy/tcp_rules.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020059#include <haproxy/thread.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020060#include <haproxy/trace.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020061#include <haproxy/vars.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020062
Willy Tarreaubaaee002006-06-26 02:48:02 +020063
Willy Tarreau8ceae722018-11-26 11:58:30 +010064DECLARE_POOL(pool_head_stream, "stream", sizeof(struct stream));
Tim Duesterhus127a74d2020-02-28 15:13:33 +010065DECLARE_POOL(pool_head_uniqueid, "uniqueid", UNIQUEID_LEN);
Willy Tarreau8ceae722018-11-26 11:58:30 +010066
Willy Tarreaub9813182021-02-24 11:29:51 +010067/* incremented by each "show sess" to fix a delimiter between streams */
68unsigned stream_epoch = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +020069
Thierry FOURNIER5a363e72015-09-27 19:29:33 +020070/* List of all use-service keywords. */
71static struct list service_keywords = LIST_HEAD_INIT(service_keywords);
72
Willy Tarreau5790eb02017-08-28 17:18:36 +020073
Christopher Fauleteea8fc72019-11-05 16:18:10 +010074/* trace source and events */
75static void strm_trace(enum trace_level level, uint64_t mask,
76 const struct trace_source *src,
77 const struct ist where, const struct ist func,
78 const void *a1, const void *a2, const void *a3, const void *a4);
79
80/* The event representation is split like this :
81 * strm - stream
Willy Tarreaub49672d2022-05-27 10:13:37 +020082 * sc - stream connector
Christopher Fauleteea8fc72019-11-05 16:18:10 +010083 * http - http analyzis
84 * tcp - tcp analyzis
85 *
86 * STRM_EV_* macros are defined in <proto/stream.h>
87 */
88static const struct trace_event strm_trace_events[] = {
89 { .mask = STRM_EV_STRM_NEW, .name = "strm_new", .desc = "new stream" },
90 { .mask = STRM_EV_STRM_FREE, .name = "strm_free", .desc = "release stream" },
91 { .mask = STRM_EV_STRM_ERR, .name = "strm_err", .desc = "error during stream processing" },
92 { .mask = STRM_EV_STRM_ANA, .name = "strm_ana", .desc = "stream analyzers" },
93 { .mask = STRM_EV_STRM_PROC, .name = "strm_proc", .desc = "stream processing" },
94
Willy Tarreau74568cf2022-05-27 09:03:30 +020095 { .mask = STRM_EV_CS_ST, .name = "sc_state", .desc = "processing connector states" },
Christopher Fauleteea8fc72019-11-05 16:18:10 +010096
97 { .mask = STRM_EV_HTTP_ANA, .name = "http_ana", .desc = "HTTP analyzers" },
98 { .mask = STRM_EV_HTTP_ERR, .name = "http_err", .desc = "error during HTTP analyzis" },
99
100 { .mask = STRM_EV_TCP_ANA, .name = "tcp_ana", .desc = "TCP analyzers" },
101 { .mask = STRM_EV_TCP_ERR, .name = "tcp_err", .desc = "error during TCP analyzis" },
Christopher Faulet50019132022-03-08 15:47:02 +0100102
103 { .mask = STRM_EV_FLT_ANA, .name = "flt_ana", .desc = "Filter analyzers" },
104 { .mask = STRM_EV_FLT_ERR, .name = "flt_err", .desc = "error during filter analyzis" },
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100105 {}
106};
107
108static const struct name_desc strm_trace_lockon_args[4] = {
109 /* arg1 */ { /* already used by the stream */ },
110 /* arg2 */ { },
111 /* arg3 */ { },
112 /* arg4 */ { }
113};
114
115static const struct name_desc strm_trace_decoding[] = {
116#define STRM_VERB_CLEAN 1
117 { .name="clean", .desc="only user-friendly stuff, generally suitable for level \"user\"" },
118#define STRM_VERB_MINIMAL 2
Willy Tarreau4596fe22022-05-17 19:07:51 +0200119 { .name="minimal", .desc="report info on streams and connectors" },
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100120#define STRM_VERB_SIMPLE 3
121 { .name="simple", .desc="add info on request and response channels" },
122#define STRM_VERB_ADVANCED 4
123 { .name="advanced", .desc="add info on channel's buffer for data and developer levels only" },
124#define STRM_VERB_COMPLETE 5
125 { .name="complete", .desc="add info on channel's buffer" },
126 { /* end */ }
127};
128
129struct trace_source trace_strm = {
130 .name = IST("stream"),
131 .desc = "Applicative stream",
132 .arg_def = TRC_ARG1_STRM, // TRACE()'s first argument is always a stream
133 .default_cb = strm_trace,
134 .known_events = strm_trace_events,
135 .lockon_args = strm_trace_lockon_args,
136 .decoding = strm_trace_decoding,
137 .report_events = ~0, // report everything by default
138};
139
140#define TRACE_SOURCE &trace_strm
141INITCALL1(STG_REGISTER, trace_register_source, TRACE_SOURCE);
142
143/* the stream traces always expect that arg1, if non-null, is of a stream (from
144 * which we can derive everything), that arg2, if non-null, is an http
145 * transaction, that arg3, if non-null, is an http message.
146 */
147static void strm_trace(enum trace_level level, uint64_t mask, const struct trace_source *src,
148 const struct ist where, const struct ist func,
149 const void *a1, const void *a2, const void *a3, const void *a4)
150{
151 const struct stream *s = a1;
152 const struct http_txn *txn = a2;
153 const struct http_msg *msg = a3;
154 struct task *task;
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100155 const struct channel *req, *res;
156 struct htx *htx;
157
158 if (!s || src->verbosity < STRM_VERB_CLEAN)
159 return;
160
161 task = s->task;
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100162 req = &s->req;
163 res = &s->res;
164 htx = (msg ? htxbuf(&msg->chn->buf) : NULL);
165
166 /* General info about the stream (htx/tcp, id...) */
167 chunk_appendf(&trace_buf, " : [%u,%s]",
168 s->uniq_id, ((s->flags & SF_HTX) ? "HTX" : "TCP"));
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100169 if (isttest(s->unique_id)) {
170 chunk_appendf(&trace_buf, " id=");
171 b_putist(&trace_buf, s->unique_id);
172 }
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100173
Willy Tarreau4596fe22022-05-17 19:07:51 +0200174 /* Front and back stream connector state */
Willy Tarreaue68bc612022-05-27 11:23:05 +0200175 chunk_appendf(&trace_buf, " SC=(%s,%s)",
Willy Tarreau74568cf2022-05-27 09:03:30 +0200176 sc_state_str(s->scf->state), sc_state_str(s->scb->state));
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100177
178 /* If txn is defined, HTTP req/rep states */
179 if (txn)
180 chunk_appendf(&trace_buf, " HTTP=(%s,%s)",
181 h1_msg_state_str(txn->req.msg_state), h1_msg_state_str(txn->rsp.msg_state));
182 if (msg)
183 chunk_appendf(&trace_buf, " %s", ((msg->chn->flags & CF_ISRESP) ? "RESPONSE" : "REQUEST"));
184
185 if (src->verbosity == STRM_VERB_CLEAN)
186 return;
187
188 /* If msg defined, display status-line if possible (verbosity > MINIMAL) */
189 if (src->verbosity > STRM_VERB_MINIMAL && htx && htx_nbblks(htx)) {
Willy Tarreaud46b5b92022-05-30 16:27:48 +0200190 const struct htx_blk *blk = __htx_get_head_blk(htx);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100191 const struct htx_sl *sl = htx_get_blk_ptr(htx, blk);
192 enum htx_blk_type type = htx_get_blk_type(blk);
193
194 if (type == HTX_BLK_REQ_SL || type == HTX_BLK_RES_SL)
195 chunk_appendf(&trace_buf, " - \"%.*s %.*s %.*s\"",
196 HTX_SL_P1_LEN(sl), HTX_SL_P1_PTR(sl),
197 HTX_SL_P2_LEN(sl), HTX_SL_P2_PTR(sl),
198 HTX_SL_P3_LEN(sl), HTX_SL_P3_PTR(sl));
199 }
200
201
202 /* If txn defined info about HTTP msgs, otherwise info about SI. */
203 if (txn) {
Christopher Faulet50264b42022-03-30 19:39:30 +0200204 chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) txn.flags=0x%08x, http.flags=(0x%08x,0x%08x) status=%d",
205 task, s, s->flags, s->conn_err_type, txn->flags, txn->req.flags, txn->rsp.flags, txn->status);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100206 }
207 else {
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200208 chunk_appendf(&trace_buf, " - t=%p s=(%p,0x%08x,0x%x) scf=(%p,%d,0x%08x) scb=(%p,%d,0x%08x) retries=%d",
Christopher Fauletc77ceb62022-04-04 11:08:42 +0200209 task, s, s->flags, s->conn_err_type,
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200210 s->scf, s->scf->state, s->scf->flags,
211 s->scb, s->scb->state, s->scb->flags,
Christopher Fauletc77ceb62022-04-04 11:08:42 +0200212 s->conn_retries);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100213 }
214
215 if (src->verbosity == STRM_VERB_MINIMAL)
216 return;
217
218
219 /* If txn defined, don't display all channel info */
220 if (src->verbosity == STRM_VERB_SIMPLE || txn) {
221 chunk_appendf(&trace_buf, " req=(%p .fl=0x%08x .exp(r,w,a)=(%u,%u,%u))",
222 req, req->flags, req->rex, req->wex, req->analyse_exp);
223 chunk_appendf(&trace_buf, " res=(%p .fl=0x%08x .exp(r,w,a)=(%u,%u,%u))",
224 res, res->flags, res->rex, res->wex, res->analyse_exp);
225 }
226 else {
227 chunk_appendf(&trace_buf, " req=(%p .fl=0x%08x .ana=0x%08x .exp(r,w,a)=(%u,%u,%u) .o=%lu .tot=%llu .to_fwd=%u)",
228 req, req->flags, req->analysers, req->rex, req->wex, req->analyse_exp,
Willy Tarreaue18f53e2019-11-27 15:41:31 +0100229 (long)req->output, req->total, req->to_forward);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100230 chunk_appendf(&trace_buf, " res=(%p .fl=0x%08x .ana=0x%08x .exp(r,w,a)=(%u,%u,%u) .o=%lu .tot=%llu .to_fwd=%u)",
231 res, res->flags, res->analysers, res->rex, res->wex, res->analyse_exp,
Willy Tarreaue18f53e2019-11-27 15:41:31 +0100232 (long)res->output, res->total, res->to_forward);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100233 }
234
235 if (src->verbosity == STRM_VERB_SIMPLE ||
236 (src->verbosity == STRM_VERB_ADVANCED && src->level < TRACE_LEVEL_DATA))
237 return;
238
239 /* channels' buffer info */
240 if (s->flags & SF_HTX) {
241 struct htx *rqhtx = htxbuf(&req->buf);
242 struct htx *rphtx = htxbuf(&res->buf);
243
244 chunk_appendf(&trace_buf, " htx=(%u/%u#%u, %u/%u#%u)",
245 rqhtx->data, rqhtx->size, htx_nbblks(rqhtx),
246 rphtx->data, rphtx->size, htx_nbblks(rphtx));
247 }
248 else {
249 chunk_appendf(&trace_buf, " buf=(%u@%p+%u/%u, %u@%p+%u/%u)",
250 (unsigned int)b_data(&req->buf), b_orig(&req->buf),
251 (unsigned int)b_head_ofs(&req->buf), (unsigned int)b_size(&req->buf),
Christopher Faulet5ce12992022-03-08 15:48:55 +0100252 (unsigned int)b_data(&res->buf), b_orig(&res->buf),
253 (unsigned int)b_head_ofs(&res->buf), (unsigned int)b_size(&res->buf));
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100254 }
255
256 /* If msg defined, display htx info if defined (level > USER) */
257 if (src->level > TRACE_LEVEL_USER && htx && htx_nbblks(htx)) {
258 int full = 0;
259
260 /* Full htx info (level > STATE && verbosity > SIMPLE) */
261 if (src->level > TRACE_LEVEL_STATE) {
262 if (src->verbosity == STRM_VERB_COMPLETE)
263 full = 1;
264 }
265
266 chunk_memcat(&trace_buf, "\n\t", 2);
267 htx_dump(&trace_buf, htx, full);
268 }
269}
270
Willy Tarreaub49672d2022-05-27 10:13:37 +0200271/* Upgrade an existing stream for stream connector <sc>. Return < 0 on error. This
Christopher Faulet13a35e52021-12-20 15:34:16 +0100272 * is only valid right after a TCP to H1 upgrade. The stream should be
273 * "reativated" by removing SF_IGNORE flag. And the right mode must be set. On
Christopher Faulet16df1782020-12-04 16:47:41 +0100274 * success, <input> buffer is transferred to the stream and thus points to
275 * BUF_NULL. On error, it is unchanged and it is the caller responsibility to
Christopher Faulet4ef84c92021-01-21 17:36:12 +0100276 * release it (this never happens for now).
277 */
Willy Tarreaudf1a2fc2022-05-27 11:11:15 +0200278int stream_upgrade_from_sc(struct stconn *sc, struct buffer *input)
Christopher Faulet4ef84c92021-01-21 17:36:12 +0100279{
Willy Tarreaub49672d2022-05-27 10:13:37 +0200280 struct stream *s = __sc_strm(sc);
281 const struct mux_ops *mux = sc_mux_ops(sc);
Christopher Faulet4ef84c92021-01-21 17:36:12 +0100282
Christopher Faulet693b23b2022-02-28 09:09:05 +0100283 if (mux) {
Christopher Faulet13a35e52021-12-20 15:34:16 +0100284 if (mux->flags & MX_FL_HTX)
285 s->flags |= SF_HTX;
286 }
Christopher Faulet4ef84c92021-01-21 17:36:12 +0100287
288 if (!b_is_null(input)) {
289 /* Xfer the input buffer to the request channel. <input> will
290 * than point to BUF_NULL. From this point, it is the stream
291 * responsibility to release it.
292 */
293 s->req.buf = *input;
294 *input = BUF_NULL;
295 s->req.total = (IS_HTX_STRM(s) ? htxbuf(&s->req.buf)->data : b_data(&s->req.buf));
296 s->req.flags |= (s->req.total ? CF_READ_PARTIAL : 0);
297 }
298
299 s->flags &= ~SF_IGNORE;
300
301 task_wakeup(s->task, TASK_WOKEN_INIT);
302 return 0;
303}
304
Willy Tarreaub882dd82018-11-06 15:50:21 +0100305/* Callback used to wake up a stream when an input buffer is available. The
Willy Tarreau4596fe22022-05-17 19:07:51 +0200306 * stream <s>'s stream connectors are checked for a failed buffer allocation
Willy Tarreau15252cd2022-05-25 16:36:21 +0200307 * as indicated by the presence of the SC_FL_NEED_BUFF flag and the lack of a
Willy Tarreaub882dd82018-11-06 15:50:21 +0100308 * buffer, and and input buffer is assigned there (at most one). The function
309 * returns 1 and wakes the stream up if a buffer was taken, otherwise zero.
310 * It's designed to be called from __offer_buffer().
311 */
312int stream_buf_available(void *arg)
313{
314 struct stream *s = arg;
315
Willy Tarreau15252cd2022-05-25 16:36:21 +0200316 if (!s->req.buf.size && !s->req.pipe && s->scf->flags & SC_FL_NEED_BUFF &&
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100317 b_alloc(&s->req.buf))
Willy Tarreau0ed73c32022-05-25 07:48:07 +0200318 sc_have_buff(s->scf);
Willy Tarreau15252cd2022-05-25 16:36:21 +0200319 else if (!s->res.buf.size && !s->res.pipe && s->scb->flags & SC_FL_NEED_BUFF &&
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100320 b_alloc(&s->res.buf))
Willy Tarreau0ed73c32022-05-25 07:48:07 +0200321 sc_have_buff(s->scb);
Willy Tarreaub882dd82018-11-06 15:50:21 +0100322 else
323 return 0;
324
325 task_wakeup(s->task, TASK_WOKEN_RES);
326 return 1;
327
328}
329
Willy Tarreau9903f0e2015-04-04 18:50:31 +0200330/* This function is called from the session handler which detects the end of
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200331 * handshake, in order to complete initialization of a valid stream. It must be
Joseph Herlant4cc8d0d2018-11-15 09:14:14 -0800332 * called with a completely initialized session. It returns the pointer to
Willy Tarreau73b65ac2015-04-08 18:26:29 +0200333 * the newly created stream, or NULL in case of fatal error. The client-facing
Willy Tarreau87787ac2017-08-28 16:22:54 +0200334 * end point is assigned to <origin>, which must be valid. The stream's task
335 * is configured with a nice value inherited from the listener's nice if any.
336 * The task's context is set to the new stream, and its function is set to
Christopher Faulet16df1782020-12-04 16:47:41 +0100337 * process_stream(). Target and analysers are null. <input> is used as input
338 * buffer for the request channel and may contain data. On success, it is
339 * transfer to the stream and <input> is set to BUF_NULL. On error, <input>
340 * buffer is unchanged and it is the caller responsibility to release it.
Willy Tarreau2542b532012-08-31 16:01:23 +0200341 */
Willy Tarreaub49672d2022-05-27 10:13:37 +0200342struct stream *stream_new(struct session *sess, struct stconn *sc, struct buffer *input)
Willy Tarreau2542b532012-08-31 16:01:23 +0200343{
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200344 struct stream *s;
Willy Tarreau87787ac2017-08-28 16:22:54 +0200345 struct task *t;
Willy Tarreau2542b532012-08-31 16:01:23 +0200346
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100347 DBG_TRACE_ENTER(STRM_EV_STRM_NEW);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100348 if (unlikely((s = pool_alloc(pool_head_stream)) == NULL))
Willy Tarreau87787ac2017-08-28 16:22:54 +0200349 goto out_fail_alloc;
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200350
351 /* minimum stream initialization required for an embryonic stream is
352 * fairly low. We need very little to execute L4 ACLs, then we need a
353 * task to make the client-side connection live on its own.
354 * - flags
355 * - stick-entry tracking
356 */
357 s->flags = 0;
Willy Tarreaufb9f5842015-04-05 18:19:23 +0200358 s->logs.logwait = sess->fe->to_log;
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200359 s->logs.level = 0;
Willy Tarreau99eb0f12015-04-05 12:03:54 +0200360 tv_zero(&s->logs.tv_request);
361 s->logs.t_queue = -1;
362 s->logs.t_connect = -1;
363 s->logs.t_data = -1;
364 s->logs.t_close = 0;
365 s->logs.bytes_in = s->logs.bytes_out = 0;
Patrick Hemmerffe5e8c2018-05-11 12:52:31 -0400366 s->logs.prx_queue_pos = 0; /* we get the number of pending conns before us */
367 s->logs.srv_queue_pos = 0; /* we will get this number soon */
Baptiste Assmann333939c2019-01-21 08:34:50 +0100368 s->obj_type = OBJ_TYPE_STREAM;
Willy Tarreau99eb0f12015-04-05 12:03:54 +0200369
Christopher Faulet15e525f2020-09-30 14:03:54 +0200370 s->logs.accept_date = sess->accept_date;
371 s->logs.tv_accept = sess->tv_accept;
372 s->logs.t_handshake = sess->t_handshake;
Christopher Faulet7a6c5132020-09-30 13:49:56 +0200373 s->logs.t_idle = sess->t_idle;
Christopher Fauletb3484d62018-11-29 15:19:05 +0100374
Willy Tarreau99eb0f12015-04-05 12:03:54 +0200375 /* default logging function */
376 s->do_log = strm_log;
377
378 /* default error reporting function, may be changed by analysers */
379 s->srv_error = default_srv_error;
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200380
381 /* Initialise the current rule list pointer to NULL. We are sure that
382 * any rulelist match the NULL pointer.
383 */
384 s->current_rule_list = NULL;
Remi Gacogne7fb9de22015-07-22 17:10:58 +0200385 s->current_rule = NULL;
Christopher Faulet2747fbb2020-07-28 11:56:13 +0200386 s->rules_exp = TICK_ETERNITY;
Willy Tarreauc6dae862022-03-09 17:23:10 +0100387 s->last_rule_file = NULL;
388 s->last_rule_line = 0;
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200389
Willy Tarreaua68f7622015-09-21 17:48:24 +0200390 /* Copy SC counters for the stream. We don't touch refcounts because
391 * any reference we have is inherited from the session. Since the stream
392 * doesn't exist without the session, the session's existence guarantees
393 * we don't lose the entry. During the store operation, the stream won't
394 * touch these ones.
Thierry FOURNIER827752e2015-08-18 11:34:18 +0200395 */
Thierry FOURNIERc8fdb982015-08-16 12:03:39 +0200396 memcpy(s->stkctr, sess->stkctr, sizeof(s->stkctr));
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200397
398 s->sess = sess;
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200399
Willy Tarreaub9813182021-02-24 11:29:51 +0100400 s->stream_epoch = _HA_ATOMIC_LOAD(&stream_epoch);
Willy Tarreau18515722021-04-06 11:57:41 +0200401 s->uniq_id = _HA_ATOMIC_FETCH_ADD(&global.req_count, 1);
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200402
Willy Tarreau87b09662015-04-03 00:22:06 +0200403 /* OK, we're keeping the stream, so let's properly initialize the stream */
Willy Tarreau2542b532012-08-31 16:01:23 +0200404 LIST_INIT(&s->back_refs);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100405
Willy Tarreau90f366b2021-02-20 11:49:49 +0100406 LIST_INIT(&s->buffer_wait.list);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100407 s->buffer_wait.target = s;
Willy Tarreaub882dd82018-11-06 15:50:21 +0100408 s->buffer_wait.wakeup_cb = stream_buf_available;
Willy Tarreauf8a49ea2013-10-14 21:32:07 +0200409
Willy Tarreaufa1258f2021-04-10 23:00:53 +0200410 s->call_rate.curr_tick = s->call_rate.curr_ctr = s->call_rate.prev_ctr = 0;
William Lallemandcf62f7e2018-10-26 14:47:40 +0200411 s->pcli_next_pid = 0;
William Lallemandebf61802018-12-11 16:10:57 +0100412 s->pcli_flags = 0;
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100413 s->unique_id = IST_NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200414
Willy Tarreaubeeabf52021-10-01 18:23:30 +0200415 if ((t = task_new_here()) == NULL)
Willy Tarreau87787ac2017-08-28 16:22:54 +0200416 goto out_fail_alloc;
417
Willy Tarreau02a0c0e2015-04-04 18:08:21 +0200418 s->task = t;
Christopher Faulet9d810ca2016-12-08 22:33:52 +0100419 s->pending_events = 0;
Christopher Faulet909f3182022-03-29 15:42:09 +0200420 s->conn_retries = 0;
Christopher Fauletae024ce2022-03-29 19:02:31 +0200421 s->conn_exp = TICK_ETERNITY;
Christopher Faulet50264b42022-03-30 19:39:30 +0200422 s->conn_err_type = STRM_ET_NONE;
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200423 s->prev_conn_state = SC_ST_INI;
Willy Tarreaud1769b82015-04-06 00:25:48 +0200424 t->process = process_stream;
Willy Tarreau2542b532012-08-31 16:01:23 +0200425 t->context = s;
426 t->expire = TICK_ETERNITY;
Willy Tarreau87787ac2017-08-28 16:22:54 +0200427 if (sess->listener)
428 t->nice = sess->listener->nice;
Willy Tarreau2542b532012-08-31 16:01:23 +0200429
Willy Tarreau87b09662015-04-03 00:22:06 +0200430 /* Note: initially, the stream's backend points to the frontend.
Willy Tarreau2542b532012-08-31 16:01:23 +0200431 * This changes later when switching rules are executed or
432 * when the default backend is assigned.
433 */
Willy Tarreaue36cbcb2015-04-03 15:40:56 +0200434 s->be = sess->fe;
Willy Tarreaucb7dd012015-04-03 22:16:32 +0200435 s->req_cap = NULL;
436 s->res_cap = NULL;
Willy Tarreau2542b532012-08-31 16:01:23 +0200437
Willy Tarreauebcd4842015-06-19 11:59:02 +0200438 /* Initialise all the variables contexts even if not used.
439 * This permits to prune these contexts without errors.
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200440 */
Willy Tarreaub7bfcb32021-08-31 08:13:25 +0200441 vars_init_head(&s->vars_txn, SCOPE_TXN);
442 vars_init_head(&s->vars_reqres, SCOPE_REQ);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200443
Christopher Faulet0dd566b2021-12-23 12:06:45 +0100444 /* Set SF_HTX flag for HTTP frontends. */
445 if (sess->fe->mode == PR_MODE_HTTP)
446 s->flags |= SF_HTX;
447
Willy Tarreaub49672d2022-05-27 10:13:37 +0200448 s->scf = sc;
Willy Tarreau19c65a92022-05-27 08:49:24 +0200449 if (sc_attach_strm(s->scf, s) < 0)
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200450 goto out_fail_attach_scf;
Christopher Fauleta9e8b392022-03-23 11:01:09 +0100451
Willy Tarreaua0b58b52022-05-27 08:33:53 +0200452 s->scb = sc_new_from_strm(s, SC_FL_ISBACK);
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200453 if (!s->scb)
454 goto out_fail_alloc_scb;
Christopher Faulet95a61e82021-12-22 14:22:03 +0100455
Willy Tarreau74568cf2022-05-27 09:03:30 +0200456 sc_set_state(s->scf, SC_ST_EST);
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200457 s->scf->hcto = sess->fe->timeout.clientfin;
Christopher Faulet0dd566b2021-12-23 12:06:45 +0100458
Christopher Fauletcda94ac2021-12-23 17:28:17 +0100459 if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
Willy Tarreaucb041662022-05-17 19:44:42 +0200460 s->scf->flags |= SC_FL_INDEP_STR;
Christopher Faulet0dd566b2021-12-23 12:06:45 +0100461
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200462 s->scb->hcto = TICK_ETERNITY;
Christopher Faulet0dd566b2021-12-23 12:06:45 +0100463 if (likely(sess->fe->options2 & PR_O2_INDEPSTR))
Willy Tarreaucb041662022-05-17 19:44:42 +0200464 s->scb->flags |= SC_FL_INDEP_STR;
Willy Tarreau984fca92017-12-20 16:31:43 +0100465
Willy Tarreaub49672d2022-05-27 10:13:37 +0200466 if (sc_ep_test(sc, SE_FL_WEBSOCKET))
Christopher Faulet13a35e52021-12-20 15:34:16 +0100467 s->flags |= SF_WEBSOCKET;
Willy Tarreaub49672d2022-05-27 10:13:37 +0200468 if (sc_conn(sc)) {
469 const struct mux_ops *mux = sc_mux_ops(sc);
Christopher Faulet897d6122021-12-17 17:28:35 +0100470
Christopher Faulet78ed7f22022-03-30 16:31:41 +0200471 if (mux && mux->flags & MX_FL_HTX)
472 s->flags |= SF_HTX;
Christopher Fauleta7422932021-12-15 11:42:23 +0100473 }
474
Willy Tarreau87b09662015-04-03 00:22:06 +0200475 stream_init_srv_conn(s);
Willy Tarreau9b82d942016-12-05 00:26:31 +0100476 s->target = sess->listener ? sess->listener->default_target : NULL;
477
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200478 s->pend_pos = NULL;
Patrick Hemmer268a7072018-05-11 12:52:31 -0400479 s->priority_class = 0;
480 s->priority_offset = 0;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200481
482 /* init store persistence */
483 s->store_count = 0;
484
Christopher Faulet16df1782020-12-04 16:47:41 +0100485 channel_init(&s->req);
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100486 s->req.flags |= CF_READ_ATTACHED; /* the producer is already connected */
Christopher Faulete9382e02022-03-07 15:31:46 +0100487 s->req.analysers = sess->listener ? sess->listener->analysers : sess->fe->fe_req_ana;
Willy Tarreaue223e3b2017-11-18 15:39:10 +0100488
Christopher Faulet57e4a1b2021-03-15 17:09:27 +0100489 if (IS_HTX_STRM(s)) {
490 /* Be sure to have HTTP analysers because in case of
491 * "destructive" stream upgrade, they may be missing (e.g
492 * TCP>H2)
493 */
494 s->req.analysers |= AN_REQ_WAIT_HTTP|AN_REQ_HTTP_PROCESS_FE;
495 }
496
Willy Tarreaue223e3b2017-11-18 15:39:10 +0100497 if (!sess->fe->fe_req_ana) {
498 channel_auto_connect(&s->req); /* don't wait to establish connection */
499 channel_auto_close(&s->req); /* let the producer forward close requests */
500 }
Willy Tarreauc8815ef2015-04-05 18:15:59 +0200501
502 s->req.rto = sess->fe->timeout.client;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100503 s->req.wto = TICK_ETERNITY;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100504 s->req.rex = TICK_ETERNITY;
505 s->req.wex = TICK_ETERNITY;
506 s->req.analyse_exp = TICK_ETERNITY;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200507
Christopher Faulet16df1782020-12-04 16:47:41 +0100508 channel_init(&s->res);
Willy Tarreauef573c02014-11-28 14:17:09 +0100509 s->res.flags |= CF_ISRESP;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100510 s->res.analysers = 0;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200511
Willy Tarreaue36cbcb2015-04-03 15:40:56 +0200512 if (sess->fe->options2 & PR_O2_NODELAY) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100513 s->req.flags |= CF_NEVER_WAIT;
514 s->res.flags |= CF_NEVER_WAIT;
Willy Tarreau96e31212011-05-30 18:10:30 +0200515 }
516
Willy Tarreauc8815ef2015-04-05 18:15:59 +0200517 s->res.wto = sess->fe->timeout.client;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100518 s->res.rto = TICK_ETERNITY;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100519 s->res.rex = TICK_ETERNITY;
520 s->res.wex = TICK_ETERNITY;
521 s->res.analyse_exp = TICK_ETERNITY;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200522
Willy Tarreaueee5b512015-04-03 23:46:31 +0200523 s->txn = NULL;
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100524 s->hlua = NULL;
Thierry FOURNIER65f34c62015-02-16 20:11:43 +0100525
Emeric Brun08622d32020-12-23 17:41:43 +0100526 s->resolv_ctx.requester = NULL;
527 s->resolv_ctx.hostname_dn = NULL;
528 s->resolv_ctx.hostname_dn_len = 0;
529 s->resolv_ctx.parent = NULL;
Frédéric Lécaillebed883a2019-04-23 17:26:33 +0200530
Amaury Denoyellefb504432020-12-10 13:43:53 +0100531 s->tunnel_timeout = TICK_ETERNITY;
532
Willy Tarreaub4e34762021-09-30 19:02:18 +0200533 LIST_APPEND(&th_ctx->streams, &s->list);
Emeric Brun6b35e9b2017-06-30 16:23:45 +0200534
Christopher Faulet92d36382015-11-05 13:35:03 +0100535 if (flt_stream_init(s) < 0 || flt_stream_start(s) < 0)
Christopher Fauletd7c91962015-04-30 11:48:27 +0200536 goto out_fail_accept;
537
Willy Tarreau369d5aa2022-05-27 16:49:18 +0200538 /* just in case the caller would have pre-disabled it */
539 se_will_consume(s->scf->sedesc);
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200540
Willy Tarreaufb9f5842015-04-05 18:19:23 +0200541 if (sess->fe->accept && sess->fe->accept(s) < 0)
Willy Tarreauc5a7ff42015-04-05 11:52:08 +0200542 goto out_fail_accept;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200543
Christopher Faulet16df1782020-12-04 16:47:41 +0100544 if (!b_is_null(input)) {
545 /* Xfer the input buffer to the request channel. <input> will
546 * than point to BUF_NULL. From this point, it is the stream
547 * responsibility to release it.
548 */
549 s->req.buf = *input;
550 *input = BUF_NULL;
Christopher Fauletc43fca02020-12-04 17:22:49 +0100551 s->req.total = (IS_HTX_STRM(s) ? htxbuf(&s->req.buf)->data : b_data(&s->req.buf));
Christopher Faulet16df1782020-12-04 16:47:41 +0100552 s->req.flags |= (s->req.total ? CF_READ_PARTIAL : 0);
553 }
554
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200555 /* it is important not to call the wakeup function directly but to
556 * pass through task_wakeup(), because this one knows how to apply
Emeric Brun5f77fef2017-05-29 15:26:51 +0200557 * priorities to tasks. Using multi thread we must be sure that
558 * stream is fully initialized before calling task_wakeup. So
559 * the caller must handle the task_wakeup
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200560 */
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100561 DBG_TRACE_LEAVE(STRM_EV_STRM_NEW, s);
Christopher Faulet13a35e52021-12-20 15:34:16 +0100562 task_wakeup(s->task, TASK_WOKEN_INIT);
Willy Tarreau02d86382015-04-05 12:00:52 +0200563 return s;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200564
565 /* Error unrolling */
Willy Tarreauc5a7ff42015-04-05 11:52:08 +0200566 out_fail_accept:
Christopher Faulet92d36382015-11-05 13:35:03 +0100567 flt_stream_release(s, 0);
Willy Tarreau2b718102021-04-21 07:32:39 +0200568 LIST_DELETE(&s->list);
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200569 out_fail_attach_scf:
Willy Tarreaua0b58b52022-05-27 08:33:53 +0200570 sc_free(s->scb);
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200571 out_fail_alloc_scb:
Christopher Faulet0dd566b2021-12-23 12:06:45 +0100572 task_destroy(t);
Willy Tarreau87787ac2017-08-28 16:22:54 +0200573 out_fail_alloc:
Willy Tarreaubafbe012017-11-24 17:34:44 +0100574 pool_free(pool_head_stream, s);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100575 DBG_TRACE_DEVEL("leaving on error", STRM_EV_STRM_NEW|STRM_EV_STRM_ERR);
Willy Tarreau02d86382015-04-05 12:00:52 +0200576 return NULL;
Willy Tarreau81f9aa32010-06-01 17:45:26 +0200577}
578
Willy Tarreaubaaee002006-06-26 02:48:02 +0200579/*
Willy Tarreau87b09662015-04-03 00:22:06 +0200580 * frees the context associated to a stream. It must have been removed first.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200581 */
Christopher Fauletab5d1dc2022-05-12 14:56:55 +0200582void stream_free(struct stream *s)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200583{
Willy Tarreau9ad7bd42015-04-03 19:19:59 +0200584 struct session *sess = strm_sess(s);
585 struct proxy *fe = sess->fe;
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100586 struct bref *bref, *back;
Willy Tarreaua4cda672010-06-06 18:28:49 +0200587 int i;
Willy Tarreau0f7562b2007-01-07 15:46:13 +0100588
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100589 DBG_TRACE_POINT(STRM_EV_STRM_FREE, s);
590
Willy Tarreau0ad46fa2019-05-17 14:20:05 +0200591 /* detach the stream from its own task before even releasing it so
592 * that walking over a task list never exhibits a dying stream.
593 */
594 s->task->context = NULL;
595 __ha_barrier_store();
596
Willy Tarreaud0ad4a82018-07-25 11:13:53 +0200597 pendconn_free(s);
Willy Tarreau922a8062008-12-04 09:33:58 +0100598
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100599 if (objt_server(s->target)) { /* there may be requests left pending in queue */
Willy Tarreaue7dff022015-04-03 01:14:29 +0200600 if (s->flags & SF_CURR_SESS) {
601 s->flags &= ~SF_CURR_SESS;
Willy Tarreau4781b152021-04-06 13:53:36 +0200602 _HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
Willy Tarreau1e62de62008-11-11 20:20:02 +0100603 }
Willy Tarreau88bc8002021-12-06 07:01:02 +0000604 if (may_dequeue_tasks(__objt_server(s->target), s->be))
605 process_srv_queue(__objt_server(s->target));
Willy Tarreau1e62de62008-11-11 20:20:02 +0100606 }
Willy Tarreau922a8062008-12-04 09:33:58 +0100607
Willy Tarreau7c669d72008-06-20 15:04:11 +0200608 if (unlikely(s->srv_conn)) {
Willy Tarreau87b09662015-04-03 00:22:06 +0200609 /* the stream still has a reserved slot on a server, but
Willy Tarreau7c669d72008-06-20 15:04:11 +0200610 * it should normally be only the same as the one above,
611 * so this should not happen in fact.
612 */
613 sess_change_server(s, NULL);
614 }
615
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100616 if (s->req.pipe)
617 put_pipe(s->req.pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100618
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100619 if (s->res.pipe)
620 put_pipe(s->res.pipe);
Willy Tarreau259de1b2009-01-18 21:56:21 +0100621
Willy Tarreaubf883e02014-11-25 21:10:35 +0100622 /* We may still be present in the buffer wait queue */
Willy Tarreau2b718102021-04-21 07:32:39 +0200623 if (LIST_INLIST(&s->buffer_wait.list))
Willy Tarreau90f366b2021-02-20 11:49:49 +0100624 LIST_DEL_INIT(&s->buffer_wait.list);
Willy Tarreau21046592020-02-26 10:39:36 +0100625
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200626 if (s->req.buf.size || s->res.buf.size) {
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100627 int count = !!s->req.buf.size + !!s->res.buf.size;
628
Willy Tarreaue0d0b402019-08-08 08:06:27 +0200629 b_free(&s->req.buf);
630 b_free(&s->res.buf);
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100631 offer_buffers(NULL, count);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100632 }
Willy Tarreau9b28e032012-10-12 23:49:43 +0200633
Tim Duesterhusa17e6622020-03-05 20:19:02 +0100634 pool_free(pool_head_uniqueid, s->unique_id.ptr);
635 s->unique_id = IST_NULL;
Olivier Houchard32211a12019-02-01 18:10:46 +0100636
Christopher Faulet03fb1b22020-02-24 16:26:55 +0100637 flt_stream_stop(s);
638 flt_stream_release(s, 0);
639
Thierry FOURNIER2c8b54e2016-12-17 12:45:32 +0100640 hlua_ctx_destroy(s->hlua);
641 s->hlua = NULL;
Willy Tarreaueee5b512015-04-03 23:46:31 +0200642 if (s->txn)
Christopher Faulet75f619a2021-03-08 19:12:58 +0100643 http_destroy_txn(s);
Willy Tarreau46023632010-01-07 22:51:47 +0100644
Willy Tarreau1e954912012-10-12 17:50:05 +0200645 /* ensure the client-side transport layer is destroyed */
Christopher Faulet13a35e52021-12-20 15:34:16 +0100646 /* Be sure it is useless !! */
647 /* if (cli_cs) */
648 /* cs_close(cli_cs); */
Willy Tarreau1e954912012-10-12 17:50:05 +0200649
Willy Tarreaua4cda672010-06-06 18:28:49 +0200650 for (i = 0; i < s->store_count; i++) {
651 if (!s->store[i].ts)
652 continue;
653 stksess_free(s->store[i].table, s->store[i].ts);
654 s->store[i].ts = NULL;
655 }
656
Emeric Brun08622d32020-12-23 17:41:43 +0100657 if (s->resolv_ctx.requester) {
Emeric Brun21fbeed2020-12-23 18:01:04 +0100658 __decl_thread(struct resolvers *resolvers = s->resolv_ctx.parent->arg.resolv.resolvers);
Christopher Faulet5098a082020-07-22 11:46:32 +0200659
660 HA_SPIN_LOCK(DNS_LOCK, &resolvers->lock);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100661 ha_free(&s->resolv_ctx.hostname_dn);
Emeric Brun08622d32020-12-23 17:41:43 +0100662 s->resolv_ctx.hostname_dn_len = 0;
Willy Tarreau6878f802021-10-20 14:07:31 +0200663 resolv_unlink_resolution(s->resolv_ctx.requester);
Christopher Faulet5098a082020-07-22 11:46:32 +0200664 HA_SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
Baptiste Assmann333939c2019-01-21 08:34:50 +0100665
Emeric Brun08622d32020-12-23 17:41:43 +0100666 pool_free(resolv_requester_pool, s->resolv_ctx.requester);
667 s->resolv_ctx.requester = NULL;
Baptiste Assmann333939c2019-01-21 08:34:50 +0100668 }
669
Willy Tarreau92fb9832007-10-16 17:34:28 +0200670 if (fe) {
Christopher Faulet59399252019-11-07 14:27:52 +0100671 if (s->req_cap) {
672 struct cap_hdr *h;
673 for (h = fe->req_cap; h; h = h->next)
674 pool_free(h->pool, s->req_cap[h->index]);
Willy Tarreau47af3172022-06-23 11:46:14 +0200675 pool_free(fe->req_cap_pool, s->req_cap);
Christopher Faulet59399252019-11-07 14:27:52 +0100676 }
677
678 if (s->res_cap) {
679 struct cap_hdr *h;
680 for (h = fe->rsp_cap; h; h = h->next)
681 pool_free(h->pool, s->res_cap[h->index]);
Willy Tarreau47af3172022-06-23 11:46:14 +0200682 pool_free(fe->rsp_cap_pool, s->res_cap);
Christopher Faulet59399252019-11-07 14:27:52 +0100683 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200684 }
Willy Tarreau0937bc42009-12-22 15:03:09 +0100685
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200686 /* Cleanup all variable contexts. */
Willy Tarreaucda7f3f2018-10-28 13:44:36 +0100687 if (!LIST_ISEMPTY(&s->vars_txn.head))
688 vars_prune(&s->vars_txn, s->sess, s);
689 if (!LIST_ISEMPTY(&s->vars_reqres.head))
690 vars_prune(&s->vars_reqres, s->sess, s);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +0200691
Willy Tarreau87b09662015-04-03 00:22:06 +0200692 stream_store_counters(s);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200693
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100694 list_for_each_entry_safe(bref, back, &s->back_refs, users) {
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100695 /* we have to unlink all watchers. We must not relink them if
Willy Tarreau49de6852021-02-24 13:46:12 +0100696 * this stream was the last one in the list. This is safe to do
697 * here because we're touching our thread's list so we know
698 * that other streams are not active, and the watchers will
699 * only touch their node under thread isolation.
Willy Tarreaufd3828e2009-02-22 15:17:24 +0100700 */
Willy Tarreau49de6852021-02-24 13:46:12 +0100701 LIST_DEL_INIT(&bref->users);
Willy Tarreaub4e34762021-09-30 19:02:18 +0200702 if (s->list.n != &th_ctx->streams)
Willy Tarreau2b718102021-04-21 07:32:39 +0200703 LIST_APPEND(&LIST_ELEM(s->list.n, struct stream *, list)->back_refs, &bref->users);
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100704 bref->ref = s->list.n;
Willy Tarreau49de6852021-02-24 13:46:12 +0100705 __ha_barrier_store();
Willy Tarreau62e4f1d2008-12-07 20:16:23 +0100706 }
Willy Tarreau2b718102021-04-21 07:32:39 +0200707 LIST_DELETE(&s->list);
Emeric Brun6b35e9b2017-06-30 16:23:45 +0200708
Willy Tarreaua0b58b52022-05-27 08:33:53 +0200709 sc_destroy(s->scb);
710 sc_destroy(s->scf);
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200711
Willy Tarreaubafbe012017-11-24 17:34:44 +0100712 pool_free(pool_head_stream, s);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200713
714 /* We may want to free the maximum amount of pools if the proxy is stopping */
Christopher Fauletdfd10ab2021-10-06 14:24:19 +0200715 if (fe && unlikely(fe->flags & (PR_FL_DISABLED|PR_FL_STOPPED))) {
Willy Tarreaubafbe012017-11-24 17:34:44 +0100716 pool_flush(pool_head_buffer);
717 pool_flush(pool_head_http_txn);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100718 pool_flush(pool_head_requri);
719 pool_flush(pool_head_capture);
720 pool_flush(pool_head_stream);
721 pool_flush(pool_head_session);
722 pool_flush(pool_head_connection);
723 pool_flush(pool_head_pendconn);
724 pool_flush(fe->req_cap_pool);
725 pool_flush(fe->rsp_cap_pool);
Willy Tarreau632f5a72007-07-11 10:42:35 +0200726 }
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200727}
728
Willy Tarreau656859d2014-11-25 19:46:36 +0100729
Willy Tarreau87b09662015-04-03 00:22:06 +0200730/* Allocates a work buffer for stream <s>. It is meant to be called inside
731 * process_stream(). It will only allocate the side needed for the function
Willy Tarreaubc39a5d2015-04-20 15:52:18 +0200732 * to work fine, which is the response buffer so that an error message may be
733 * built and returned. Response buffers may be allocated from the reserve, this
734 * is critical to ensure that a response may always flow and will never block a
735 * server from releasing a connection. Returns 0 in case of failure, non-zero
736 * otherwise.
Willy Tarreau656859d2014-11-25 19:46:36 +0100737 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100738static int stream_alloc_work_buffer(struct stream *s)
Willy Tarreau656859d2014-11-25 19:46:36 +0100739{
Willy Tarreaud68d4f12021-03-22 14:44:31 +0100740 if (b_alloc(&s->res.buf))
Willy Tarreau656859d2014-11-25 19:46:36 +0100741 return 1;
Willy Tarreau656859d2014-11-25 19:46:36 +0100742 return 0;
743}
744
745/* releases unused buffers after processing. Typically used at the end of the
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100746 * update() functions. It will try to wake up as many tasks/applets as the
747 * number of buffers that it releases. In practice, most often streams are
748 * blocked on a single buffer, so it makes sense to try to wake two up when two
749 * buffers are released at once.
Willy Tarreau656859d2014-11-25 19:46:36 +0100750 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200751void stream_release_buffers(struct stream *s)
Willy Tarreau656859d2014-11-25 19:46:36 +0100752{
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100753 int offer = 0;
Willy Tarreau656859d2014-11-25 19:46:36 +0100754
Willy Tarreau0c7ed5d2018-07-10 09:53:31 +0200755 if (c_size(&s->req) && c_empty(&s->req)) {
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100756 offer++;
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100757 b_free(&s->req.buf);
758 }
Willy Tarreau0c7ed5d2018-07-10 09:53:31 +0200759 if (c_size(&s->res) && c_empty(&s->res)) {
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100760 offer++;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100761 b_free(&s->res.buf);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100762 }
Willy Tarreau656859d2014-11-25 19:46:36 +0100763
Willy Tarreaubf883e02014-11-25 21:10:35 +0100764 /* if we're certain to have at least 1 buffer available, and there is
765 * someone waiting, we can wake up a waiter and offer them.
766 */
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100767 if (offer)
Willy Tarreau4d77bbf2021-02-20 12:02:46 +0100768 offer_buffers(s, offer);
Willy Tarreau656859d2014-11-25 19:46:36 +0100769}
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200770
Willy Tarreau87b09662015-04-03 00:22:06 +0200771void stream_process_counters(struct stream *s)
Willy Tarreau30e71012007-11-26 20:15:35 +0100772{
Willy Tarreaufb0afa72015-04-03 14:46:27 +0200773 struct session *sess = s->sess;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100774 unsigned long long bytes;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100775 int i;
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100776
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100777 bytes = s->req.total - s->logs.bytes_in;
778 s->logs.bytes_in = s->req.total;
779 if (bytes) {
Olivier Houcharddc6111e2019-03-08 18:54:51 +0100780 _HA_ATOMIC_ADD(&sess->fe->fe_counters.bytes_in, bytes);
781 _HA_ATOMIC_ADD(&s->be->be_counters.bytes_in, bytes);
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100782
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100783 if (objt_server(s->target))
Willy Tarreau88bc8002021-12-06 07:01:02 +0000784 _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.bytes_in, bytes);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200785
Willy Tarreaufb0afa72015-04-03 14:46:27 +0200786 if (sess->listener && sess->listener->counters)
Olivier Houcharddc6111e2019-03-08 18:54:51 +0100787 _HA_ATOMIC_ADD(&sess->listener->counters->bytes_in, bytes);
Willy Tarreau855e4bb2010-06-18 18:33:32 +0200788
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100789 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Christopher Faulet84600632020-10-06 13:52:40 +0200790 if (!stkctr_inc_bytes_in_ctr(&s->stkctr[i], bytes))
791 stkctr_inc_bytes_in_ctr(&sess->stkctr[i], bytes);
Willy Tarreau30e71012007-11-26 20:15:35 +0100792 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100793 }
794
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100795 bytes = s->res.total - s->logs.bytes_out;
796 s->logs.bytes_out = s->res.total;
797 if (bytes) {
Olivier Houcharddc6111e2019-03-08 18:54:51 +0100798 _HA_ATOMIC_ADD(&sess->fe->fe_counters.bytes_out, bytes);
799 _HA_ATOMIC_ADD(&s->be->be_counters.bytes_out, bytes);
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100800
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100801 if (objt_server(s->target))
Willy Tarreau88bc8002021-12-06 07:01:02 +0000802 _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.bytes_out, bytes);
Krzysztof Piotr Oledzkiaeebf9b2009-10-04 15:43:17 +0200803
Willy Tarreaufb0afa72015-04-03 14:46:27 +0200804 if (sess->listener && sess->listener->counters)
Olivier Houcharddc6111e2019-03-08 18:54:51 +0100805 _HA_ATOMIC_ADD(&sess->listener->counters->bytes_out, bytes);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200806
Willy Tarreau22ec1ea2014-11-27 20:45:39 +0100807 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Christopher Faulet84600632020-10-06 13:52:40 +0200808 if (!stkctr_inc_bytes_out_ctr(&s->stkctr[i], bytes))
809 stkctr_inc_bytes_out_ctr(&sess->stkctr[i], bytes);
Willy Tarreau30e71012007-11-26 20:15:35 +0100810 }
Krzysztof Piotr Oledzki583bc962007-11-24 22:12:47 +0100811 }
812}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200813
Christopher Faulet9125f3c2022-03-31 09:47:24 +0200814/*
815 * Returns a message to the client ; the connection is shut down for read,
816 * and the request is cleared so that no server connection can be initiated.
817 * The buffer is marked for read shutdown on the other side to protect the
818 * message, and the buffer write is enabled. The message is contained in a
819 * "chunk". If it is null, then an empty message is used. The reply buffer does
820 * not need to be empty before this, and its contents will not be overwritten.
821 * The primary goal of this function is to return error messages to a client.
822 */
823void stream_retnclose(struct stream *s, const struct buffer *msg)
824{
825 struct channel *ic = &s->req;
826 struct channel *oc = &s->res;
827
828 channel_auto_read(ic);
829 channel_abort(ic);
830 channel_auto_close(ic);
831 channel_erase(ic);
832 channel_truncate(oc);
833
834 if (likely(msg && msg->data))
835 co_inject(oc, msg->area, msg->data);
836
837 oc->wex = tick_add_ifset(now_ms, oc->wto);
838 channel_auto_read(oc);
839 channel_auto_close(oc);
840 channel_shutr_now(oc);
841}
842
Amaury Denoyelleb7150782020-12-10 13:43:51 +0100843int stream_set_timeout(struct stream *s, enum act_timeout_name name, int timeout)
844{
Amaury Denoyelle90d3d882020-12-10 13:43:52 +0100845 switch (name) {
846 case ACT_TIMEOUT_SERVER:
847 s->req.wto = timeout;
848 s->res.rto = timeout;
849 return 1;
850
Amaury Denoyellefb504432020-12-10 13:43:53 +0100851 case ACT_TIMEOUT_TUNNEL:
852 s->tunnel_timeout = timeout;
853 return 1;
854
Amaury Denoyelle90d3d882020-12-10 13:43:52 +0100855 default:
856 return 0;
857 }
Amaury Denoyelleb7150782020-12-10 13:43:51 +0100858}
859
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100860/*
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200861 * This function handles the transition between the SC_ST_CON state and the
862 * SC_ST_EST state. It must only be called after switching from SC_ST_CON (or
863 * SC_ST_INI or SC_ST_RDY) to SC_ST_EST, but only when a ->proto is defined.
864 * Note that it will switch the interface to SC_ST_DIS if we already have
Olivier Houchardaacc4052019-05-21 17:43:50 +0200865 * the CF_SHUTR flag, it means we were able to forward the request, and
866 * receive the response, before process_stream() had the opportunity to
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200867 * make the switch from SC_ST_CON to SC_ST_EST. When that happens, we want
Willy Tarreau3a9312a2020-01-09 18:43:15 +0100868 * to go through back_establish() anyway, to make sure the analysers run.
Willy Tarreaud66ed882019-06-05 18:02:04 +0200869 * Timeouts are cleared. Error are reported on the channel so that analysers
870 * can handle them.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100871 */
Willy Tarreau3a9312a2020-01-09 18:43:15 +0100872static void back_establish(struct stream *s)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100873{
Willy Tarreaufd9417b2022-05-18 16:23:22 +0200874 struct connection *conn = sc_conn(s->scb);
Willy Tarreau7b8c4f92014-11-28 15:15:44 +0100875 struct channel *req = &s->req;
876 struct channel *rep = &s->res;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100877
Christopher Faulet62e75742022-03-31 09:16:34 +0200878 DBG_TRACE_ENTER(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
Willy Tarreaud66ed882019-06-05 18:02:04 +0200879 /* First, centralize the timers information, and clear any irrelevant
880 * timeout.
881 */
Willy Tarreau0e37f1c2013-12-31 23:06:46 +0100882 s->logs.t_connect = tv_ms_elapsed(&s->logs.tv_accept, &now);
Christopher Fauletae024ce2022-03-29 19:02:31 +0200883 s->conn_exp = TICK_ETERNITY;
884 s->flags &= ~SF_CONN_EXP;
Willy Tarreaud66ed882019-06-05 18:02:04 +0200885
886 /* errors faced after sending data need to be reported */
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +0200887 if (sc_ep_test(s->scb, SE_FL_ERROR) && req->flags & CF_WROTE_DATA) {
Willy Tarreaud66ed882019-06-05 18:02:04 +0200888 /* Don't add CF_WRITE_ERROR if we're here because
889 * early data were rejected by the server, or
890 * http_wait_for_response() will never be called
891 * to send a 425.
892 */
893 if (conn && conn->err_code != CO_ER_SSL_EARLY_FAILED)
894 req->flags |= CF_WRITE_ERROR;
895 rep->flags |= CF_READ_ERROR;
Christopher Faulet50264b42022-03-30 19:39:30 +0200896 s->conn_err_type = STRM_ET_DATA_ERR;
Christopher Faulet62e75742022-03-31 09:16:34 +0200897 DBG_TRACE_STATE("read/write error", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
Willy Tarreaud66ed882019-06-05 18:02:04 +0200898 }
899
Willy Tarreau3fdb3662012-11-12 00:42:33 +0100900 if (objt_server(s->target))
Willy Tarreau88bc8002021-12-06 07:01:02 +0000901 health_adjust(__objt_server(s->target), HANA_STATUS_L4_OK);
Krzysztof Piotr Oledzki97f07b82009-12-15 22:31:24 +0100902
Christopher Faulet1bb6afa2021-03-08 17:57:53 +0100903 if (!IS_HTX_STRM(s)) { /* let's allow immediate data connection in this case */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100904 /* if the user wants to log as soon as possible, without counting
905 * bytes from the server, then this is the right moment. */
Willy Tarreaud0d8da92015-04-04 02:10:38 +0200906 if (!LIST_ISEMPTY(&strm_fe(s)->logformat) && !(s->logs.logwait & LW_BYTES)) {
Willy Tarreau66425e32018-07-25 06:55:12 +0200907 /* note: no pend_pos here, session is established */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100908 s->logs.t_close = s->logs.t_connect; /* to get a valid end date */
Willy Tarreaua5555ec2008-11-30 19:02:32 +0100909 s->do_log(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100910 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100911 }
912 else {
Willy Tarreaud81ca042013-12-31 22:33:13 +0100913 rep->flags |= CF_READ_DONTWAIT; /* a single read is enough to get response headers */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100914 }
915
Willy Tarreau0007d0a2018-12-11 18:01:38 +0100916 rep->analysers |= strm_fe(s)->fe_rsp_ana | s->be->be_rsp_ana;
Christopher Faulet309c6412015-12-02 09:57:32 +0100917
Willy Tarreau4164eb92022-05-25 15:42:03 +0200918 se_have_more_data(s->scb->sedesc);
Willy Tarreau03cdb7c2012-08-27 23:14:58 +0200919 rep->flags |= CF_READ_ATTACHED; /* producer is now attached */
Christopher Faulet0256da12021-12-15 09:50:17 +0100920 if (conn) {
Amaury Denoyelle90d3d882020-12-10 13:43:52 +0100921 /* real connections have timeouts
922 * if already defined, it means that a set-timeout rule has
923 * been executed so do not overwrite them
924 */
925 if (!tick_isset(req->wto))
926 req->wto = s->be->timeout.server;
927 if (!tick_isset(rep->rto))
928 rep->rto = s->be->timeout.server;
Amaury Denoyellefb504432020-12-10 13:43:53 +0100929 if (!tick_isset(s->tunnel_timeout))
930 s->tunnel_timeout = s->be->timeout.tunnel;
Amaury Denoyelle90d3d882020-12-10 13:43:52 +0100931
Olivier Houchard47e9a1a2018-11-07 17:55:19 +0100932 /* The connection is now established, try to read data from the
933 * underlying layer, and subscribe to recv events. We use a
934 * delayed recv here to give a chance to the data to flow back
935 * by the time we process other tasks.
936 */
Willy Tarreauf61dd192022-05-27 09:00:19 +0200937 sc_chk_rcv(s->scb);
Willy Tarreaud04e8582010-05-31 12:31:35 +0200938 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100939 req->wex = TICK_ETERNITY;
Olivier Houchard78595262019-07-26 14:54:34 +0200940 /* If we managed to get the whole response, and we don't have anything
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200941 * left to send, or can't, switch to SC_ST_DIS now. */
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100942 if (rep->flags & (CF_SHUTR | CF_SHUTW)) {
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200943 s->scb->state = SC_ST_DIS;
Christopher Faulet62e75742022-03-31 09:16:34 +0200944 DBG_TRACE_STATE("response channel shutdwn for read/write", STRM_EV_STRM_PROC|STRM_EV_CS_ST|STRM_EV_STRM_ERR, s);
Christopher Fauleteea8fc72019-11-05 16:18:10 +0100945 }
946
Christopher Faulet62e75742022-03-31 09:16:34 +0200947 DBG_TRACE_LEAVE(STRM_EV_STRM_PROC|STRM_EV_CS_ST, s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100948}
949
Willy Tarreau87b09662015-04-03 00:22:06 +0200950/* Set correct stream termination flags in case no analyser has done it. It
Simon Hormandec5be42011-06-08 09:19:07 +0900951 * also counts a failed request if the server state has not reached the request
952 * stage.
953 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200954static void sess_set_term_flags(struct stream *s)
Simon Hormandec5be42011-06-08 09:19:07 +0900955{
Willy Tarreaue7dff022015-04-03 01:14:29 +0200956 if (!(s->flags & SF_FINST_MASK)) {
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200957 if (s->scb->state == SC_ST_INI) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +0200958 /* anything before REQ in fact */
Willy Tarreau4781b152021-04-06 13:53:36 +0200959 _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.failed_req);
Willy Tarreau2c1068c2015-09-23 12:21:21 +0200960 if (strm_li(s) && strm_li(s)->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +0200961 _HA_ATOMIC_INC(&strm_li(s)->counters->failed_req);
Simon Hormandec5be42011-06-08 09:19:07 +0900962
Willy Tarreaue7dff022015-04-03 01:14:29 +0200963 s->flags |= SF_FINST_R;
Simon Hormandec5be42011-06-08 09:19:07 +0900964 }
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200965 else if (s->scb->state == SC_ST_QUE)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200966 s->flags |= SF_FINST_Q;
Willy Tarreau74568cf2022-05-27 09:03:30 +0200967 else if (sc_state_in(s->scb->state, SC_SB_REQ|SC_SB_TAR|SC_SB_ASS|SC_SB_CON|SC_SB_CER|SC_SB_RDY))
Willy Tarreaue7dff022015-04-03 01:14:29 +0200968 s->flags |= SF_FINST_C;
Willy Tarreau026e8fb2022-05-17 19:47:17 +0200969 else if (s->scb->state == SC_ST_EST || s->prev_conn_state == SC_ST_EST)
Willy Tarreaue7dff022015-04-03 01:14:29 +0200970 s->flags |= SF_FINST_D;
Simon Hormandec5be42011-06-08 09:19:07 +0900971 else
Willy Tarreaue7dff022015-04-03 01:14:29 +0200972 s->flags |= SF_FINST_L;
Simon Hormandec5be42011-06-08 09:19:07 +0900973 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +0100974}
975
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200976/* This function parses the use-service action ruleset. It executes
977 * the associated ACL and set an applet as a stream or txn final node.
978 * it returns ACT_RET_ERR if an error occurs, the proxy left in
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500979 * consistent state. It returns ACT_RET_STOP in success case because
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200980 * use-service must be a terminal action. Returns ACT_RET_YIELD
981 * if the initialisation function require more data.
982 */
983enum act_return process_use_service(struct act_rule *rule, struct proxy *px,
984 struct session *sess, struct stream *s, int flags)
985
986{
987 struct appctx *appctx;
988
989 /* Initialises the applet if it is required. */
Christopher Faulet105ba6c2019-12-18 14:41:51 +0100990 if (flags & ACT_OPT_FIRST) {
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200991 /* Register applet. this function schedules the applet. */
992 s->target = &rule->applet.obj_type;
Willy Tarreaua0b58b52022-05-27 08:33:53 +0200993 appctx = sc_applet_create(s->scb, objt_applet(s->target));
Christopher Faulet2da02ae2022-02-24 13:45:27 +0100994 if (unlikely(!appctx))
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200995 return ACT_RET_ERR;
996
Christopher Faulet93882042022-01-19 14:56:50 +0100997 /* Finish initialisation of the context. */
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200998 appctx->rule = rule;
Christopher Faulet16c0d9c2022-05-12 14:59:28 +0200999 if (appctx_init(appctx) == -1)
Christopher Faulet4aa1d282022-01-13 16:01:35 +01001000 return ACT_RET_ERR;
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02001001 }
1002 else
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02001003 appctx = __sc_appctx(s->scb);
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02001004
Christopher Faulet2571bc62019-03-01 11:44:26 +01001005 if (rule->from != ACT_F_HTTP_REQ) {
1006 if (sess->fe == s->be) /* report it if the request was intercepted by the frontend */
Willy Tarreau4781b152021-04-06 13:53:36 +02001007 _HA_ATOMIC_INC(&sess->fe->fe_counters.intercepted_req);
Christopher Faulet2571bc62019-03-01 11:44:26 +01001008
1009 /* The flag SF_ASSIGNED prevent from server assignment. */
1010 s->flags |= SF_ASSIGNED;
1011 }
1012
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02001013 /* Now we can schedule the applet. */
Willy Tarreau90e8b452022-05-25 18:21:43 +02001014 applet_need_more_data(appctx);
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02001015 appctx_wakeup(appctx);
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02001016 return ACT_RET_STOP;
1017}
1018
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001019/* This stream analyser checks the switching rules and changes the backend
Willy Tarreau4de91492010-01-22 19:10:05 +01001020 * if appropriate. The default_backend rule is also considered, then the
1021 * target backend's forced persistence rules are also evaluated last if any.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001022 * It returns 1 if the processing can continue on next analysers, or zero if it
1023 * either needs more data or wants to immediately abort the request.
1024 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001025static int process_switching_rules(struct stream *s, struct channel *req, int an_bit)
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001026{
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001027 struct persist_rule *prst_rule;
Willy Tarreau192252e2015-04-04 01:47:55 +02001028 struct session *sess = s->sess;
1029 struct proxy *fe = sess->fe;
Willy Tarreau4de91492010-01-22 19:10:05 +01001030
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001031 req->analysers &= ~an_bit;
1032 req->analyse_exp = TICK_ETERNITY;
1033
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001034 DBG_TRACE_ENTER(STRM_EV_STRM_ANA, s);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001035
1036 /* now check whether we have some switching rules for this request */
Willy Tarreaue7dff022015-04-03 01:14:29 +02001037 if (!(s->flags & SF_BE_ASSIGNED)) {
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001038 struct switching_rule *rule;
1039
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02001040 list_for_each_entry(rule, &fe->switching_rules, list) {
Willy Tarreauf51658d2014-04-23 01:21:56 +02001041 int ret = 1;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001042
Willy Tarreauf51658d2014-04-23 01:21:56 +02001043 if (rule->cond) {
Willy Tarreau192252e2015-04-04 01:47:55 +02001044 ret = acl_exec_cond(rule->cond, fe, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreauf51658d2014-04-23 01:21:56 +02001045 ret = acl_pass(ret);
1046 if (rule->cond->pol == ACL_COND_UNLESS)
1047 ret = !ret;
1048 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001049
1050 if (ret) {
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01001051 /* If the backend name is dynamic, try to resolve the name.
1052 * If we can't resolve the name, or if any error occurs, break
1053 * the loop and fallback to the default backend.
1054 */
Dragan Dosen2ae327e2017-10-26 11:25:10 +02001055 struct proxy *backend = NULL;
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01001056
1057 if (rule->dynamic) {
Willy Tarreau83061a82018-07-13 11:56:34 +02001058 struct buffer *tmp;
Dragan Dosen2ae327e2017-10-26 11:25:10 +02001059
1060 tmp = alloc_trash_chunk();
1061 if (!tmp)
1062 goto sw_failed;
1063
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001064 if (build_logline(s, tmp->area, tmp->size, &rule->be.expr))
1065 backend = proxy_be_by_name(tmp->area);
Dragan Dosen2ae327e2017-10-26 11:25:10 +02001066
1067 free_trash_chunk(tmp);
1068 tmp = NULL;
1069
Bertrand Jacquin702d44f2013-11-19 11:43:06 +01001070 if (!backend)
1071 break;
1072 }
1073 else
1074 backend = rule->be.backend;
1075
Willy Tarreau87b09662015-04-03 00:22:06 +02001076 if (!stream_set_backend(s, backend))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001077 goto sw_failed;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001078 break;
1079 }
1080 }
1081
1082 /* To ensure correct connection accounting on the backend, we
1083 * have to assign one if it was not set (eg: a listen). This
1084 * measure also takes care of correctly setting the default
Christopher Fauletf0d7eb22021-03-22 15:07:51 +01001085 * backend if any. Don't do anything if an upgrade is already in
1086 * progress.
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001087 */
Christopher Fauletf0d7eb22021-03-22 15:07:51 +01001088 if (!(s->flags & (SF_BE_ASSIGNED|SF_IGNORE)))
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02001089 if (!stream_set_backend(s, fe->defbe.be ? fe->defbe.be : s->be))
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001090 goto sw_failed;
Christopher Fauletf0d7eb22021-03-22 15:07:51 +01001091
1092 /* No backend assigned but no error reported. It happens when a
1093 * TCP stream is upgraded to HTTP/2.
1094 */
1095 if ((s->flags & (SF_BE_ASSIGNED|SF_IGNORE)) == SF_IGNORE) {
1096 DBG_TRACE_DEVEL("leaving with no backend because of a destructive upgrade", STRM_EV_STRM_ANA, s);
1097 return 0;
1098 }
1099
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001100 }
1101
Willy Tarreaufb356202010-08-03 14:02:05 +02001102 /* we don't want to run the TCP or HTTP filters again if the backend has not changed */
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02001103 if (fe == s->be) {
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001104 s->req.analysers &= ~AN_REQ_INSPECT_BE;
1105 s->req.analysers &= ~AN_REQ_HTTP_PROCESS_BE;
Christopher Faulet0184ea72017-01-05 14:06:34 +01001106 s->req.analysers &= ~AN_REQ_FLT_START_BE;
Willy Tarreaufb356202010-08-03 14:02:05 +02001107 }
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001108
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001109 /* as soon as we know the backend, we must check if we have a matching forced or ignored
Willy Tarreau87b09662015-04-03 00:22:06 +02001110 * persistence rule, and report that in the stream.
Willy Tarreau4de91492010-01-22 19:10:05 +01001111 */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001112 list_for_each_entry(prst_rule, &s->be->persist_rules, list) {
Willy Tarreau4de91492010-01-22 19:10:05 +01001113 int ret = 1;
1114
1115 if (prst_rule->cond) {
Willy Tarreau192252e2015-04-04 01:47:55 +02001116 ret = acl_exec_cond(prst_rule->cond, s->be, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreau4de91492010-01-22 19:10:05 +01001117 ret = acl_pass(ret);
1118 if (prst_rule->cond->pol == ACL_COND_UNLESS)
1119 ret = !ret;
1120 }
1121
1122 if (ret) {
1123 /* no rule, or the rule matches */
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001124 if (prst_rule->type == PERSIST_TYPE_FORCE) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02001125 s->flags |= SF_FORCE_PRST;
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001126 } else {
Willy Tarreaue7dff022015-04-03 01:14:29 +02001127 s->flags |= SF_IGNORE_PRST;
Cyril Bonté47fdd8e2010-04-25 00:00:51 +02001128 }
Willy Tarreau4de91492010-01-22 19:10:05 +01001129 break;
1130 }
1131 }
1132
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001133 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA, s);
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001134 return 1;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001135
1136 sw_failed:
1137 /* immediately abort this request in case of allocation failure */
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001138 channel_abort(&s->req);
1139 channel_abort(&s->res);
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001140
Willy Tarreaue7dff022015-04-03 01:14:29 +02001141 if (!(s->flags & SF_ERR_MASK))
1142 s->flags |= SF_ERR_RESOURCE;
1143 if (!(s->flags & SF_FINST_MASK))
1144 s->flags |= SF_FINST_R;
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001145
Willy Tarreaueee5b512015-04-03 23:46:31 +02001146 if (s->txn)
1147 s->txn->status = 500;
Christopher Faulet0184ea72017-01-05 14:06:34 +01001148 s->req.analysers &= AN_REQ_FLT_END;
Willy Tarreau22ec1ea2014-11-27 20:45:39 +01001149 s->req.analyse_exp = TICK_ETERNITY;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001150 DBG_TRACE_DEVEL("leaving on error", STRM_EV_STRM_ANA|STRM_EV_STRM_ERR, s);
Willy Tarreaubedb9ba2009-07-12 08:27:39 +02001151 return 0;
Willy Tarreau1d0dfb12009-07-07 15:10:31 +02001152}
1153
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001154/* This stream analyser works on a request. It applies all use-server rules on
1155 * it then returns 1. The data must already be present in the buffer otherwise
1156 * they won't match. It always returns 1.
1157 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001158static int process_server_rules(struct stream *s, struct channel *req, int an_bit)
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001159{
1160 struct proxy *px = s->be;
Willy Tarreau192252e2015-04-04 01:47:55 +02001161 struct session *sess = s->sess;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001162 struct server_rule *rule;
1163
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001164 DBG_TRACE_ENTER(STRM_EV_STRM_ANA, s);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001165
Willy Tarreaue7dff022015-04-03 01:14:29 +02001166 if (!(s->flags & SF_ASSIGNED)) {
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001167 list_for_each_entry(rule, &px->server_rules, list) {
1168 int ret;
1169
Willy Tarreau192252e2015-04-04 01:47:55 +02001170 ret = acl_exec_cond(rule->cond, s->be, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001171 ret = acl_pass(ret);
1172 if (rule->cond->pol == ACL_COND_UNLESS)
1173 ret = !ret;
1174
1175 if (ret) {
Jerome Magnin824186b2020-03-29 09:37:12 +02001176 struct server *srv;
1177
1178 if (rule->dynamic) {
1179 struct buffer *tmp = get_trash_chunk();
1180
1181 if (!build_logline(s, tmp->area, tmp->size, &rule->expr))
1182 break;
1183
1184 srv = findserver(s->be, tmp->area);
1185 if (!srv)
1186 break;
1187 }
1188 else
1189 srv = rule->srv.ptr;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001190
Emeric Brun52a91d32017-08-31 14:41:55 +02001191 if ((srv->cur_state != SRV_ST_STOPPED) ||
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001192 (px->options & PR_O_PERSIST) ||
Willy Tarreaue7dff022015-04-03 01:14:29 +02001193 (s->flags & SF_FORCE_PRST)) {
1194 s->flags |= SF_DIRECT | SF_ASSIGNED;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001195 s->target = &srv->obj_type;
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001196 break;
1197 }
1198 /* if the server is not UP, let's go on with next rules
1199 * just in case another one is suited.
1200 */
1201 }
1202 }
1203 }
1204
1205 req->analysers &= ~an_bit;
1206 req->analyse_exp = TICK_ETERNITY;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001207 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA, s);
Willy Tarreau4a5cade2012-04-05 21:09:48 +02001208 return 1;
1209}
1210
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001211static inline void sticking_rule_find_target(struct stream *s,
1212 struct stktable *t, struct stksess *ts)
1213{
1214 struct proxy *px = s->be;
1215 struct eb32_node *node;
1216 struct dict_entry *de;
1217 void *ptr;
1218 struct server *srv;
1219
1220 /* Look for the server name previously stored in <t> stick-table */
1221 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
Thayne McCombs92149f92020-11-20 01:28:26 -07001222 ptr = __stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_KEY);
Emeric Brun0e3457b2021-06-30 17:18:28 +02001223 de = stktable_data_cast(ptr, std_t_dict);
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001224 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
1225
1226 if (de) {
Thayne McCombs92149f92020-11-20 01:28:26 -07001227 struct ebpt_node *node;
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001228
Thayne McCombs92149f92020-11-20 01:28:26 -07001229 if (t->server_key_type == STKTABLE_SRV_NAME) {
1230 node = ebis_lookup(&px->conf.used_server_name, de->value.key);
1231 if (node) {
1232 srv = container_of(node, struct server, conf.name);
1233 goto found;
1234 }
1235 } else if (t->server_key_type == STKTABLE_SRV_ADDR) {
1236 HA_RWLOCK_RDLOCK(PROXY_LOCK, &px->lock);
1237 node = ebis_lookup(&px->used_server_addr, de->value.key);
1238 HA_RWLOCK_RDUNLOCK(PROXY_LOCK, &px->lock);
1239 if (node) {
1240 srv = container_of(node, struct server, addr_node);
1241 goto found;
1242 }
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001243 }
1244 }
1245
1246 /* Look for the server ID */
1247 HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
1248 ptr = __stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_ID);
Emeric Brun0e3457b2021-06-30 17:18:28 +02001249 node = eb32_lookup(&px->conf.used_server_id, stktable_data_cast(ptr, std_t_sint));
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001250 HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
1251
1252 if (!node)
1253 return;
1254
1255 srv = container_of(node, struct server, conf.id);
1256 found:
1257 if ((srv->cur_state != SRV_ST_STOPPED) ||
1258 (px->options & PR_O_PERSIST) || (s->flags & SF_FORCE_PRST)) {
1259 s->flags |= SF_DIRECT | SF_ASSIGNED;
1260 s->target = &srv->obj_type;
1261 }
1262}
1263
Emeric Brun1d33b292010-01-04 15:47:17 +01001264/* This stream analyser works on a request. It applies all sticking rules on
1265 * it then returns 1. The data must already be present in the buffer otherwise
1266 * they won't match. It always returns 1.
1267 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001268static int process_sticking_rules(struct stream *s, struct channel *req, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001269{
1270 struct proxy *px = s->be;
Willy Tarreau192252e2015-04-04 01:47:55 +02001271 struct session *sess = s->sess;
Emeric Brun1d33b292010-01-04 15:47:17 +01001272 struct sticking_rule *rule;
1273
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001274 DBG_TRACE_ENTER(STRM_EV_STRM_ANA, s);
Emeric Brun1d33b292010-01-04 15:47:17 +01001275
1276 list_for_each_entry(rule, &px->sticking_rules, list) {
1277 int ret = 1 ;
1278 int i;
1279
Willy Tarreau9667a802013-12-09 12:52:13 +01001280 /* Only the first stick store-request of each table is applied
1281 * and other ones are ignored. The purpose is to allow complex
1282 * configurations which look for multiple entries by decreasing
1283 * order of precision and to stop at the first which matches.
1284 * An example could be a store of the IP address from an HTTP
1285 * header first, then from the source if not found.
1286 */
Jerome Magninbee00ad2020-01-16 17:37:21 +01001287 if (rule->flags & STK_IS_STORE) {
1288 for (i = 0; i < s->store_count; i++) {
1289 if (rule->table.t == s->store[i].table)
1290 break;
1291 }
Emeric Brun1d33b292010-01-04 15:47:17 +01001292
Jerome Magninbee00ad2020-01-16 17:37:21 +01001293 if (i != s->store_count)
1294 continue;
1295 }
Emeric Brun1d33b292010-01-04 15:47:17 +01001296
1297 if (rule->cond) {
Willy Tarreau192252e2015-04-04 01:47:55 +02001298 ret = acl_exec_cond(rule->cond, px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001299 ret = acl_pass(ret);
1300 if (rule->cond->pol == ACL_COND_UNLESS)
1301 ret = !ret;
1302 }
1303
1304 if (ret) {
1305 struct stktable_key *key;
1306
Willy Tarreau192252e2015-04-04 01:47:55 +02001307 key = stktable_fetch_key(rule->table.t, px, sess, s, SMP_OPT_DIR_REQ|SMP_OPT_FINAL, rule->expr, NULL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001308 if (!key)
1309 continue;
1310
1311 if (rule->flags & STK_IS_MATCH) {
1312 struct stksess *ts;
1313
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001314 if ((ts = stktable_lookup_key(rule->table.t, key)) != NULL) {
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001315 if (!(s->flags & SF_ASSIGNED))
1316 sticking_rule_find_target(s, rule->table.t, ts);
Emeric Brun819fc6f2017-06-13 19:37:32 +02001317 stktable_touch_local(rule->table.t, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001318 }
1319 }
1320 if (rule->flags & STK_IS_STORE) {
1321 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
1322 struct stksess *ts;
1323
1324 ts = stksess_new(rule->table.t, key);
1325 if (ts) {
1326 s->store[s->store_count].table = rule->table.t;
1327 s->store[s->store_count++].ts = ts;
1328 }
1329 }
1330 }
1331 }
1332 }
1333
1334 req->analysers &= ~an_bit;
1335 req->analyse_exp = TICK_ETERNITY;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001336 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA, s);
Emeric Brun1d33b292010-01-04 15:47:17 +01001337 return 1;
1338}
1339
1340/* This stream analyser works on a response. It applies all store rules on it
1341 * then returns 1. The data must already be present in the buffer otherwise
1342 * they won't match. It always returns 1.
1343 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001344static int process_store_rules(struct stream *s, struct channel *rep, int an_bit)
Emeric Brun1d33b292010-01-04 15:47:17 +01001345{
1346 struct proxy *px = s->be;
Willy Tarreau192252e2015-04-04 01:47:55 +02001347 struct session *sess = s->sess;
Emeric Brun1d33b292010-01-04 15:47:17 +01001348 struct sticking_rule *rule;
1349 int i;
Willy Tarreau9667a802013-12-09 12:52:13 +01001350 int nbreq = s->store_count;
Emeric Brun1d33b292010-01-04 15:47:17 +01001351
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001352 DBG_TRACE_ENTER(STRM_EV_STRM_ANA, s);
Emeric Brun1d33b292010-01-04 15:47:17 +01001353
1354 list_for_each_entry(rule, &px->storersp_rules, list) {
1355 int ret = 1 ;
Emeric Brun1d33b292010-01-04 15:47:17 +01001356
Willy Tarreau9667a802013-12-09 12:52:13 +01001357 /* Only the first stick store-response of each table is applied
1358 * and other ones are ignored. The purpose is to allow complex
1359 * configurations which look for multiple entries by decreasing
1360 * order of precision and to stop at the first which matches.
1361 * An example could be a store of a set-cookie value, with a
1362 * fallback to a parameter found in a 302 redirect.
1363 *
1364 * The store-response rules are not allowed to override the
1365 * store-request rules for the same table, but they may coexist.
1366 * Thus we can have up to one store-request entry and one store-
1367 * response entry for the same table at any time.
1368 */
1369 for (i = nbreq; i < s->store_count; i++) {
1370 if (rule->table.t == s->store[i].table)
1371 break;
1372 }
1373
1374 /* skip existing entries for this table */
1375 if (i < s->store_count)
1376 continue;
1377
Emeric Brun1d33b292010-01-04 15:47:17 +01001378 if (rule->cond) {
Willy Tarreau192252e2015-04-04 01:47:55 +02001379 ret = acl_exec_cond(rule->cond, px, sess, s, SMP_OPT_DIR_RES|SMP_OPT_FINAL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001380 ret = acl_pass(ret);
1381 if (rule->cond->pol == ACL_COND_UNLESS)
1382 ret = !ret;
1383 }
1384
1385 if (ret) {
1386 struct stktable_key *key;
1387
Willy Tarreau192252e2015-04-04 01:47:55 +02001388 key = stktable_fetch_key(rule->table.t, px, sess, s, SMP_OPT_DIR_RES|SMP_OPT_FINAL, rule->expr, NULL);
Emeric Brun1d33b292010-01-04 15:47:17 +01001389 if (!key)
1390 continue;
1391
Willy Tarreau37e340c2013-12-06 23:05:21 +01001392 if (s->store_count < (sizeof(s->store) / sizeof(s->store[0]))) {
Emeric Brun1d33b292010-01-04 15:47:17 +01001393 struct stksess *ts;
1394
1395 ts = stksess_new(rule->table.t, key);
1396 if (ts) {
1397 s->store[s->store_count].table = rule->table.t;
Emeric Brun1d33b292010-01-04 15:47:17 +01001398 s->store[s->store_count++].ts = ts;
1399 }
1400 }
1401 }
1402 }
1403
1404 /* process store request and store response */
1405 for (i = 0; i < s->store_count; i++) {
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001406 struct stksess *ts;
Willy Tarreau13c29de2010-06-06 16:40:39 +02001407 void *ptr;
Thayne McCombs92149f92020-11-20 01:28:26 -07001408 char *key;
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001409 struct dict_entry *de;
Thayne McCombs92149f92020-11-20 01:28:26 -07001410 struct stktable *t = s->store[i].table;
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001411
Willy Tarreau88bc8002021-12-06 07:01:02 +00001412 if (objt_server(s->target) && __objt_server(s->target)->flags & SRV_F_NON_STICK) {
Simon Hormanfa461682011-06-25 09:39:49 +09001413 stksess_free(s->store[i].table, s->store[i].ts);
1414 s->store[i].ts = NULL;
1415 continue;
1416 }
1417
Thayne McCombs92149f92020-11-20 01:28:26 -07001418 ts = stktable_set_entry(t, s->store[i].ts);
Emeric Brun819fc6f2017-06-13 19:37:32 +02001419 if (ts != s->store[i].ts) {
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001420 /* the entry already existed, we can free ours */
Thayne McCombs92149f92020-11-20 01:28:26 -07001421 stksess_free(t, s->store[i].ts);
Emeric Brun1d33b292010-01-04 15:47:17 +01001422 }
Willy Tarreauf16d2b82010-06-06 15:38:59 +02001423 s->store[i].ts = NULL;
Emeric Brun819fc6f2017-06-13 19:37:32 +02001424
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001425 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Thayne McCombs92149f92020-11-20 01:28:26 -07001426 ptr = __stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_ID);
Emeric Brun0e3457b2021-06-30 17:18:28 +02001427 stktable_data_cast(ptr, std_t_sint) = __objt_server(s->target)->puid;
Christopher Faulet2a944ee2017-11-07 10:42:54 +01001428 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001429
Thayne McCombs92149f92020-11-20 01:28:26 -07001430 if (t->server_key_type == STKTABLE_SRV_NAME)
1431 key = __objt_server(s->target)->id;
1432 else if (t->server_key_type == STKTABLE_SRV_ADDR)
1433 key = __objt_server(s->target)->addr_node.key;
1434 else
1435 continue;
1436
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001437 HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
Thayne McCombs92149f92020-11-20 01:28:26 -07001438 de = dict_insert(&server_key_dict, key);
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001439 if (de) {
Thayne McCombs92149f92020-11-20 01:28:26 -07001440 ptr = __stktable_data_ptr(t, ts, STKTABLE_DT_SERVER_KEY);
Emeric Brun0e3457b2021-06-30 17:18:28 +02001441 stktable_data_cast(ptr, std_t_dict) = de;
Frédéric Lécaille03cdf552019-05-20 10:08:27 +02001442 }
1443 HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
1444
Thayne McCombs92149f92020-11-20 01:28:26 -07001445 stktable_touch_local(t, ts, 1);
Emeric Brun1d33b292010-01-04 15:47:17 +01001446 }
Willy Tarreau2a164ee2010-06-18 09:57:45 +02001447 s->store_count = 0; /* everything is stored */
Emeric Brun1d33b292010-01-04 15:47:17 +01001448
1449 rep->analysers &= ~an_bit;
1450 rep->analyse_exp = TICK_ETERNITY;
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001451
1452 DBG_TRACE_LEAVE(STRM_EV_STRM_ANA, s);
Emeric Brun1d33b292010-01-04 15:47:17 +01001453 return 1;
1454}
1455
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001456/* Set the stream to HTTP mode, if necessary. The minimal request HTTP analysers
1457 * are set and the client mux is upgraded. It returns 1 if the stream processing
1458 * may continue or 0 if it should be stopped. It happens on error or if the
Christopher Fauletae863c62021-03-15 12:03:44 +01001459 * upgrade required a new stream. The mux protocol may be specified.
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001460 */
Christopher Fauletae863c62021-03-15 12:03:44 +01001461int stream_set_http_mode(struct stream *s, const struct mux_proto_list *mux_proto)
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001462{
Willy Tarreaub49672d2022-05-27 10:13:37 +02001463 struct stconn *sc = s->scf;
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001464 struct connection *conn;
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001465
1466 /* Already an HTTP stream */
1467 if (IS_HTX_STRM(s))
1468 return 1;
1469
1470 s->req.analysers |= AN_REQ_WAIT_HTTP|AN_REQ_HTTP_PROCESS_FE;
1471
1472 if (unlikely(!s->txn && !http_create_txn(s)))
1473 return 0;
1474
Willy Tarreaub49672d2022-05-27 10:13:37 +02001475 conn = sc_conn(sc);
Christopher Faulet13a35e52021-12-20 15:34:16 +01001476 if (conn) {
Willy Tarreau4164eb92022-05-25 15:42:03 +02001477 se_have_more_data(s->scf->sedesc);
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001478 /* Make sure we're unsubscribed, the the new
1479 * mux will probably want to subscribe to
1480 * the underlying XPRT
1481 */
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001482 if (s->scf->wait_event.events)
Willy Tarreaub49672d2022-05-27 10:13:37 +02001483 conn->mux->unsubscribe(sc, s->scf->wait_event.events, &(s->scf->wait_event));
Christopher Fauletae863c62021-03-15 12:03:44 +01001484
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001485 if (conn->mux->flags & MX_FL_NO_UPG)
1486 return 0;
Christopher Fauletb68f77d2022-06-16 16:24:16 +02001487
1488 sc_conn_prepare_endp_upgrade(sc);
Willy Tarreaub49672d2022-05-27 10:13:37 +02001489 if (conn_upgrade_mux_fe(conn, sc, &s->req.buf,
Christopher Fauletae863c62021-03-15 12:03:44 +01001490 (mux_proto ? mux_proto->token : ist("")),
Christopher Fauletb68f77d2022-06-16 16:24:16 +02001491 PROTO_MODE_HTTP) == -1) {
1492 sc_conn_abort_endp_upgrade(sc);
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001493 return 0;
Christopher Fauletb68f77d2022-06-16 16:24:16 +02001494 }
1495 sc_conn_commit_endp_upgrade(sc);
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001496
1497 s->req.flags &= ~(CF_READ_PARTIAL|CF_AUTO_CONNECT);
1498 s->req.total = 0;
1499 s->flags |= SF_IGNORE;
Christopher Faulet9b8d7a12022-06-17 09:36:57 +02001500 if (sc_ep_test(sc, SE_FL_DETACHED)) {
1501 /* If stream connector is detached, it means it was not
1502 * reused by the new mux. Son destroy it, disable
1503 * logging, and abort the stream process. Thus the
1504 * stream will be silently destroyed. The new mux will
1505 * create new streams.
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001506 */
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001507 s->logs.logwait = 0;
1508 s->logs.level = 0;
1509 channel_abort(&s->req);
1510 channel_abort(&s->res);
1511 s->req.analysers &= AN_REQ_FLT_END;
1512 s->req.analyse_exp = TICK_ETERNITY;
1513 }
1514 }
1515
1516 return 1;
1517}
1518
1519
Willy Tarreau4596fe22022-05-17 19:07:51 +02001520/* Updates at once the channel flags, and timers of both stream connectors of a
Christopher Fauletef285c12022-04-01 14:48:06 +02001521 * same stream, to complete the work after the analysers, then updates the data
1522 * layer below. This will ensure that any synchronous update performed at the
Willy Tarreau4596fe22022-05-17 19:07:51 +02001523 * data layer will be reflected in the channel flags and/or stream connector.
1524 * Note that this does not change the stream connector's current state, though
Christopher Fauletef285c12022-04-01 14:48:06 +02001525 * it updates the previous state to the current one.
1526 */
Willy Tarreaub49672d2022-05-27 10:13:37 +02001527static void stream_update_both_sc(struct stream *s)
Christopher Fauletef285c12022-04-01 14:48:06 +02001528{
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001529 struct stconn *scf = s->scf;
1530 struct stconn *scb = s->scb;
Christopher Fauletef285c12022-04-01 14:48:06 +02001531 struct channel *req = &s->req;
1532 struct channel *res = &s->res;
1533
1534 req->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL);
1535 res->flags &= ~(CF_READ_NULL|CF_READ_PARTIAL|CF_READ_ATTACHED|CF_WRITE_NULL|CF_WRITE_PARTIAL);
1536
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001537 s->prev_conn_state = scb->state;
Christopher Fauletef285c12022-04-01 14:48:06 +02001538
1539 /* let's recompute both sides states */
Willy Tarreau74568cf2022-05-27 09:03:30 +02001540 if (sc_state_in(scf->state, SC_SB_RDY|SC_SB_EST))
Willy Tarreau19c65a92022-05-27 08:49:24 +02001541 sc_update(scf);
Christopher Fauletef285c12022-04-01 14:48:06 +02001542
Willy Tarreau74568cf2022-05-27 09:03:30 +02001543 if (sc_state_in(scb->state, SC_SB_RDY|SC_SB_EST))
Willy Tarreau19c65a92022-05-27 08:49:24 +02001544 sc_update(scb);
Christopher Fauletef285c12022-04-01 14:48:06 +02001545
Willy Tarreau4596fe22022-05-17 19:07:51 +02001546 /* stream connectors are processed outside of process_stream() and must be
Christopher Fauletef285c12022-04-01 14:48:06 +02001547 * handled at the latest moment.
1548 */
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02001549 if (sc_appctx(scf)) {
Willy Tarreau13d63af2022-05-25 15:00:44 +02001550 if (sc_is_recv_allowed(scf) || sc_is_send_allowed(scf))
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02001551 appctx_wakeup(__sc_appctx(scf));
Christopher Fauletef285c12022-04-01 14:48:06 +02001552 }
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02001553 if (sc_appctx(scb)) {
Willy Tarreau13d63af2022-05-25 15:00:44 +02001554 if (sc_is_recv_allowed(scb) || sc_is_send_allowed(scb))
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02001555 appctx_wakeup(__sc_appctx(scb));
Christopher Fauletef285c12022-04-01 14:48:06 +02001556 }
1557}
1558
Christopher Faulet6c1fd982021-03-15 10:42:02 +01001559
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001560/* This macro is very specific to the function below. See the comments in
Willy Tarreau87b09662015-04-03 00:22:06 +02001561 * process_stream() below to understand the logic and the tests.
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001562 */
1563#define UPDATE_ANALYSERS(real, list, back, flag) { \
1564 list = (((list) & ~(flag)) | ~(back)) & (real); \
1565 back = real; \
1566 if (!(list)) \
1567 break; \
1568 if (((list) ^ ((list) & ((list) - 1))) < (flag)) \
1569 continue; \
1570}
1571
Christopher Fauleta9215b72016-05-11 17:06:28 +02001572/* These 2 following macros call an analayzer for the specified channel if the
1573 * right flag is set. The first one is used for "filterable" analyzers. If a
Christopher Faulet3a394fa2016-05-11 17:13:39 +02001574 * stream has some registered filters, pre and post analyaze callbacks are
Christopher Faulet0184ea72017-01-05 14:06:34 +01001575 * called. The second are used for other analyzers (AN_REQ/RES_FLT_* and
Christopher Fauleta9215b72016-05-11 17:06:28 +02001576 * AN_REQ/RES_HTTP_XFER_BODY) */
1577#define FLT_ANALYZE(strm, chn, fun, list, back, flag, ...) \
1578 { \
1579 if ((list) & (flag)) { \
1580 if (HAS_FILTERS(strm)) { \
Christopher Faulet3a394fa2016-05-11 17:13:39 +02001581 if (!flt_pre_analyze((strm), (chn), (flag))) \
Christopher Fauleta9215b72016-05-11 17:06:28 +02001582 break; \
1583 if (!fun((strm), (chn), (flag), ##__VA_ARGS__)) \
1584 break; \
Christopher Faulet3a394fa2016-05-11 17:13:39 +02001585 if (!flt_post_analyze((strm), (chn), (flag))) \
1586 break; \
Christopher Fauleta9215b72016-05-11 17:06:28 +02001587 } \
1588 else { \
1589 if (!fun((strm), (chn), (flag), ##__VA_ARGS__)) \
1590 break; \
1591 } \
1592 UPDATE_ANALYSERS((chn)->analysers, (list), \
1593 (back), (flag)); \
1594 } \
1595 }
1596
1597#define ANALYZE(strm, chn, fun, list, back, flag, ...) \
1598 { \
1599 if ((list) & (flag)) { \
1600 if (!fun((strm), (chn), (flag), ##__VA_ARGS__)) \
1601 break; \
1602 UPDATE_ANALYSERS((chn)->analysers, (list), \
1603 (back), (flag)); \
1604 } \
1605 }
1606
Willy Tarreau87b09662015-04-03 00:22:06 +02001607/* Processes the client, server, request and response jobs of a stream task,
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001608 * then puts it back to the wait queue in a clean state, or cleans up its
1609 * resources if it must be deleted. Returns in <next> the date the task wants
1610 * to be woken up, or TICK_ETERNITY. In order not to call all functions for
1611 * nothing too many times, the request and response buffers flags are monitored
1612 * and each function is called only if at least another function has changed at
1613 * least one flag it is interested in.
1614 */
Willy Tarreau144f84a2021-03-02 16:09:26 +01001615struct task *process_stream(struct task *t, void *context, unsigned int state)
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001616{
Willy Tarreau827aee92011-03-10 16:55:02 +01001617 struct server *srv;
Olivier Houchard9f6af332018-05-25 14:04:04 +02001618 struct stream *s = context;
Willy Tarreaufb0afa72015-04-03 14:46:27 +02001619 struct session *sess = s->sess;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001620 unsigned int rqf_last, rpf_last;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001621 unsigned int rq_prod_last, rq_cons_last;
1622 unsigned int rp_cons_last, rp_prod_last;
Willy Tarreau576507f2010-01-07 00:09:04 +01001623 unsigned int req_ana_back;
Willy Tarreau8f128b42014-11-28 15:07:47 +01001624 struct channel *req, *res;
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001625 struct stconn *scf, *scb;
Willy Tarreau3d07a162019-04-25 19:15:20 +02001626 unsigned int rate;
Willy Tarreau8f128b42014-11-28 15:07:47 +01001627
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001628 DBG_TRACE_ENTER(STRM_EV_STRM_PROC, s);
1629
Willy Tarreau7af4fa92020-06-17 20:49:49 +02001630 activity[tid].stream_calls++;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01001631
Willy Tarreau8f128b42014-11-28 15:07:47 +01001632 req = &s->req;
1633 res = &s->res;
1634
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001635 scf = s->scf;
1636 scb = s->scb;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001637
Willy Tarreau0f8d3ab2018-10-25 10:42:39 +02001638 /* First, attempt to receive pending data from I/O layers */
Willy Tarreau462b9892022-05-18 18:06:53 +02001639 sc_conn_sync_recv(scf);
1640 sc_conn_sync_recv(scb);
Willy Tarreau0f8d3ab2018-10-25 10:42:39 +02001641
Willy Tarreau6c539c42022-01-20 18:42:16 +01001642 /* Let's check if we're looping without making any progress, e.g. due
1643 * to a bogus analyser or the fact that we're ignoring a read0. The
1644 * call_rate counter only counts calls with no progress made.
1645 */
1646 if (!((req->flags | res->flags) & (CF_READ_PARTIAL|CF_WRITE_PARTIAL))) {
1647 rate = update_freq_ctr(&s->call_rate, 1);
1648 if (rate >= 100000 && s->call_rate.prev_ctr) // make sure to wait at least a full second
1649 stream_dump_and_crash(&s->obj_type, read_freq_ctr(&s->call_rate));
Willy Tarreau3d07a162019-04-25 19:15:20 +02001650 }
Olivier Houchardc2aa7112018-09-11 18:27:21 +02001651
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001652 /* this data may be no longer valid, clear it */
Willy Tarreaueee5b512015-04-03 23:46:31 +02001653 if (s->txn)
1654 memset(&s->txn->auth, 0, sizeof(s->txn->auth));
Krzysztof Piotr Oledzkif9423ae2010-01-29 19:26:18 +01001655
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02001656 /* This flag must explicitly be set every time */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001657 req->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
1658 res->flags &= ~(CF_READ_NOEXP|CF_WAKE_WRITE);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001659
1660 /* Keep a copy of req/rep flags so that we can detect shutdowns */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001661 rqf_last = req->flags & ~CF_MASK_ANALYSER;
1662 rpf_last = res->flags & ~CF_MASK_ANALYSER;
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001663
Willy Tarreau4596fe22022-05-17 19:07:51 +02001664 /* we don't want the stream connector functions to recursively wake us up */
Willy Tarreaucb041662022-05-17 19:44:42 +02001665 scf->flags |= SC_FL_DONT_WAKE;
1666 scb->flags |= SC_FL_DONT_WAKE;
Willy Tarreau89f7ef22009-09-05 20:57:35 +02001667
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001668 /* update pending events */
Olivier Houchard9f6af332018-05-25 14:04:04 +02001669 s->pending_events |= (state & TASK_WOKEN_ANY);
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001670
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001671 /* 1a: Check for low level timeouts if needed. We just set a flag on
Willy Tarreau4596fe22022-05-17 19:07:51 +02001672 * stream connectors when their timeouts have expired.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001673 */
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001674 if (unlikely(s->pending_events & TASK_WOKEN_TIMER)) {
Christopher Fauletae024ce2022-03-29 19:02:31 +02001675 stream_check_conn_timeout(s);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001676
Willy Tarreau4596fe22022-05-17 19:07:51 +02001677 /* check channel timeouts, and close the corresponding stream connectors
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001678 * for future reads or writes. Note: this will also concern upper layers
1679 * but we do not touch any other flag. We must be careful and correctly
1680 * detect state changes when calling them.
1681 */
1682
Willy Tarreau8f128b42014-11-28 15:07:47 +01001683 channel_check_timeouts(req);
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001684
Willy Tarreau8f128b42014-11-28 15:07:47 +01001685 if (unlikely((req->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02001686 scb->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02001687 sc_shutw(scb);
Willy Tarreau14641402009-12-29 14:49:56 +01001688 }
1689
Willy Tarreau8f128b42014-11-28 15:07:47 +01001690 if (unlikely((req->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02001691 if (scf->flags & SC_FL_NOHALF)
1692 scf->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02001693 sc_shutr(scf);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001694 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001695
Willy Tarreau8f128b42014-11-28 15:07:47 +01001696 channel_check_timeouts(res);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001697
Willy Tarreau8f128b42014-11-28 15:07:47 +01001698 if (unlikely((res->flags & (CF_SHUTW|CF_WRITE_TIMEOUT)) == CF_WRITE_TIMEOUT)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02001699 scf->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02001700 sc_shutw(scf);
Willy Tarreau14641402009-12-29 14:49:56 +01001701 }
1702
Willy Tarreau8f128b42014-11-28 15:07:47 +01001703 if (unlikely((res->flags & (CF_SHUTR|CF_READ_TIMEOUT)) == CF_READ_TIMEOUT)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02001704 if (scb->flags & SC_FL_NOHALF)
1705 scb->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02001706 sc_shutr(scb);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02001707 }
Willy Tarreau798f4322012-11-08 14:49:17 +01001708
Christopher Fauleta00d8172016-11-10 14:58:05 +01001709 if (HAS_FILTERS(s))
1710 flt_stream_check_timeouts(s);
1711
Willy Tarreau798f4322012-11-08 14:49:17 +01001712 /* Once in a while we're woken up because the task expires. But
1713 * this does not necessarily mean that a timeout has been reached.
Willy Tarreau87b09662015-04-03 00:22:06 +02001714 * So let's not run a whole stream processing if only an expiration
Willy Tarreau798f4322012-11-08 14:49:17 +01001715 * timeout needs to be refreshed.
1716 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001717 if (!((req->flags | res->flags) &
Willy Tarreau798f4322012-11-08 14:49:17 +01001718 (CF_SHUTR|CF_READ_ACTIVITY|CF_READ_TIMEOUT|CF_SHUTW|
Willy Tarreauede3d882018-10-24 17:17:56 +02001719 CF_WRITE_ACTIVITY|CF_WRITE_TIMEOUT|CF_ANA_TIMEOUT)) &&
Christopher Fauletae024ce2022-03-29 19:02:31 +02001720 !(s->flags & SF_CONN_EXP) &&
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001721 !((sc_ep_get(scf) | scb->flags) & SE_FL_ERROR) &&
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001722 ((s->pending_events & TASK_WOKEN_ANY) == TASK_WOKEN_TIMER)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02001723 scf->flags &= ~SC_FL_DONT_WAKE;
1724 scb->flags &= ~SC_FL_DONT_WAKE;
Willy Tarreau798f4322012-11-08 14:49:17 +01001725 goto update_exp_and_leave;
Willy Tarreau5fb04712016-05-04 10:18:37 +02001726 }
Willy Tarreaub67a9b82009-06-21 22:03:51 +02001727 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001728
Willy Tarreau4596fe22022-05-17 19:07:51 +02001729 resync_stconns:
Willy Tarreau10fc09e2014-11-25 19:46:36 +01001730 /* below we may emit error messages so we have to ensure that we have
Christopher Faulet686501c2022-02-01 18:53:53 +01001731 * our buffers properly allocated. If the allocation failed, an error is
1732 * triggered.
1733 *
1734 * NOTE: An error is returned because the mechanism to queue entities
1735 * waiting for a buffer is totally broken for now. However, this
1736 * part must be refactored. When it will be handled, this part
1737 * must be be reviewed too.
Willy Tarreau10fc09e2014-11-25 19:46:36 +01001738 */
Willy Tarreau87b09662015-04-03 00:22:06 +02001739 if (!stream_alloc_work_buffer(s)) {
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001740 sc_ep_set(s->scf, SE_FL_ERROR);
Christopher Faulet50264b42022-03-30 19:39:30 +02001741 s->conn_err_type = STRM_ET_CONN_RES;
Christopher Faulet686501c2022-02-01 18:53:53 +01001742
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001743 sc_ep_set(s->scb, SE_FL_ERROR);
Christopher Faulet50264b42022-03-30 19:39:30 +02001744 s->conn_err_type = STRM_ET_CONN_RES;
Christopher Faulet686501c2022-02-01 18:53:53 +01001745
1746 if (!(s->flags & SF_ERR_MASK))
1747 s->flags |= SF_ERR_RESOURCE;
1748 sess_set_term_flags(s);
Willy Tarreau10fc09e2014-11-25 19:46:36 +01001749 }
1750
Willy Tarreau4596fe22022-05-17 19:07:51 +02001751 /* 1b: check for low-level errors reported at the stream connector.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001752 * First we check if it's a retryable error (in which case we don't
1753 * want to tell the buffer). Otherwise we report the error one level
1754 * upper by setting flags into the buffers. Note that the side towards
1755 * the client cannot have connect (hence retryable) errors. Also, the
1756 * connection setup code must be able to deal with any type of abort.
1757 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001758 srv = objt_server(s->target);
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001759 if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) {
Willy Tarreau74568cf2022-05-27 09:03:30 +02001760 if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) {
Willy Tarreauf61dd192022-05-27 09:00:19 +02001761 sc_shutr(scf);
1762 sc_shutw(scf);
Willy Tarreau74568cf2022-05-27 09:03:30 +02001763 sc_report_error(scf);
Willy Tarreau8f128b42014-11-28 15:07:47 +01001764 if (!(req->analysers) && !(res->analysers)) {
Willy Tarreau4781b152021-04-06 13:53:36 +02001765 _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
1766 _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01001767 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02001768 _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01001769 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02001770 _HA_ATOMIC_INC(&srv->counters.cli_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02001771 if (!(s->flags & SF_ERR_MASK))
1772 s->flags |= SF_ERR_CLICL;
1773 if (!(s->flags & SF_FINST_MASK))
1774 s->flags |= SF_FINST_D;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001775 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001776 }
1777 }
1778
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001779 if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) {
Willy Tarreau74568cf2022-05-27 09:03:30 +02001780 if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
Willy Tarreauf61dd192022-05-27 09:00:19 +02001781 sc_shutr(scb);
1782 sc_shutw(scb);
Willy Tarreau74568cf2022-05-27 09:03:30 +02001783 sc_report_error(scb);
Willy Tarreau4781b152021-04-06 13:53:36 +02001784 _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
Willy Tarreau827aee92011-03-10 16:55:02 +01001785 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02001786 _HA_ATOMIC_INC(&srv->counters.failed_resp);
Willy Tarreau8f128b42014-11-28 15:07:47 +01001787 if (!(req->analysers) && !(res->analysers)) {
Willy Tarreau4781b152021-04-06 13:53:36 +02001788 _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
1789 _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01001790 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02001791 _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01001792 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02001793 _HA_ATOMIC_INC(&srv->counters.srv_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02001794 if (!(s->flags & SF_ERR_MASK))
1795 s->flags |= SF_ERR_SRVCL;
1796 if (!(s->flags & SF_FINST_MASK))
1797 s->flags |= SF_FINST_D;
Willy Tarreau05cb29b2008-12-14 11:44:04 +01001798 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001799 }
1800 /* note: maybe we should process connection errors here ? */
1801 }
1802
Willy Tarreau74568cf2022-05-27 09:03:30 +02001803 if (sc_state_in(scb->state, SC_SB_CON|SC_SB_RDY)) {
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001804 /* we were trying to establish a connection on the server side,
1805 * maybe it succeeded, maybe it failed, maybe we timed out, ...
1806 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001807 if (scb->state == SC_ST_RDY)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01001808 back_handle_st_rdy(s);
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001809 else if (s->scb->state == SC_ST_CON)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01001810 back_handle_st_con(s);
Willy Tarreaud66ed882019-06-05 18:02:04 +02001811
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001812 if (scb->state == SC_ST_CER)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01001813 back_handle_st_cer(s);
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001814 else if (scb->state == SC_ST_EST)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01001815 back_establish(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001816
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001817 /* state is now one of SC_ST_CON (still in progress), SC_ST_EST
1818 * (established), SC_ST_DIS (abort), SC_ST_CLO (last error),
1819 * SC_ST_ASS/SC_ST_TAR/SC_ST_REQ for retryable errors.
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001820 */
1821 }
1822
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001823 rq_prod_last = scf->state;
1824 rq_cons_last = scb->state;
1825 rp_cons_last = scf->state;
1826 rp_prod_last = scb->state;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001827
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001828 /* Check for connection closure */
Christopher Fauleteea8fc72019-11-05 16:18:10 +01001829 DBG_TRACE_POINT(STRM_EV_STRM_PROC, s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001830
1831 /* nothing special to be done on client side */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001832 if (unlikely(scf->state == SC_ST_DIS)) {
1833 scf->state = SC_ST_CLO;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001834
Christopher Fauleta70a3542022-03-30 17:13:02 +02001835 /* This is needed only when debugging is enabled, to indicate
1836 * client-side close.
1837 */
1838 if (unlikely((global.mode & MODE_DEBUG) &&
1839 (!(global.mode & MODE_QUIET) ||
1840 (global.mode & MODE_VERBOSE)))) {
1841 chunk_printf(&trash, "%08x:%s.clicls[%04x:%04x]\n",
1842 s->uniq_id, s->be->id,
Willy Tarreaufd9417b2022-05-18 16:23:22 +02001843 (unsigned short)conn_fd(sc_conn(scf)),
1844 (unsigned short)conn_fd(sc_conn(scb)));
Christopher Fauleta70a3542022-03-30 17:13:02 +02001845 DISGUISE(write(1, trash.area, trash.data));
1846 }
1847 }
1848
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001849 /* When a server-side connection is released, we have to count it and
1850 * check for pending connections on this server.
1851 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001852 if (unlikely(scb->state == SC_ST_DIS)) {
1853 scb->state = SC_ST_CLO;
Willy Tarreau3fdb3662012-11-12 00:42:33 +01001854 srv = objt_server(s->target);
Willy Tarreau827aee92011-03-10 16:55:02 +01001855 if (srv) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02001856 if (s->flags & SF_CURR_SESS) {
1857 s->flags &= ~SF_CURR_SESS;
Willy Tarreau4781b152021-04-06 13:53:36 +02001858 _HA_ATOMIC_DEC(&srv->cur_sess);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001859 }
1860 sess_change_server(s, NULL);
Willy Tarreau827aee92011-03-10 16:55:02 +01001861 if (may_dequeue_tasks(srv, s->be))
Willy Tarreau9ab78292021-06-22 18:47:51 +02001862 process_srv_queue(srv);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001863 }
Christopher Fauleta70a3542022-03-30 17:13:02 +02001864
1865 /* This is needed only when debugging is enabled, to indicate
1866 * server-side close.
1867 */
1868 if (unlikely((global.mode & MODE_DEBUG) &&
1869 (!(global.mode & MODE_QUIET) ||
1870 (global.mode & MODE_VERBOSE)))) {
Willy Tarreau026e8fb2022-05-17 19:47:17 +02001871 if (s->prev_conn_state == SC_ST_EST) {
Christopher Fauleta70a3542022-03-30 17:13:02 +02001872 chunk_printf(&trash, "%08x:%s.srvcls[%04x:%04x]\n",
1873 s->uniq_id, s->be->id,
Willy Tarreaufd9417b2022-05-18 16:23:22 +02001874 (unsigned short)conn_fd(sc_conn(scf)),
1875 (unsigned short)conn_fd(sc_conn(scb)));
Christopher Fauleta70a3542022-03-30 17:13:02 +02001876 DISGUISE(write(1, trash.area, trash.data));
1877 }
1878 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001879 }
1880
1881 /*
1882 * Note: of the transient states (REQ, CER, DIS), only REQ may remain
1883 * at this point.
1884 */
1885
Willy Tarreau0be0ef92009-03-08 19:20:25 +01001886 resync_request:
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001887 /* Analyse request */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001888 if (((req->flags & ~rqf_last) & CF_MASK_ANALYSER) ||
1889 ((req->flags ^ rqf_last) & CF_MASK_STATIC) ||
Willy Tarreau33982cb2017-11-20 15:37:13 +01001890 (req->analysers && (req->flags & CF_SHUTW)) ||
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001891 scf->state != rq_prod_last ||
1892 scb->state != rq_cons_last ||
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001893 s->pending_events & TASK_WOKEN_MSG) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01001894 unsigned int flags = req->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001895
Willy Tarreau74568cf2022-05-27 09:03:30 +02001896 if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001897 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001898 unsigned int ana_list;
1899 unsigned int ana_back;
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001900
Willy Tarreau90deb182010-01-07 00:20:41 +01001901 /* it's up to the analysers to stop new connections,
1902 * disable reading or closing. Note: if an analyser
1903 * disables any of these bits, it is responsible for
1904 * enabling them again when it disables itself, so
1905 * that other analysers are called in similar conditions.
1906 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001907 channel_auto_read(req);
1908 channel_auto_connect(req);
1909 channel_auto_close(req);
Willy Tarreauedcf6682008-11-30 23:15:34 +01001910
1911 /* We will call all analysers for which a bit is set in
Willy Tarreau8f128b42014-11-28 15:07:47 +01001912 * req->analysers, following the bit order from LSB
Willy Tarreauedcf6682008-11-30 23:15:34 +01001913 * to MSB. The analysers must remove themselves from
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001914 * the list when not needed. Any analyser may return 0
1915 * to break out of the loop, either because of missing
1916 * data to take a decision, or because it decides to
Willy Tarreau87b09662015-04-03 00:22:06 +02001917 * kill the stream. We loop at least once through each
Willy Tarreau1a52dbd2009-06-28 19:37:53 +02001918 * analyser, and we may loop again if other analysers
1919 * are added in the middle.
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001920 *
1921 * We build a list of analysers to run. We evaluate all
1922 * of these analysers in the order of the lower bit to
1923 * the higher bit. This ordering is very important.
1924 * An analyser will often add/remove other analysers,
1925 * including itself. Any changes to itself have no effect
1926 * on the loop. If it removes any other analysers, we
1927 * want those analysers not to be called anymore during
1928 * this loop. If it adds an analyser that is located
1929 * after itself, we want it to be scheduled for being
1930 * processed during the loop. If it adds an analyser
1931 * which is located before it, we want it to switch to
1932 * it immediately, even if it has already been called
1933 * once but removed since.
1934 *
1935 * In order to achieve this, we compare the analyser
1936 * list after the call with a copy of it before the
1937 * call. The work list is fed with analyser bits that
1938 * appeared during the call. Then we compare previous
1939 * work list with the new one, and check the bits that
1940 * appeared. If the lowest of these bits is lower than
1941 * the current bit, it means we have enabled a previous
1942 * analyser and must immediately loop again.
Willy Tarreauedcf6682008-11-30 23:15:34 +01001943 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001944
Willy Tarreau8f128b42014-11-28 15:07:47 +01001945 ana_list = ana_back = req->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01001946 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001947 /* Warning! ensure that analysers are always placed in ascending order! */
Christopher Faulet0184ea72017-01-05 14:06:34 +01001948 ANALYZE (s, req, flt_start_analyze, ana_list, ana_back, AN_REQ_FLT_START_FE);
Christopher Fauleta9215b72016-05-11 17:06:28 +02001949 FLT_ANALYZE(s, req, tcp_inspect_request, ana_list, ana_back, AN_REQ_INSPECT_FE);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001950 FLT_ANALYZE(s, req, http_wait_for_request, ana_list, ana_back, AN_REQ_WAIT_HTTP);
1951 FLT_ANALYZE(s, req, http_wait_for_request_body, ana_list, ana_back, AN_REQ_HTTP_BODY);
1952 FLT_ANALYZE(s, req, http_process_req_common, ana_list, ana_back, AN_REQ_HTTP_PROCESS_FE, sess->fe);
Christopher Fauleta9215b72016-05-11 17:06:28 +02001953 FLT_ANALYZE(s, req, process_switching_rules, ana_list, ana_back, AN_REQ_SWITCHING_RULES);
Christopher Faulet0184ea72017-01-05 14:06:34 +01001954 ANALYZE (s, req, flt_start_analyze, ana_list, ana_back, AN_REQ_FLT_START_BE);
Christopher Fauleta9215b72016-05-11 17:06:28 +02001955 FLT_ANALYZE(s, req, tcp_inspect_request, ana_list, ana_back, AN_REQ_INSPECT_BE);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001956 FLT_ANALYZE(s, req, http_process_req_common, ana_list, ana_back, AN_REQ_HTTP_PROCESS_BE, s->be);
1957 FLT_ANALYZE(s, req, http_process_tarpit, ana_list, ana_back, AN_REQ_HTTP_TARPIT);
Christopher Fauleta9215b72016-05-11 17:06:28 +02001958 FLT_ANALYZE(s, req, process_server_rules, ana_list, ana_back, AN_REQ_SRV_RULES);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001959 FLT_ANALYZE(s, req, http_process_request, ana_list, ana_back, AN_REQ_HTTP_INNER);
Christopher Fauleta9215b72016-05-11 17:06:28 +02001960 FLT_ANALYZE(s, req, tcp_persist_rdp_cookie, ana_list, ana_back, AN_REQ_PRST_RDP_COOKIE);
1961 FLT_ANALYZE(s, req, process_sticking_rules, ana_list, ana_back, AN_REQ_STICKING_RULES);
Christopher Faulet0184ea72017-01-05 14:06:34 +01001962 ANALYZE (s, req, flt_analyze_http_headers, ana_list, ana_back, AN_REQ_FLT_HTTP_HDRS);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02001963 ANALYZE (s, req, http_request_forward_body, ana_list, ana_back, AN_REQ_HTTP_XFER_BODY);
William Lallemandcf62f7e2018-10-26 14:47:40 +02001964 ANALYZE (s, req, pcli_wait_for_request, ana_list, ana_back, AN_REQ_WAIT_CLI);
Christopher Faulet0184ea72017-01-05 14:06:34 +01001965 ANALYZE (s, req, flt_xfer_data, ana_list, ana_back, AN_REQ_FLT_XFER_DATA);
1966 ANALYZE (s, req, flt_end_analyze, ana_list, ana_back, AN_REQ_FLT_END);
Willy Tarreaue34070e2010-01-08 00:32:27 +01001967 break;
1968 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01001969 }
Willy Tarreau84455332009-03-15 22:34:05 +01001970
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001971 rq_prod_last = scf->state;
1972 rq_cons_last = scb->state;
Willy Tarreau8f128b42014-11-28 15:07:47 +01001973 req->flags &= ~CF_WAKE_ONCE;
1974 rqf_last = req->flags;
Willy Tarreau815a9b22010-07-27 17:15:12 +02001975
Willy Tarreau1ec9bb52019-06-06 14:45:26 +02001976 if ((req->flags ^ flags) & (CF_SHUTR|CF_SHUTW))
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001977 goto resync_request;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001978 }
1979
Willy Tarreau576507f2010-01-07 00:09:04 +01001980 /* we'll monitor the request analysers while parsing the response,
1981 * because some response analysers may indirectly enable new request
1982 * analysers (eg: HTTP keep-alive).
1983 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01001984 req_ana_back = req->analysers;
Willy Tarreau576507f2010-01-07 00:09:04 +01001985
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001986 resync_response:
1987 /* Analyse response */
1988
Willy Tarreau8f128b42014-11-28 15:07:47 +01001989 if (((res->flags & ~rpf_last) & CF_MASK_ANALYSER) ||
1990 (res->flags ^ rpf_last) & CF_MASK_STATIC ||
Willy Tarreau33982cb2017-11-20 15:37:13 +01001991 (res->analysers && (res->flags & CF_SHUTW)) ||
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02001992 scf->state != rp_cons_last ||
1993 scb->state != rp_prod_last ||
Christopher Faulet9d810ca2016-12-08 22:33:52 +01001994 s->pending_events & TASK_WOKEN_MSG) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01001995 unsigned int flags = res->flags;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02001996
Willy Tarreau74568cf2022-05-27 09:03:30 +02001997 if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) {
Willy Tarreaue34070e2010-01-08 00:32:27 +01001998 int max_loops = global.tune.maxpollevents;
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01001999 unsigned int ana_list;
2000 unsigned int ana_back;
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002001
Willy Tarreau90deb182010-01-07 00:20:41 +01002002 /* it's up to the analysers to stop disable reading or
2003 * closing. Note: if an analyser disables any of these
2004 * bits, it is responsible for enabling them again when
2005 * it disables itself, so that other analysers are called
2006 * in similar conditions.
2007 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002008 channel_auto_read(res);
2009 channel_auto_close(res);
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002010
2011 /* We will call all analysers for which a bit is set in
Willy Tarreau8f128b42014-11-28 15:07:47 +01002012 * res->analysers, following the bit order from LSB
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002013 * to MSB. The analysers must remove themselves from
2014 * the list when not needed. Any analyser may return 0
2015 * to break out of the loop, either because of missing
2016 * data to take a decision, or because it decides to
Willy Tarreau87b09662015-04-03 00:22:06 +02002017 * kill the stream. We loop at least once through each
Willy Tarreaub37c27e2009-10-18 22:53:08 +02002018 * analyser, and we may loop again if other analysers
2019 * are added in the middle.
2020 */
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002021
Willy Tarreau8f128b42014-11-28 15:07:47 +01002022 ana_list = ana_back = res->analysers;
Willy Tarreaue34070e2010-01-08 00:32:27 +01002023 while (ana_list && max_loops--) {
Willy Tarreau1e0bbaf2010-01-06 23:53:24 +01002024 /* Warning! ensure that analysers are always placed in ascending order! */
Christopher Faulet0184ea72017-01-05 14:06:34 +01002025 ANALYZE (s, res, flt_start_analyze, ana_list, ana_back, AN_RES_FLT_START_FE);
2026 ANALYZE (s, res, flt_start_analyze, ana_list, ana_back, AN_RES_FLT_START_BE);
Christopher Fauleta9215b72016-05-11 17:06:28 +02002027 FLT_ANALYZE(s, res, tcp_inspect_response, ana_list, ana_back, AN_RES_INSPECT);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02002028 FLT_ANALYZE(s, res, http_wait_for_response, ana_list, ana_back, AN_RES_WAIT_HTTP);
Christopher Fauleta9215b72016-05-11 17:06:28 +02002029 FLT_ANALYZE(s, res, process_store_rules, ana_list, ana_back, AN_RES_STORE_RULES);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02002030 FLT_ANALYZE(s, res, http_process_res_common, ana_list, ana_back, AN_RES_HTTP_PROCESS_BE, s->be);
Christopher Faulet0184ea72017-01-05 14:06:34 +01002031 ANALYZE (s, res, flt_analyze_http_headers, ana_list, ana_back, AN_RES_FLT_HTTP_HDRS);
Christopher Fauletfc9cfe42019-07-16 14:54:53 +02002032 ANALYZE (s, res, http_response_forward_body, ana_list, ana_back, AN_RES_HTTP_XFER_BODY);
William Lallemandcf62f7e2018-10-26 14:47:40 +02002033 ANALYZE (s, res, pcli_wait_for_response, ana_list, ana_back, AN_RES_WAIT_CLI);
Christopher Faulet0184ea72017-01-05 14:06:34 +01002034 ANALYZE (s, res, flt_xfer_data, ana_list, ana_back, AN_RES_FLT_XFER_DATA);
2035 ANALYZE (s, res, flt_end_analyze, ana_list, ana_back, AN_RES_FLT_END);
Willy Tarreaue34070e2010-01-08 00:32:27 +01002036 break;
2037 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002038 }
2039
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002040 rp_cons_last = scf->state;
2041 rp_prod_last = scb->state;
Christopher Fauletcdaea892017-07-06 15:49:30 +02002042 res->flags &= ~CF_WAKE_ONCE;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002043 rpf_last = res->flags;
Willy Tarreau815a9b22010-07-27 17:15:12 +02002044
Willy Tarreau1ec9bb52019-06-06 14:45:26 +02002045 if ((res->flags ^ flags) & (CF_SHUTR|CF_SHUTW))
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002046 goto resync_response;
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002047 }
2048
Willy Tarreau576507f2010-01-07 00:09:04 +01002049 /* maybe someone has added some request analysers, so we must check and loop */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002050 if (req->analysers & ~req_ana_back)
Willy Tarreau576507f2010-01-07 00:09:04 +01002051 goto resync_request;
2052
Willy Tarreau8f128b42014-11-28 15:07:47 +01002053 if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
Willy Tarreau0499e352010-12-17 07:13:42 +01002054 goto resync_request;
2055
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002056 /* FIXME: here we should call protocol handlers which rely on
2057 * both buffers.
2058 */
2059
2060
2061 /*
Willy Tarreau87b09662015-04-03 00:22:06 +02002062 * Now we propagate unhandled errors to the stream. Normally
Willy Tarreauae526782010-03-04 20:34:23 +01002063 * we're just in a data phase here since it means we have not
2064 * seen any analyser who could set an error status.
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002065 */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002066 srv = objt_server(s->target);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002067 if (unlikely(!(s->flags & SF_ERR_MASK))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002068 if (req->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002069 /* Report it if the client got an error or a read timeout expired */
Christopher Faulet813f9132021-10-18 15:06:20 +02002070 req->analysers &= AN_REQ_FLT_END;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002071 if (req->flags & CF_READ_ERROR) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002072 _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
2073 _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002074 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002075 _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002076 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002077 _HA_ATOMIC_INC(&srv->counters.cli_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002078 s->flags |= SF_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002079 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002080 else if (req->flags & CF_READ_TIMEOUT) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002081 _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
2082 _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002083 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002084 _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002085 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002086 _HA_ATOMIC_INC(&srv->counters.cli_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002087 s->flags |= SF_ERR_CLITO;
Willy Tarreauae526782010-03-04 20:34:23 +01002088 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002089 else if (req->flags & CF_WRITE_ERROR) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002090 _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
2091 _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002092 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002093 _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002094 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002095 _HA_ATOMIC_INC(&srv->counters.srv_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002096 s->flags |= SF_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002097 }
2098 else {
Willy Tarreau4781b152021-04-06 13:53:36 +02002099 _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
2100 _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002101 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002102 _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002103 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002104 _HA_ATOMIC_INC(&srv->counters.srv_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002105 s->flags |= SF_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002106 }
Willy Tarreau84455332009-03-15 22:34:05 +01002107 sess_set_term_flags(s);
Christopher Faulet5e1a9d72019-04-23 17:34:22 +02002108
2109 /* Abort the request if a client error occurred while
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002110 * the backend stream connector is in the SC_ST_INI
2111 * state. It is switched into the SC_ST_CLO state and
Christopher Faulet5e1a9d72019-04-23 17:34:22 +02002112 * the request channel is erased. */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002113 if (scb->state == SC_ST_INI) {
2114 s->scb->state = SC_ST_CLO;
Christopher Faulet5e1a9d72019-04-23 17:34:22 +02002115 channel_abort(req);
2116 if (IS_HTX_STRM(s))
2117 channel_htx_erase(req, htxbuf(&req->buf));
2118 else
2119 channel_erase(req);
2120 }
Willy Tarreau84455332009-03-15 22:34:05 +01002121 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002122 else if (res->flags & (CF_READ_ERROR|CF_READ_TIMEOUT|CF_WRITE_ERROR|CF_WRITE_TIMEOUT)) {
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002123 /* Report it if the server got an error or a read timeout expired */
Christopher Faulet813f9132021-10-18 15:06:20 +02002124 res->analysers &= AN_RES_FLT_END;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002125 if (res->flags & CF_READ_ERROR) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002126 _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
2127 _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002128 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002129 _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002130 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002131 _HA_ATOMIC_INC(&srv->counters.srv_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002132 s->flags |= SF_ERR_SRVCL;
Willy Tarreauae526782010-03-04 20:34:23 +01002133 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002134 else if (res->flags & CF_READ_TIMEOUT) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002135 _HA_ATOMIC_INC(&s->be->be_counters.srv_aborts);
2136 _HA_ATOMIC_INC(&sess->fe->fe_counters.srv_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002137 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002138 _HA_ATOMIC_INC(&sess->listener->counters->srv_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002139 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002140 _HA_ATOMIC_INC(&srv->counters.srv_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002141 s->flags |= SF_ERR_SRVTO;
Willy Tarreauae526782010-03-04 20:34:23 +01002142 }
Willy Tarreau8f128b42014-11-28 15:07:47 +01002143 else if (res->flags & CF_WRITE_ERROR) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002144 _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
2145 _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002146 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002147 _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002148 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002149 _HA_ATOMIC_INC(&srv->counters.cli_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002150 s->flags |= SF_ERR_CLICL;
Willy Tarreauae526782010-03-04 20:34:23 +01002151 }
2152 else {
Willy Tarreau4781b152021-04-06 13:53:36 +02002153 _HA_ATOMIC_INC(&s->be->be_counters.cli_aborts);
2154 _HA_ATOMIC_INC(&sess->fe->fe_counters.cli_aborts);
Christopher Faulet99ac8a12020-01-24 11:45:05 +01002155 if (sess->listener && sess->listener->counters)
Willy Tarreau4781b152021-04-06 13:53:36 +02002156 _HA_ATOMIC_INC(&sess->listener->counters->cli_aborts);
Willy Tarreau827aee92011-03-10 16:55:02 +01002157 if (srv)
Willy Tarreau4781b152021-04-06 13:53:36 +02002158 _HA_ATOMIC_INC(&srv->counters.cli_aborts);
Willy Tarreaue7dff022015-04-03 01:14:29 +02002159 s->flags |= SF_ERR_CLITO;
Willy Tarreauae526782010-03-04 20:34:23 +01002160 }
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002161 sess_set_term_flags(s);
2162 }
Willy Tarreau84455332009-03-15 22:34:05 +01002163 }
2164
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002165 /*
2166 * Here we take care of forwarding unhandled data. This also includes
2167 * connection establishments and shutdown requests.
2168 */
2169
2170
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05002171 /* If no one is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002172 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002173 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002174 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002175 */
Christopher Faulet35fe6992017-08-29 16:06:38 +02002176 if (unlikely((!req->analysers || (req->analysers == AN_REQ_FLT_END && !(req->flags & CF_FLT_ANALYZE))) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002177 !(req->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau74568cf2022-05-27 09:03:30 +02002178 (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO)) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002179 (req->to_forward != CHN_INFINITE_FORWARD))) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002180 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002181 * attached to it. If any data are left in, we'll permit them to
2182 * move.
2183 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002184 channel_auto_read(req);
2185 channel_auto_connect(req);
2186 channel_auto_close(req);
Willy Tarreau5bd8c372009-01-19 00:32:22 +01002187
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002188 if (IS_HTX_STRM(s)) {
2189 struct htx *htx = htxbuf(&req->buf);
2190
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002191 /* We'll let data flow between the producer (if still connected)
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002192 * to the consumer.
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002193 */
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002194 co_set_data(req, htx->data);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002195 if (!(req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002196 channel_htx_forward_forever(req, htx);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002197 }
2198 else {
2199 /* We'll let data flow between the producer (if still connected)
2200 * to the consumer (which might possibly not be connected yet).
2201 */
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002202 c_adv(req, ci_data(req));
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002203 if (!(req->flags & (CF_SHUTR|CF_SHUTW_NOW)))
2204 channel_forward_forever(req);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002205 }
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002206 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002207
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002208 /* check if it is wise to enable kernel splicing to forward request data */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002209 if (!(req->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
2210 req->to_forward &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002211 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreaufd9417b2022-05-18 16:23:22 +02002212 (sc_conn(scf) && __sc_conn(scf)->xprt && __sc_conn(scf)->xprt->rcv_pipe &&
2213 __sc_conn(scf)->mux && __sc_conn(scf)->mux->rcv_pipe) &&
2214 (sc_conn(scb) && __sc_conn(scb)->xprt && __sc_conn(scb)->xprt->snd_pipe &&
2215 __sc_conn(scb)->mux && __sc_conn(scb)->mux->snd_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002216 (pipes_used < global.maxpipes) &&
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002217 (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
2218 (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002219 (req->flags & CF_STREAMER_FAST)))) {
2220 req->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002221 }
2222
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002223 /* reflect what the L7 analysers have seen last */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002224 rqf_last = req->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002225
Willy Tarreau520d95e2009-09-19 21:04:57 +02002226 /* it's possible that an upper layer has requested a connection setup or abort.
2227 * There are 2 situations where we decide to establish a new connection :
2228 * - there are data scheduled for emission in the buffer
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002229 * - the CF_AUTO_CONNECT flag is set (active connection)
Willy Tarreau520d95e2009-09-19 21:04:57 +02002230 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002231 if (scb->state == SC_ST_INI) {
Christopher Faulet5e1a9d72019-04-23 17:34:22 +02002232 if (!(req->flags & CF_SHUTW)) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002233 if ((req->flags & CF_AUTO_CONNECT) || !channel_is_empty(req)) {
Willy Tarreaucf644ed2013-09-29 17:19:56 +02002234 /* If we have an appctx, there is no connect method, so we
2235 * immediately switch to the connected state, otherwise we
2236 * perform a connection request.
Willy Tarreau520d95e2009-09-19 21:04:57 +02002237 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002238 scb->state = SC_ST_REQ; /* new connection requested */
Christopher Faulet731c8e62022-03-29 16:08:44 +02002239 s->conn_retries = 0;
Christopher Faulet9f5382e2021-05-21 13:46:14 +02002240 if ((s->be->retry_type &~ PR_RE_CONN_FAILED) &&
2241 (s->be->mode == PR_MODE_HTTP) &&
Christopher Faulete05bf9e2022-03-29 15:23:40 +02002242 !(s->txn->flags & TX_D_L7_RETRY))
2243 s->txn->flags |= TX_L7_RETRY;
Willy Tarreau520d95e2009-09-19 21:04:57 +02002244 }
Willy Tarreau73201222009-08-16 18:27:24 +02002245 }
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002246 else {
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002247 s->scb->state = SC_ST_CLO; /* shutw+ini = abort */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002248 channel_shutw_now(req); /* fix buffer flags upon abort */
2249 channel_shutr_now(res);
Willy Tarreauf41ffdc2009-09-20 08:19:25 +02002250 }
Willy Tarreau92795622009-03-06 12:51:23 +01002251 }
2252
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002253
2254 /* we may have a pending connection request, or a connection waiting
2255 * for completion.
2256 */
Willy Tarreau74568cf2022-05-27 09:03:30 +02002257 if (sc_state_in(scb->state, SC_SB_REQ|SC_SB_QUE|SC_SB_TAR|SC_SB_ASS)) {
Thierry FOURNIER4834bc72015-06-06 19:29:07 +02002258 /* prune the request variables and swap to the response variables. */
2259 if (s->vars_reqres.scope != SCOPE_RES) {
Jerome Magnin2f44e882019-11-09 18:00:47 +01002260 if (!LIST_ISEMPTY(&s->vars_reqres.head))
Willy Tarreaucda7f3f2018-10-28 13:44:36 +01002261 vars_prune(&s->vars_reqres, s->sess, s);
Willy Tarreaub7bfcb32021-08-31 08:13:25 +02002262 vars_init_head(&s->vars_reqres, SCOPE_RES);
Thierry FOURNIER4834bc72015-06-06 19:29:07 +02002263 }
2264
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002265 do {
2266 /* nb: step 1 might switch from QUE to ASS, but we first want
2267 * to give a chance to step 2 to perform a redirect if needed.
2268 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002269 if (scb->state != SC_ST_REQ)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01002270 back_try_conn_req(s);
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002271 if (scb->state == SC_ST_REQ)
Willy Tarreau3a9312a2020-01-09 18:43:15 +01002272 back_handle_st_req(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002273
Willy Tarreauada4c582020-03-04 16:42:03 +01002274 /* get a chance to complete an immediate connection setup */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002275 if (scb->state == SC_ST_RDY)
Willy Tarreau4596fe22022-05-17 19:07:51 +02002276 goto resync_stconns;
Willy Tarreauada4c582020-03-04 16:42:03 +01002277
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +01002278 /* applets directly go to the ESTABLISHED state. Similarly,
2279 * servers experience the same fate when their connection
2280 * is reused.
2281 */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002282 if (unlikely(scb->state == SC_ST_EST))
Willy Tarreau3a9312a2020-01-09 18:43:15 +01002283 back_establish(s);
Willy Tarreaufac4bd12013-11-30 09:21:49 +01002284
Willy Tarreau3fdb3662012-11-12 00:42:33 +01002285 srv = objt_server(s->target);
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002286 if (scb->state == SC_ST_ASS && srv && srv->rdr_len && (s->flags & SF_REDIRECTABLE))
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002287 http_perform_server_redirect(s, scb);
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002288 } while (scb->state == SC_ST_ASS);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002289 }
2290
Willy Tarreau829bd472019-06-06 09:17:23 +02002291 /* Let's see if we can send the pending request now */
Willy Tarreau462b9892022-05-18 18:06:53 +02002292 sc_conn_sync_send(scb);
Willy Tarreau829bd472019-06-06 09:17:23 +02002293
2294 /*
2295 * Now forward all shutdown requests between both sides of the request buffer
2296 */
2297
2298 /* first, let's check if the request buffer needs to shutdown(write), which may
2299 * happen either because the input is closed or because we want to force a close
2300 * once the server has begun to respond. If a half-closed timeout is set, we adjust
Willy Tarreaua544c662022-04-14 17:39:48 +02002301 * the other side's timeout as well. However this doesn't have effect during the
2302 * connection setup unless the backend has abortonclose set.
Willy Tarreau829bd472019-06-06 09:17:23 +02002303 */
2304 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreaua544c662022-04-14 17:39:48 +02002305 (CF_AUTO_CLOSE|CF_SHUTR) &&
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002306 (scb->state != SC_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) {
Willy Tarreau829bd472019-06-06 09:17:23 +02002307 channel_shutw_now(req);
2308 }
2309
2310 /* shutdown(write) pending */
2311 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
2312 channel_is_empty(req))) {
2313 if (req->flags & CF_READ_ERROR)
Willy Tarreaucb041662022-05-17 19:44:42 +02002314 scb->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02002315 sc_shutw(scb);
Willy Tarreau829bd472019-06-06 09:17:23 +02002316 }
2317
2318 /* shutdown(write) done on server side, we must stop the client too */
2319 if (unlikely((req->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW &&
2320 !req->analysers))
2321 channel_shutr_now(req);
2322
2323 /* shutdown(read) pending */
2324 if (unlikely((req->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02002325 if (scf->flags & SC_FL_NOHALF)
2326 scf->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02002327 sc_shutr(scf);
Willy Tarreau829bd472019-06-06 09:17:23 +02002328 }
2329
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002330 /* Benchmarks have shown that it's optimal to do a full resync now */
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002331 if (scf->state == SC_ST_DIS ||
Willy Tarreau74568cf2022-05-27 09:03:30 +02002332 sc_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002333 (sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
2334 (sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
Willy Tarreau4596fe22022-05-17 19:07:51 +02002335 goto resync_stconns;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002336
Willy Tarreau815a9b22010-07-27 17:15:12 +02002337 /* otherwise we want to check if we need to resync the req buffer or not */
Willy Tarreau1ec9bb52019-06-06 14:45:26 +02002338 if ((req->flags ^ rqf_last) & (CF_SHUTR|CF_SHUTW))
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002339 goto resync_request;
2340
Willy Tarreau3deb3d02009-06-21 22:43:05 +02002341 /* perform output updates to the response buffer */
Willy Tarreau84455332009-03-15 22:34:05 +01002342
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +05002343 /* If no one is interested in analysing data, it's time to forward
Willy Tarreau31971e52009-09-20 12:07:52 +02002344 * everything. We configure the buffer to forward indefinitely.
Willy Tarreau03cdb7c2012-08-27 23:14:58 +02002345 * Note that we're checking CF_SHUTR_NOW as an indication of a possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002346 * recent call to channel_abort().
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002347 */
Christopher Faulet35fe6992017-08-29 16:06:38 +02002348 if (unlikely((!res->analysers || (res->analysers == AN_RES_FLT_END && !(res->flags & CF_FLT_ANALYZE))) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002349 !(res->flags & (CF_SHUTW|CF_SHUTR_NOW)) &&
Willy Tarreau74568cf2022-05-27 09:03:30 +02002350 sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS|SC_SB_CLO) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002351 (res->to_forward != CHN_INFINITE_FORWARD))) {
Willy Tarreaub31c9712012-11-11 23:05:39 +01002352 /* This buffer is freewheeling, there's no analyser
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002353 * attached to it. If any data are left in, we'll permit them to
2354 * move.
2355 */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002356 channel_auto_read(res);
2357 channel_auto_close(res);
Willy Tarreauda4d9fe2010-11-07 20:26:56 +01002358
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002359 if (IS_HTX_STRM(s)) {
2360 struct htx *htx = htxbuf(&res->buf);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002361
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002362 /* We'll let data flow between the producer (if still connected)
2363 * to the consumer.
2364 */
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002365 co_set_data(res, htx->data);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002366 if (!(res->flags & (CF_SHUTR|CF_SHUTW_NOW)))
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002367 channel_htx_forward_forever(res, htx);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002368 }
2369 else {
2370 /* We'll let data flow between the producer (if still connected)
2371 * to the consumer.
2372 */
Christopher Faulet2dba1a52018-12-18 21:57:24 +01002373 c_adv(res, ci_data(res));
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002374 if (!(res->flags & (CF_SHUTR|CF_SHUTW_NOW)))
2375 channel_forward_forever(res);
Christopher Fauletb2aedea2018-12-05 11:56:15 +01002376 }
Willy Tarreau42529c32015-07-09 18:38:57 +02002377
Willy Tarreauce887fd2012-05-12 12:50:00 +02002378 /* if we have no analyser anymore in any direction and have a
Willy Tarreau05cdd962014-05-10 14:30:07 +02002379 * tunnel timeout set, use it now. Note that we must respect
2380 * the half-closed timeouts as well.
Willy Tarreauce887fd2012-05-12 12:50:00 +02002381 */
Amaury Denoyellefb504432020-12-10 13:43:53 +01002382 if (!req->analysers && s->tunnel_timeout) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002383 req->rto = req->wto = res->rto = res->wto =
Amaury Denoyellefb504432020-12-10 13:43:53 +01002384 s->tunnel_timeout;
Willy Tarreau05cdd962014-05-10 14:30:07 +02002385
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002386 if ((req->flags & CF_SHUTR) && tick_isset(sess->fe->timeout.clientfin))
2387 res->wto = sess->fe->timeout.clientfin;
Willy Tarreau8f128b42014-11-28 15:07:47 +01002388 if ((req->flags & CF_SHUTW) && tick_isset(s->be->timeout.serverfin))
2389 res->rto = s->be->timeout.serverfin;
2390 if ((res->flags & CF_SHUTR) && tick_isset(s->be->timeout.serverfin))
2391 req->wto = s->be->timeout.serverfin;
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002392 if ((res->flags & CF_SHUTW) && tick_isset(sess->fe->timeout.clientfin))
2393 req->rto = sess->fe->timeout.clientfin;
Willy Tarreau05cdd962014-05-10 14:30:07 +02002394
Willy Tarreau8f128b42014-11-28 15:07:47 +01002395 req->rex = tick_add(now_ms, req->rto);
2396 req->wex = tick_add(now_ms, req->wto);
2397 res->rex = tick_add(now_ms, res->rto);
2398 res->wex = tick_add(now_ms, res->wto);
Willy Tarreauce887fd2012-05-12 12:50:00 +02002399 }
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002400 }
Willy Tarreauf890dc92008-12-13 21:12:26 +01002401
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002402 /* check if it is wise to enable kernel splicing to forward response data */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002403 if (!(res->flags & (CF_KERN_SPLICING|CF_SHUTR)) &&
2404 res->to_forward &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002405 (global.tune.options & GTUNE_USE_SPLICE) &&
Willy Tarreaufd9417b2022-05-18 16:23:22 +02002406 (sc_conn(scf) && __sc_conn(scf)->xprt && __sc_conn(scf)->xprt->snd_pipe &&
2407 __sc_conn(scf)->mux && __sc_conn(scf)->mux->snd_pipe) &&
2408 (sc_conn(scb) && __sc_conn(scb)->xprt && __sc_conn(scb)->xprt->rcv_pipe &&
2409 __sc_conn(scb)->mux && __sc_conn(scb)->mux->rcv_pipe) &&
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002410 (pipes_used < global.maxpipes) &&
Willy Tarreaue36cbcb2015-04-03 15:40:56 +02002411 (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
2412 (((sess->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
Willy Tarreau8f128b42014-11-28 15:07:47 +01002413 (res->flags & CF_STREAMER_FAST)))) {
2414 res->flags |= CF_KERN_SPLICING;
Willy Tarreau7c84bab2009-03-08 21:38:23 +01002415 }
2416
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002417 /* reflect what the L7 analysers have seen last */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002418 rpf_last = res->flags;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002419
Willy Tarreau829bd472019-06-06 09:17:23 +02002420 /* Let's see if we can send the pending response now */
Willy Tarreau462b9892022-05-18 18:06:53 +02002421 sc_conn_sync_send(scf);
Willy Tarreau829bd472019-06-06 09:17:23 +02002422
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002423 /*
2424 * Now forward all shutdown requests between both sides of the buffer
2425 */
2426
2427 /*
2428 * FIXME: this is probably where we should produce error responses.
2429 */
2430
Willy Tarreau6b66f3e2008-12-14 17:31:54 +01002431 /* first, let's check if the response buffer needs to shutdown(write) */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002432 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW|CF_AUTO_CLOSE|CF_SHUTR)) ==
Willy Tarreau05cdd962014-05-10 14:30:07 +02002433 (CF_AUTO_CLOSE|CF_SHUTR))) {
Willy Tarreau8f128b42014-11-28 15:07:47 +01002434 channel_shutw_now(res);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002435 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002436
2437 /* shutdown(write) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002438 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTW_NOW)) == CF_SHUTW_NOW &&
2439 channel_is_empty(res))) {
Willy Tarreauf61dd192022-05-27 09:00:19 +02002440 sc_shutw(scf);
Willy Tarreau05cdd962014-05-10 14:30:07 +02002441 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002442
2443 /* shutdown(write) done on the client side, we must stop the server too */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002444 if (unlikely((res->flags & (CF_SHUTW|CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTW) &&
2445 !res->analysers)
2446 channel_shutr_now(res);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002447
2448 /* shutdown(read) pending */
Willy Tarreau8f128b42014-11-28 15:07:47 +01002449 if (unlikely((res->flags & (CF_SHUTR|CF_SHUTR_NOW)) == CF_SHUTR_NOW)) {
Willy Tarreaucb041662022-05-17 19:44:42 +02002450 if (scb->flags & SC_FL_NOHALF)
2451 scb->flags |= SC_FL_NOLINGER;
Willy Tarreauf61dd192022-05-27 09:00:19 +02002452 sc_shutr(scb);
Willy Tarreau7bb68ab2012-05-13 14:48:59 +02002453 }
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002454
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002455 if (scf->state == SC_ST_DIS ||
Willy Tarreau74568cf2022-05-27 09:03:30 +02002456 sc_state_in(scb->state, SC_SB_RDY|SC_SB_DIS) ||
Willy Tarreau026e8fb2022-05-17 19:47:17 +02002457 (sc_ep_test(scf, SE_FL_ERROR) && scf->state != SC_ST_CLO) ||
2458 (sc_ep_test(scb, SE_FL_ERROR) && scb->state != SC_ST_CLO))
Willy Tarreau4596fe22022-05-17 19:07:51 +02002459 goto resync_stconns;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002460
Willy Tarreau3c5c0662019-06-06 14:32:49 +02002461 if ((req->flags & ~rqf_last) & CF_MASK_ANALYSER)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002462 goto resync_request;
2463
Willy Tarreau8f128b42014-11-28 15:07:47 +01002464 if ((res->flags ^ rpf_last) & CF_MASK_STATIC)
Willy Tarreau0be0ef92009-03-08 19:20:25 +01002465 goto resync_response;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002466
Willy Tarreau829bd472019-06-06 09:17:23 +02002467 if (((req->flags ^ rqf_last) | (res->flags ^ rpf_last)) & CF_MASK_ANALYSER)
2468 goto resync_request;
2469
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002470 /* we're interested in getting wakeups again */
Willy Tarreaucb041662022-05-17 19:44:42 +02002471 scf->flags &= ~SC_FL_DONT_WAKE;
2472 scb->flags &= ~SC_FL_DONT_WAKE;
Willy Tarreau89f7ef22009-09-05 20:57:35 +02002473
Willy Tarreau74568cf2022-05-27 09:03:30 +02002474 if (likely((scf->state != SC_ST_CLO) || !sc_state_in(scb->state, SC_SB_INI|SC_SB_CLO) ||
Christopher Faulet6fcd2d32019-11-13 11:12:32 +01002475 (req->analysers & AN_REQ_FLT_END) || (res->analysers & AN_RES_FLT_END))) {
Olivier Houchard4c18f942019-07-31 18:05:26 +02002476 if ((sess->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED) && !(s->flags & SF_IGNORE))
Willy Tarreau87b09662015-04-03 00:22:06 +02002477 stream_process_counters(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002478
Willy Tarreaub49672d2022-05-27 10:13:37 +02002479 stream_update_both_sc(s);
Olivier Houchard53216e72018-10-10 15:46:36 +02002480
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02002481 /* Trick: if a request is being waiting for the server to respond,
2482 * and if we know the server can timeout, we don't want the timeout
2483 * to expire on the client side first, but we're still interested
2484 * in passing data from the client to the server (eg: POST). Thus,
2485 * we can cancel the client's request timeout if the server's
2486 * request timeout is set and the server has not yet sent a response.
2487 */
2488
Willy Tarreau8f128b42014-11-28 15:07:47 +01002489 if ((res->flags & (CF_AUTO_CLOSE|CF_SHUTR)) == 0 &&
2490 (tick_isset(req->wex) || tick_isset(res->rex))) {
2491 req->flags |= CF_READ_NOEXP;
2492 req->rex = TICK_ETERNITY;
Willy Tarreau6f0a7ba2014-06-23 15:22:31 +02002493 }
2494
Christopher Faulet9d810ca2016-12-08 22:33:52 +01002495 /* Reset pending events now */
2496 s->pending_events = 0;
2497
Willy Tarreau798f4322012-11-08 14:49:17 +01002498 update_exp_and_leave:
Willy Tarreaucb041662022-05-17 19:44:42 +02002499 /* Note: please ensure that if you branch here you disable SC_FL_DONT_WAKE */
Christopher Fauleta00d8172016-11-10 14:58:05 +01002500 t->expire = tick_first((tick_is_expired(t->expire, now_ms) ? 0 : t->expire),
2501 tick_first(tick_first(req->rex, req->wex),
2502 tick_first(res->rex, res->wex)));
Willy Tarreaudef0d222016-11-08 22:03:00 +01002503 if (!req->analysers)
2504 req->analyse_exp = TICK_ETERNITY;
2505
2506 if ((sess->fe->options & PR_O_CONTSTATS) && (s->flags & SF_BE_ASSIGNED) &&
2507 (!tick_isset(req->analyse_exp) || tick_is_expired(req->analyse_exp, now_ms)))
2508 req->analyse_exp = tick_add(now_ms, 5000);
2509
2510 t->expire = tick_first(t->expire, req->analyse_exp);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002511
Willy Tarreau9a398be2017-11-10 17:14:23 +01002512 t->expire = tick_first(t->expire, res->analyse_exp);
2513
Christopher Fauletae024ce2022-03-29 19:02:31 +02002514 t->expire = tick_first(t->expire, s->conn_exp);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002515
Christopher Faulet9d810ca2016-12-08 22:33:52 +01002516 s->pending_events &= ~(TASK_WOKEN_TIMER | TASK_WOKEN_RES);
Willy Tarreau87b09662015-04-03 00:22:06 +02002517 stream_release_buffers(s);
Christopher Fauleteea8fc72019-11-05 16:18:10 +01002518
2519 DBG_TRACE_DEVEL("queuing", STRM_EV_STRM_PROC, s);
Willy Tarreau26c25062009-03-08 09:38:41 +01002520 return t; /* nothing more to do */
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002521 }
2522
Christopher Fauleteea8fc72019-11-05 16:18:10 +01002523 DBG_TRACE_DEVEL("releasing", STRM_EV_STRM_PROC, s);
2524
Willy Tarreaue7dff022015-04-03 01:14:29 +02002525 if (s->flags & SF_BE_ASSIGNED)
Willy Tarreau4781b152021-04-06 13:53:36 +02002526 _HA_ATOMIC_DEC(&s->be->beconn);
Willy Tarreau6f5e4b92017-09-15 09:07:56 +02002527
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002528 if (unlikely((global.mode & MODE_DEBUG) &&
2529 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)))) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002530 chunk_printf(&trash, "%08x:%s.closed[%04x:%04x]\n",
Christopher Faulet0256da12021-12-15 09:50:17 +01002531 s->uniq_id, s->be->id,
Willy Tarreaufd9417b2022-05-18 16:23:22 +02002532 (unsigned short)conn_fd(sc_conn(scf)),
2533 (unsigned short)conn_fd(sc_conn(scb)));
Willy Tarreau2e8ab6b2020-03-14 11:03:20 +01002534 DISGUISE(write(1, trash.area, trash.data));
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002535 }
2536
Christopher Faulet341064e2021-01-21 17:10:44 +01002537 if (!(s->flags & SF_IGNORE)) {
2538 s->logs.t_close = tv_ms_elapsed(&s->logs.tv_accept, &now);
2539
Olivier Houchard4c18f942019-07-31 18:05:26 +02002540 stream_process_counters(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002541
Christopher Faulet341064e2021-01-21 17:10:44 +01002542 if (s->txn && s->txn->status) {
2543 int n;
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002544
Christopher Faulet341064e2021-01-21 17:10:44 +01002545 n = s->txn->status / 100;
2546 if (n < 1 || n > 5)
2547 n = 0;
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002548
Christopher Faulet341064e2021-01-21 17:10:44 +01002549 if (sess->fe->mode == PR_MODE_HTTP) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002550 _HA_ATOMIC_INC(&sess->fe->fe_counters.p.http.rsp[n]);
Christopher Faulet341064e2021-01-21 17:10:44 +01002551 }
2552 if ((s->flags & SF_BE_ASSIGNED) &&
2553 (s->be->mode == PR_MODE_HTTP)) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002554 _HA_ATOMIC_INC(&s->be->be_counters.p.http.rsp[n]);
2555 _HA_ATOMIC_INC(&s->be->be_counters.p.http.cum_req);
Christopher Faulet341064e2021-01-21 17:10:44 +01002556 }
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002557 }
Christopher Faulet341064e2021-01-21 17:10:44 +01002558
2559 /* let's do a final log if we need it */
2560 if (!LIST_ISEMPTY(&sess->fe->logformat) && s->logs.logwait &&
2561 !(s->flags & SF_MONITOR) &&
2562 (!(sess->fe->options & PR_O_NULLNOLOG) || req->total)) {
2563 /* we may need to know the position in the queue */
2564 pendconn_free(s);
2565 s->do_log(s);
Willy Tarreau5e16cbc2012-11-24 14:54:13 +01002566 }
Krzysztof Piotr Oledzkide71d162009-10-24 15:36:15 +02002567
Christopher Faulet341064e2021-01-21 17:10:44 +01002568 /* update time stats for this stream */
2569 stream_update_time_stats(s);
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002570 }
2571
2572 /* the task MUST not be in the run queue anymore */
Willy Tarreau87b09662015-04-03 00:22:06 +02002573 stream_free(s);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002574 task_destroy(t);
Willy Tarreau26c25062009-03-08 09:38:41 +01002575 return NULL;
Willy Tarreau55a8d0e2008-11-30 18:47:21 +01002576}
2577
Willy Tarreau87b09662015-04-03 00:22:06 +02002578/* Update the stream's backend and server time stats */
2579void stream_update_time_stats(struct stream *s)
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002580{
2581 int t_request;
2582 int t_queue;
2583 int t_connect;
2584 int t_data;
2585 int t_close;
2586 struct server *srv;
Marcin Deraneka8dbdf32020-05-15 20:02:40 +02002587 unsigned int samples_window;
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002588
2589 t_request = 0;
2590 t_queue = s->logs.t_queue;
2591 t_connect = s->logs.t_connect;
2592 t_close = s->logs.t_close;
2593 t_data = s->logs.t_data;
2594
2595 if (s->be->mode != PR_MODE_HTTP)
2596 t_data = t_connect;
2597
2598 if (t_connect < 0 || t_data < 0)
2599 return;
2600
2601 if (tv_isge(&s->logs.tv_request, &s->logs.tv_accept))
2602 t_request = tv_ms_elapsed(&s->logs.tv_accept, &s->logs.tv_request);
2603
2604 t_data -= t_connect;
2605 t_connect -= t_queue;
2606 t_queue -= t_request;
2607
2608 srv = objt_server(s->target);
2609 if (srv) {
Marcin Deraneka8dbdf32020-05-15 20:02:40 +02002610 samples_window = (((s->be->mode == PR_MODE_HTTP) ?
2611 srv->counters.p.http.cum_req : srv->counters.cum_lbconn) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
2612 swrate_add_dynamic(&srv->counters.q_time, samples_window, t_queue);
2613 swrate_add_dynamic(&srv->counters.c_time, samples_window, t_connect);
2614 swrate_add_dynamic(&srv->counters.d_time, samples_window, t_data);
2615 swrate_add_dynamic(&srv->counters.t_time, samples_window, t_close);
Christopher Fauletefb41f02019-11-08 14:53:15 +01002616 HA_ATOMIC_UPDATE_MAX(&srv->counters.qtime_max, t_queue);
2617 HA_ATOMIC_UPDATE_MAX(&srv->counters.ctime_max, t_connect);
2618 HA_ATOMIC_UPDATE_MAX(&srv->counters.dtime_max, t_data);
2619 HA_ATOMIC_UPDATE_MAX(&srv->counters.ttime_max, t_close);
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002620 }
Marcin Deraneka8dbdf32020-05-15 20:02:40 +02002621 samples_window = (((s->be->mode == PR_MODE_HTTP) ?
2622 s->be->be_counters.p.http.cum_req : s->be->be_counters.cum_lbconn) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
2623 swrate_add_dynamic(&s->be->be_counters.q_time, samples_window, t_queue);
2624 swrate_add_dynamic(&s->be->be_counters.c_time, samples_window, t_connect);
2625 swrate_add_dynamic(&s->be->be_counters.d_time, samples_window, t_data);
2626 swrate_add_dynamic(&s->be->be_counters.t_time, samples_window, t_close);
Christopher Fauletefb41f02019-11-08 14:53:15 +01002627 HA_ATOMIC_UPDATE_MAX(&s->be->be_counters.qtime_max, t_queue);
2628 HA_ATOMIC_UPDATE_MAX(&s->be->be_counters.ctime_max, t_connect);
2629 HA_ATOMIC_UPDATE_MAX(&s->be->be_counters.dtime_max, t_data);
2630 HA_ATOMIC_UPDATE_MAX(&s->be->be_counters.ttime_max, t_close);
Willy Tarreau4bfc5802014-06-17 12:19:18 +02002631}
2632
Willy Tarreau7c669d72008-06-20 15:04:11 +02002633/*
2634 * This function adjusts sess->srv_conn and maintains the previous and new
Willy Tarreau87b09662015-04-03 00:22:06 +02002635 * server's served stream counts. Setting newsrv to NULL is enough to release
Willy Tarreau7c669d72008-06-20 15:04:11 +02002636 * current connection slot. This function also notifies any LB algo which might
Willy Tarreau87b09662015-04-03 00:22:06 +02002637 * expect to be informed about any change in the number of active streams on a
Willy Tarreau7c669d72008-06-20 15:04:11 +02002638 * server.
2639 */
Willy Tarreaue89fae32021-03-09 15:43:32 +01002640void sess_change_server(struct stream *strm, struct server *newsrv)
Willy Tarreau7c669d72008-06-20 15:04:11 +02002641{
Willy Tarreaue89fae32021-03-09 15:43:32 +01002642 struct server *oldsrv = strm->srv_conn;
Willy Tarreau751153e2021-02-17 13:33:24 +01002643
2644 if (oldsrv == newsrv)
Willy Tarreau7c669d72008-06-20 15:04:11 +02002645 return;
2646
Willy Tarreau751153e2021-02-17 13:33:24 +01002647 if (oldsrv) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002648 _HA_ATOMIC_DEC(&oldsrv->served);
2649 _HA_ATOMIC_DEC(&oldsrv->proxy->served);
Olivier Houcharddc6111e2019-03-08 18:54:51 +01002650 __ha_barrier_atomic_store();
Willy Tarreau59b0fec2021-02-17 16:01:37 +01002651 if (oldsrv->proxy->lbprm.server_drop_conn)
Willy Tarreau5941ef02021-06-18 18:29:25 +02002652 oldsrv->proxy->lbprm.server_drop_conn(oldsrv);
Willy Tarreaue89fae32021-03-09 15:43:32 +01002653 stream_del_srv_conn(strm);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002654 }
2655
2656 if (newsrv) {
Willy Tarreau4781b152021-04-06 13:53:36 +02002657 _HA_ATOMIC_INC(&newsrv->served);
2658 _HA_ATOMIC_INC(&newsrv->proxy->served);
Olivier Houcharddc6111e2019-03-08 18:54:51 +01002659 __ha_barrier_atomic_store();
Willy Tarreau59b0fec2021-02-17 16:01:37 +01002660 if (newsrv->proxy->lbprm.server_take_conn)
Willy Tarreau5941ef02021-06-18 18:29:25 +02002661 newsrv->proxy->lbprm.server_take_conn(newsrv);
Willy Tarreaue89fae32021-03-09 15:43:32 +01002662 stream_add_srv_conn(strm, newsrv);
Willy Tarreau7c669d72008-06-20 15:04:11 +02002663 }
2664}
2665
Willy Tarreau84455332009-03-15 22:34:05 +01002666/* Handle server-side errors for default protocols. It is called whenever a a
2667 * connection setup is aborted or a request is aborted in queue. It sets the
Willy Tarreau87b09662015-04-03 00:22:06 +02002668 * stream termination flags so that the caller does not have to worry about
Willy Tarreau4596fe22022-05-17 19:07:51 +02002669 * them. It's installed as ->srv_error for the server-side stream connector.
Willy Tarreau84455332009-03-15 22:34:05 +01002670 */
Willy Tarreaub49672d2022-05-27 10:13:37 +02002671void default_srv_error(struct stream *s, struct stconn *sc)
Willy Tarreau84455332009-03-15 22:34:05 +01002672{
Christopher Faulet50264b42022-03-30 19:39:30 +02002673 int err_type = s->conn_err_type;
Willy Tarreau84455332009-03-15 22:34:05 +01002674 int err = 0, fin = 0;
2675
Christopher Faulet50264b42022-03-30 19:39:30 +02002676 if (err_type & STRM_ET_QUEUE_ABRT) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002677 err = SF_ERR_CLICL;
2678 fin = SF_FINST_Q;
Willy Tarreau84455332009-03-15 22:34:05 +01002679 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002680 else if (err_type & STRM_ET_CONN_ABRT) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002681 err = SF_ERR_CLICL;
2682 fin = SF_FINST_C;
Willy Tarreau84455332009-03-15 22:34:05 +01002683 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002684 else if (err_type & STRM_ET_QUEUE_TO) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002685 err = SF_ERR_SRVTO;
2686 fin = SF_FINST_Q;
Willy Tarreau84455332009-03-15 22:34:05 +01002687 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002688 else if (err_type & STRM_ET_QUEUE_ERR) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002689 err = SF_ERR_SRVCL;
2690 fin = SF_FINST_Q;
Willy Tarreau84455332009-03-15 22:34:05 +01002691 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002692 else if (err_type & STRM_ET_CONN_TO) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002693 err = SF_ERR_SRVTO;
2694 fin = SF_FINST_C;
Willy Tarreau84455332009-03-15 22:34:05 +01002695 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002696 else if (err_type & STRM_ET_CONN_ERR) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002697 err = SF_ERR_SRVCL;
2698 fin = SF_FINST_C;
Willy Tarreau84455332009-03-15 22:34:05 +01002699 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002700 else if (err_type & STRM_ET_CONN_RES) {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002701 err = SF_ERR_RESOURCE;
2702 fin = SF_FINST_C;
Willy Tarreau2d400bb2012-05-14 12:11:47 +02002703 }
Christopher Faulet50264b42022-03-30 19:39:30 +02002704 else /* STRM_ET_CONN_OTHER and others */ {
Willy Tarreaue7dff022015-04-03 01:14:29 +02002705 err = SF_ERR_INTERNAL;
2706 fin = SF_FINST_C;
Willy Tarreau84455332009-03-15 22:34:05 +01002707 }
2708
Willy Tarreaue7dff022015-04-03 01:14:29 +02002709 if (!(s->flags & SF_ERR_MASK))
Willy Tarreau84455332009-03-15 22:34:05 +01002710 s->flags |= err;
Willy Tarreaue7dff022015-04-03 01:14:29 +02002711 if (!(s->flags & SF_FINST_MASK))
Willy Tarreau84455332009-03-15 22:34:05 +01002712 s->flags |= fin;
2713}
Willy Tarreau7c669d72008-06-20 15:04:11 +02002714
Willy Tarreaue7dff022015-04-03 01:14:29 +02002715/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
Willy Tarreau87b09662015-04-03 00:22:06 +02002716void stream_shutdown(struct stream *stream, int why)
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002717{
Willy Tarreau87b09662015-04-03 00:22:06 +02002718 if (stream->req.flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002719 return;
2720
Willy Tarreau87b09662015-04-03 00:22:06 +02002721 channel_shutw_now(&stream->req);
2722 channel_shutr_now(&stream->res);
2723 stream->task->nice = 1024;
Willy Tarreaue7dff022015-04-03 01:14:29 +02002724 if (!(stream->flags & SF_ERR_MASK))
Willy Tarreau87b09662015-04-03 00:22:06 +02002725 stream->flags |= why;
2726 task_wakeup(stream->task, TASK_WOKEN_OTHER);
Willy Tarreaua2a64e92011-09-07 23:01:56 +02002727}
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +02002728
Willy Tarreau5484d582019-05-22 09:33:03 +02002729/* Appends a dump of the state of stream <s> into buffer <buf> which must have
2730 * preliminary be prepared by its caller, with each line prepended by prefix
2731 * <pfx>, and each line terminated by character <eol>.
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002732 */
Willy Tarreau5484d582019-05-22 09:33:03 +02002733void stream_dump(struct buffer *buf, const struct stream *s, const char *pfx, char eol)
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002734{
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002735 const struct stconn *scf, *scb;
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002736 const struct connection *cof, *cob;
2737 const struct appctx *acf, *acb;
2738 const struct server *srv;
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002739 const char *src = "unknown";
2740 const char *dst = "unknown";
2741 char pn[INET6_ADDRSTRLEN];
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002742 const struct channel *req, *res;
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002743
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002744 if (!s) {
Willy Tarreau5484d582019-05-22 09:33:03 +02002745 chunk_appendf(buf, "%sstrm=%p%c", pfx, s, eol);
2746 return;
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002747 }
2748
Willy Tarreau5484d582019-05-22 09:33:03 +02002749 if (s->obj_type != OBJ_TYPE_STREAM) {
2750 chunk_appendf(buf, "%sstrm=%p [invalid type=%d(%s)]%c",
2751 pfx, s, s->obj_type, obj_type_name(&s->obj_type), eol);
2752 return;
2753 }
2754
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002755 req = &s->req;
2756 res = &s->res;
2757
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002758 scf = s->scf;
Willy Tarreaufd9417b2022-05-18 16:23:22 +02002759 cof = sc_conn(scf);
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02002760 acf = sc_appctx(scf);
Willy Tarreau71e34c12019-07-17 15:07:06 +02002761 if (cof && cof->src && addr_to_str(cof->src, pn, sizeof(pn)) >= 0)
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002762 src = pn;
2763 else if (acf)
2764 src = acf->applet->name;
2765
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002766 scb = s->scb;
Willy Tarreaufd9417b2022-05-18 16:23:22 +02002767 cob = sc_conn(scb);
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02002768 acb = sc_appctx(scb);
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002769 srv = objt_server(s->target);
2770 if (srv)
2771 dst = srv->id;
2772 else if (acb)
2773 dst = acb->applet->name;
2774
Willy Tarreau5484d582019-05-22 09:33:03 +02002775 chunk_appendf(buf,
Christopher Faulete8f35962021-11-02 17:18:15 +01002776 "%sstrm=%p,%x src=%s fe=%s be=%s dst=%s%c"
2777 "%stxn=%p,%x txn.req=%s,%x txn.rsp=%s,%x%c"
Christopher Fauletc77ceb62022-04-04 11:08:42 +02002778 "%srqf=%x rqa=%x rpf=%x rpa=%x%c"
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02002779 "%sscf=%p,%s,%x scb=%p,%s,%x%c"
Christopher Faulet13a35e52021-12-20 15:34:16 +01002780 "%saf=%p,%u sab=%p,%u%c"
Willy Tarreau5484d582019-05-22 09:33:03 +02002781 "%scof=%p,%x:%s(%p)/%s(%p)/%s(%d)%c"
2782 "%scob=%p,%x:%s(%p)/%s(%p)/%s(%d)%c"
2783 "",
Christopher Faulete8f35962021-11-02 17:18:15 +01002784 pfx, s, s->flags, src, s->sess->fe->id, s->be->id, dst, eol,
2785 pfx, s->txn, (s->txn ? s->txn->flags : 0),
2786 (s->txn ? h1_msg_state_str(s->txn->req.msg_state): "-"), (s->txn ? s->txn->req.flags : 0),
2787 (s->txn ? h1_msg_state_str(s->txn->rsp.msg_state): "-"), (s->txn ? s->txn->rsp.flags : 0), eol,
Christopher Fauletc77ceb62022-04-04 11:08:42 +02002788 pfx, req->flags, req->analysers, res->flags, res->analysers, eol,
Willy Tarreau74568cf2022-05-27 09:03:30 +02002789 pfx, scf, sc_state_str(scf->state), scf->flags, scb, sc_state_str(scb->state), scb->flags, eol,
Christopher Faulet13a35e52021-12-20 15:34:16 +01002790 pfx, acf, acf ? acf->st0 : 0, acb, acb ? acb->st0 : 0, eol,
Willy Tarreau5484d582019-05-22 09:33:03 +02002791 pfx, cof, cof ? cof->flags : 0, conn_get_mux_name(cof), cof?cof->ctx:0, conn_get_xprt_name(cof),
Willy Tarreaua57f3452022-04-11 17:58:06 +02002792 cof ? cof->xprt_ctx : 0, conn_get_ctrl_name(cof), conn_fd(cof), eol,
Willy Tarreau5484d582019-05-22 09:33:03 +02002793 pfx, cob, cob ? cob->flags : 0, conn_get_mux_name(cob), cob?cob->ctx:0, conn_get_xprt_name(cob),
Willy Tarreaua57f3452022-04-11 17:58:06 +02002794 cob ? cob->xprt_ctx : 0, conn_get_ctrl_name(cob), conn_fd(cob), eol);
Willy Tarreau5484d582019-05-22 09:33:03 +02002795}
2796
2797/* dumps an error message for type <type> at ptr <ptr> related to stream <s>,
Willy Tarreaub106ce12019-05-22 08:57:01 +02002798 * having reached loop rate <rate>, then aborts hoping to retrieve a core.
Willy Tarreau5484d582019-05-22 09:33:03 +02002799 */
2800void stream_dump_and_crash(enum obj_type *obj, int rate)
2801{
2802 const struct stream *s;
Willy Tarreau5484d582019-05-22 09:33:03 +02002803 char *msg = NULL;
2804 const void *ptr;
2805
2806 ptr = s = objt_stream(obj);
2807 if (!s) {
2808 const struct appctx *appctx = objt_appctx(obj);
2809 if (!appctx)
2810 return;
2811 ptr = appctx;
Willy Tarreau0698c802022-05-11 14:09:57 +02002812 s = appctx_strm(appctx);
Willy Tarreau5484d582019-05-22 09:33:03 +02002813 if (!s)
2814 return;
2815 }
2816
Willy Tarreau5484d582019-05-22 09:33:03 +02002817 chunk_reset(&trash);
2818 stream_dump(&trash, s, "", ' ');
Willy Tarreau9753d612020-05-01 16:57:02 +02002819
2820 chunk_appendf(&trash, "filters={");
2821 if (HAS_FILTERS(s)) {
2822 struct filter *filter;
2823
2824 list_for_each_entry(filter, &s->strm_flt.filters, list) {
2825 if (filter->list.p != &s->strm_flt.filters)
2826 chunk_appendf(&trash, ", ");
2827 chunk_appendf(&trash, "%p=\"%s\"", filter, FLT_ID(filter));
2828 }
2829 }
2830 chunk_appendf(&trash, "}");
2831
Willy Tarreaub106ce12019-05-22 08:57:01 +02002832 memprintf(&msg,
2833 "A bogus %s [%p] is spinning at %d calls per second and refuses to die, "
2834 "aborting now! Please report this error to developers "
2835 "[%s]\n",
Willy Tarreau5484d582019-05-22 09:33:03 +02002836 obj_type_name(obj), ptr, rate, trash.area);
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002837
2838 ha_alert("%s", msg);
2839 send_log(NULL, LOG_EMERG, "%s", msg);
Willy Tarreau2f67e542021-03-02 19:19:41 +01002840 ABORT_NOW();
Willy Tarreau71c07ac2019-04-25 19:08:48 +02002841}
2842
Willy Tarreaua698eb62021-02-24 10:37:01 +01002843/* initialize the require structures */
2844static void init_stream()
2845{
2846 int thr;
2847
2848 for (thr = 0; thr < MAX_THREADS; thr++)
Willy Tarreaub4e34762021-09-30 19:02:18 +02002849 LIST_INIT(&ha_thread_ctx[thr].streams);
Willy Tarreaua698eb62021-02-24 10:37:01 +01002850}
2851INITCALL0(STG_INIT, init_stream);
2852
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002853/* Generates a unique ID based on the given <format>, stores it in the given <strm> and
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002854 * returns the unique ID.
Tim Duesterhus7ad27d42022-05-18 00:22:15 +02002855 *
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002856 * If this function fails to allocate memory IST_NULL is returned.
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002857 *
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002858 * If an ID is already stored within the stream nothing happens existing unique ID is
2859 * returned.
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002860 */
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002861struct ist stream_generate_unique_id(struct stream *strm, struct list *format)
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002862{
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002863 if (isttest(strm->unique_id)) {
2864 return strm->unique_id;
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002865 }
2866 else {
2867 char *unique_id;
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002868 int length;
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002869 if ((unique_id = pool_alloc(pool_head_uniqueid)) == NULL)
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002870 return IST_NULL;
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002871
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002872 length = build_logline(strm, unique_id, UNIQUEID_LEN, format);
2873 strm->unique_id = ist2(unique_id, length);
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002874
Tim Duesterhusa17e6622020-03-05 20:19:02 +01002875 return strm->unique_id;
Tim Duesterhus127a74d2020-02-28 15:13:33 +01002876 }
2877}
2878
Willy Tarreau8b22a712010-06-18 17:46:06 +02002879/************************************************************************/
2880/* All supported ACL keywords must be declared here. */
2881/************************************************************************/
Christopher Faulet551a6412021-06-25 14:35:29 +02002882static enum act_return stream_action_set_log_level(struct act_rule *rule, struct proxy *px,
2883 struct session *sess, struct stream *s, int flags)
2884{
2885 s->logs.level = (uintptr_t)rule->arg.act.p[0];
2886 return ACT_RET_CONT;
2887}
2888
2889
2890/* Parse a "set-log-level" action. It takes the level value as argument. It
2891 * returns ACT_RET_PRS_OK on success, ACT_RET_PRS_ERR on error.
2892 */
2893static enum act_parse_ret stream_parse_set_log_level(const char **args, int *cur_arg, struct proxy *px,
2894 struct act_rule *rule, char **err)
2895{
2896 int level;
2897
2898 if (!*args[*cur_arg]) {
2899 bad_log_level:
2900 memprintf(err, "expects exactly 1 argument (log level name or 'silent')");
2901 return ACT_RET_PRS_ERR;
2902 }
2903 if (strcmp(args[*cur_arg], "silent") == 0)
2904 level = -1;
2905 else if ((level = get_log_level(args[*cur_arg]) + 1) == 0)
2906 goto bad_log_level;
2907
2908 (*cur_arg)++;
2909
2910 /* Register processing function. */
2911 rule->action_ptr = stream_action_set_log_level;
2912 rule->action = ACT_CUSTOM;
2913 rule->arg.act.p[0] = (void *)(uintptr_t)level;
2914 return ACT_RET_PRS_OK;
2915}
2916
Christopher Faulet1da374a2021-06-25 14:46:02 +02002917static enum act_return stream_action_set_nice(struct act_rule *rule, struct proxy *px,
2918 struct session *sess, struct stream *s, int flags)
2919{
2920 s->task->nice = (uintptr_t)rule->arg.act.p[0];
2921 return ACT_RET_CONT;
2922}
2923
2924
2925/* Parse a "set-nice" action. It takes the nice value as argument. It returns
2926 * ACT_RET_PRS_OK on success, ACT_RET_PRS_ERR on error.
2927 */
2928static enum act_parse_ret stream_parse_set_nice(const char **args, int *cur_arg, struct proxy *px,
2929 struct act_rule *rule, char **err)
2930{
2931 int nice;
2932
2933 if (!*args[*cur_arg]) {
2934 bad_log_level:
2935 memprintf(err, "expects exactly 1 argument (integer value)");
2936 return ACT_RET_PRS_ERR;
2937 }
2938
2939 nice = atoi(args[*cur_arg]);
2940 if (nice < -1024)
2941 nice = -1024;
2942 else if (nice > 1024)
2943 nice = 1024;
2944
2945 (*cur_arg)++;
2946
2947 /* Register processing function. */
2948 rule->action_ptr = stream_action_set_nice;
2949 rule->action = ACT_CUSTOM;
2950 rule->arg.act.p[0] = (void *)(uintptr_t)nice;
2951 return ACT_RET_PRS_OK;
2952}
2953
Christopher Faulet551a6412021-06-25 14:35:29 +02002954
Christopher Fauletae863c62021-03-15 12:03:44 +01002955static enum act_return tcp_action_switch_stream_mode(struct act_rule *rule, struct proxy *px,
2956 struct session *sess, struct stream *s, int flags)
2957{
2958 enum pr_mode mode = (uintptr_t)rule->arg.act.p[0];
2959 const struct mux_proto_list *mux_proto = rule->arg.act.p[1];
2960
2961 if (!IS_HTX_STRM(s) && mode == PR_MODE_HTTP) {
2962 if (!stream_set_http_mode(s, mux_proto)) {
2963 channel_abort(&s->req);
2964 channel_abort(&s->res);
2965 return ACT_RET_ABRT;
2966 }
2967 }
2968 return ACT_RET_STOP;
2969}
2970
2971
2972static int check_tcp_switch_stream_mode(struct act_rule *rule, struct proxy *px, char **err)
2973{
2974 const struct mux_proto_list *mux_ent;
2975 const struct mux_proto_list *mux_proto = rule->arg.act.p[1];
2976 enum pr_mode pr_mode = (uintptr_t)rule->arg.act.p[0];
2977 enum proto_proxy_mode mode = (1 << (pr_mode == PR_MODE_HTTP));
2978
Christopher Faulet3b6446f2021-03-15 15:10:38 +01002979 if (pr_mode == PR_MODE_HTTP)
2980 px->options |= PR_O_HTTP_UPG;
2981
Christopher Fauletae863c62021-03-15 12:03:44 +01002982 if (mux_proto) {
2983 mux_ent = conn_get_best_mux_entry(mux_proto->token, PROTO_SIDE_FE, mode);
2984 if (!mux_ent || !isteq(mux_ent->token, mux_proto->token)) {
2985 memprintf(err, "MUX protocol '%.*s' is not compatible with the selected mode",
2986 (int)mux_proto->token.len, mux_proto->token.ptr);
2987 return 0;
2988 }
2989 }
2990 else {
2991 mux_ent = conn_get_best_mux_entry(IST_NULL, PROTO_SIDE_FE, mode);
2992 if (!mux_ent) {
2993 memprintf(err, "Unable to find compatible MUX protocol with the selected mode");
2994 return 0;
2995 }
2996 }
2997
2998 /* Update the mux */
2999 rule->arg.act.p[1] = (void *)mux_ent;
3000 return 1;
3001
3002}
3003
3004static enum act_parse_ret stream_parse_switch_mode(const char **args, int *cur_arg,
3005 struct proxy *px, struct act_rule *rule,
3006 char **err)
3007{
3008 const struct mux_proto_list *mux_proto = NULL;
3009 struct ist proto;
3010 enum pr_mode mode;
3011
3012 /* must have at least the mode */
3013 if (*(args[*cur_arg]) == 0) {
3014 memprintf(err, "'%s %s' expects a mode as argument.", args[0], args[*cur_arg-1]);
3015 return ACT_RET_PRS_ERR;
3016 }
3017
3018 if (!(px->cap & PR_CAP_FE)) {
3019 memprintf(err, "'%s %s' not allowed because %s '%s' has no frontend capability",
3020 args[0], args[*cur_arg-1], proxy_type_str(px), px->id);
3021 return ACT_RET_PRS_ERR;
3022 }
3023 /* Check if the mode. For now "tcp" is disabled because downgrade is not
3024 * supported and PT is the only TCP mux.
3025 */
3026 if (strcmp(args[*cur_arg], "http") == 0)
3027 mode = PR_MODE_HTTP;
3028 else {
3029 memprintf(err, "'%s %s' expects a valid mode (got '%s').", args[0], args[*cur_arg-1], args[*cur_arg]);
3030 return ACT_RET_PRS_ERR;
3031 }
3032
3033 /* check the proto, if specified */
3034 if (*(args[*cur_arg+1]) && strcmp(args[*cur_arg+1], "proto") == 0) {
3035 if (*(args[*cur_arg+2]) == 0) {
3036 memprintf(err, "'%s %s': '%s' expects a protocol as argument.",
3037 args[0], args[*cur_arg-1], args[*cur_arg+1]);
3038 return ACT_RET_PRS_ERR;
3039 }
3040
Tim Duesterhusb113b5c2021-09-15 13:58:44 +02003041 proto = ist(args[*cur_arg + 2]);
Christopher Fauletae863c62021-03-15 12:03:44 +01003042 mux_proto = get_mux_proto(proto);
3043 if (!mux_proto) {
3044 memprintf(err, "'%s %s': '%s' expects a valid MUX protocol, if specified (got '%s')",
3045 args[0], args[*cur_arg-1], args[*cur_arg+1], args[*cur_arg+2]);
3046 return ACT_RET_PRS_ERR;
3047 }
3048 *cur_arg += 2;
3049 }
3050
3051 (*cur_arg)++;
3052
3053 /* Register processing function. */
3054 rule->action_ptr = tcp_action_switch_stream_mode;
3055 rule->check_ptr = check_tcp_switch_stream_mode;
3056 rule->action = ACT_CUSTOM;
3057 rule->arg.act.p[0] = (void *)(uintptr_t)mode;
3058 rule->arg.act.p[1] = (void *)mux_proto;
3059 return ACT_RET_PRS_OK;
3060}
Willy Tarreau8b22a712010-06-18 17:46:06 +02003061
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003062/* 0=OK, <0=Alert, >0=Warning */
3063static enum act_parse_ret stream_parse_use_service(const char **args, int *cur_arg,
3064 struct proxy *px, struct act_rule *rule,
3065 char **err)
3066{
3067 struct action_kw *kw;
3068
3069 /* Check if the service name exists. */
3070 if (*(args[*cur_arg]) == 0) {
3071 memprintf(err, "'%s' expects a service name.", args[0]);
Thierry FOURNIER337eae12015-11-26 19:48:04 +01003072 return ACT_RET_PRS_ERR;
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003073 }
3074
3075 /* lookup for keyword corresponding to a service. */
3076 kw = action_lookup(&service_keywords, args[*cur_arg]);
3077 if (!kw) {
3078 memprintf(err, "'%s' unknown service name.", args[1]);
3079 return ACT_RET_PRS_ERR;
3080 }
3081 (*cur_arg)++;
3082
3083 /* executes specific rule parser. */
3084 rule->kw = kw;
3085 if (kw->parse((const char **)args, cur_arg, px, rule, err) == ACT_RET_PRS_ERR)
3086 return ACT_RET_PRS_ERR;
3087
3088 /* Register processing function. */
3089 rule->action_ptr = process_use_service;
3090 rule->action = ACT_CUSTOM;
3091
3092 return ACT_RET_PRS_OK;
3093}
3094
3095void service_keywords_register(struct action_kw_list *kw_list)
3096{
Willy Tarreau2b718102021-04-21 07:32:39 +02003097 LIST_APPEND(&service_keywords, &kw_list->list);
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003098}
3099
Thierry Fournier87e53992020-11-28 19:32:14 +01003100struct action_kw *service_find(const char *kw)
3101{
3102 return action_lookup(&service_keywords, kw);
3103}
3104
Willy Tarreau5fcc1002022-03-29 15:10:44 +02003105/* Lists the known services on <out>. If <out> is null, emit them on stdout one
3106 * per line.
3107 */
Willy Tarreau679bba12019-03-19 08:08:10 +01003108void list_services(FILE *out)
3109{
Willy Tarreau3f0b2e82022-03-30 12:12:44 +02003110 const struct action_kw *akwp, *akwn;
Willy Tarreau679bba12019-03-19 08:08:10 +01003111 struct action_kw_list *kw_list;
3112 int found = 0;
3113 int i;
3114
Willy Tarreau5fcc1002022-03-29 15:10:44 +02003115 if (out)
3116 fprintf(out, "Available services :");
Willy Tarreau3f0b2e82022-03-30 12:12:44 +02003117
3118 for (akwn = akwp = NULL;; akwp = akwn) {
3119 list_for_each_entry(kw_list, &service_keywords, list) {
3120 for (i = 0; kw_list->kw[i].kw != NULL; i++) {
3121 if (strordered(akwp ? akwp->kw : NULL,
3122 kw_list->kw[i].kw,
3123 akwn != akwp ? akwn->kw : NULL))
3124 akwn = &kw_list->kw[i];
3125 found = 1;
3126 }
Willy Tarreau679bba12019-03-19 08:08:10 +01003127 }
Willy Tarreau3f0b2e82022-03-30 12:12:44 +02003128 if (akwn == akwp)
3129 break;
3130 if (out)
3131 fprintf(out, " %s", akwn->kw);
3132 else
3133 printf("%s\n", akwn->kw);
Willy Tarreau679bba12019-03-19 08:08:10 +01003134 }
Willy Tarreau5fcc1002022-03-29 15:10:44 +02003135 if (!found && out)
Willy Tarreau679bba12019-03-19 08:08:10 +01003136 fprintf(out, " none\n");
3137}
William Lallemand4c5b4d52016-11-21 08:51:11 +01003138
Willy Tarreau39f097d2022-05-03 10:49:00 +02003139/* appctx context used by the "show sess" command */
3140
3141struct show_sess_ctx {
3142 struct bref bref; /* back-reference from the session being dumped */
3143 void *target; /* session we want to dump, or NULL for all */
3144 unsigned int thr; /* the thread number being explored (0..MAX_THREADS-1) */
3145 unsigned int uid; /* if non-null, the uniq_id of the session being dumped */
3146 int section; /* section of the session being dumped */
3147 int pos; /* last position of the current session's buffer */
3148};
3149
Willy Tarreau4596fe22022-05-17 19:07:51 +02003150/* This function dumps a complete stream state onto the stream connector's
William Lallemand4c5b4d52016-11-21 08:51:11 +01003151 * read buffer. The stream has to be set in strm. It returns 0 if the output
3152 * buffer is full and it needs to be called again, otherwise non-zero. It is
3153 * designed to be called from stats_dump_strm_to_buffer() below.
3154 */
Willy Tarreaub49672d2022-05-27 10:13:37 +02003155static int stats_dump_full_strm_to_buffer(struct stconn *sc, struct stream *strm)
William Lallemand4c5b4d52016-11-21 08:51:11 +01003156{
Willy Tarreaub49672d2022-05-27 10:13:37 +02003157 struct appctx *appctx = __sc_appctx(sc);
Willy Tarreau39f097d2022-05-03 10:49:00 +02003158 struct show_sess_ctx *ctx = appctx->svcctx;
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003159 struct stconn *scf, *scb;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003160 struct tm tm;
3161 extern const char *monthname[12];
3162 char pn[INET6_ADDRSTRLEN];
3163 struct connection *conn;
3164 struct appctx *tmpctx;
3165
3166 chunk_reset(&trash);
3167
Willy Tarreau39f097d2022-05-03 10:49:00 +02003168 if (ctx->section > 0 && ctx->uid != strm->uniq_id) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003169 /* stream changed, no need to go any further */
3170 chunk_appendf(&trash, " *** session terminated while we were watching it ***\n");
Willy Tarreaud0a06d52022-05-18 15:07:19 +02003171 if (applet_putchk(appctx, &trash) == -1)
Willy Tarreaue6e52362019-01-04 17:42:57 +01003172 goto full;
3173 goto done;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003174 }
3175
Willy Tarreau39f097d2022-05-03 10:49:00 +02003176 switch (ctx->section) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003177 case 0: /* main status of the stream */
Willy Tarreau39f097d2022-05-03 10:49:00 +02003178 ctx->uid = strm->uniq_id;
3179 ctx->section = 1;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003180 /* fall through */
3181
3182 case 1:
3183 get_localtime(strm->logs.accept_date.tv_sec, &tm);
3184 chunk_appendf(&trash,
3185 "%p: [%02d/%s/%04d:%02d:%02d:%02d.%06d] id=%u proto=%s",
3186 strm,
3187 tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3188 tm.tm_hour, tm.tm_min, tm.tm_sec, (int)(strm->logs.accept_date.tv_usec),
3189 strm->uniq_id,
Willy Tarreaub7436612020-08-28 19:51:44 +02003190 strm_li(strm) ? strm_li(strm)->rx.proto->name : "?");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003191
3192 conn = objt_conn(strm_orig(strm));
Willy Tarreau71e34c12019-07-17 15:07:06 +02003193 switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003194 case AF_INET:
3195 case AF_INET6:
3196 chunk_appendf(&trash, " source=%s:%d\n",
Willy Tarreau71e34c12019-07-17 15:07:06 +02003197 pn, get_host_port(conn->src));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003198 break;
3199 case AF_UNIX:
3200 chunk_appendf(&trash, " source=unix:%d\n", strm_li(strm)->luid);
3201 break;
3202 default:
3203 /* no more information to print right now */
3204 chunk_appendf(&trash, "\n");
3205 break;
3206 }
3207
3208 chunk_appendf(&trash,
Christopher Faulet50264b42022-03-30 19:39:30 +02003209 " flags=0x%x, conn_retries=%d, conn_exp=%s conn_et=0x%03x srv_conn=%p, pend_pos=%p waiting=%d epoch=%#x\n",
Christopher Fauletae024ce2022-03-29 19:02:31 +02003210 strm->flags, strm->conn_retries,
3211 strm->conn_exp ?
3212 tick_is_expired(strm->conn_exp, now_ms) ? "<PAST>" :
3213 human_time(TICKS_TO_MS(strm->conn_exp - now_ms),
3214 TICKS_TO_MS(1000)) : "<NEVER>",
Christopher Faulet50264b42022-03-30 19:39:30 +02003215 strm->conn_err_type, strm->srv_conn, strm->pend_pos,
Willy Tarreau2b718102021-04-21 07:32:39 +02003216 LIST_INLIST(&strm->buffer_wait.list), strm->stream_epoch);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003217
3218 chunk_appendf(&trash,
3219 " frontend=%s (id=%u mode=%s), listener=%s (id=%u)",
William Lallemandb0dfd092022-03-08 12:05:31 +01003220 strm_fe(strm)->id, strm_fe(strm)->uuid, proxy_mode_str(strm_fe(strm)->mode),
William Lallemand4c5b4d52016-11-21 08:51:11 +01003221 strm_li(strm) ? strm_li(strm)->name ? strm_li(strm)->name : "?" : "?",
3222 strm_li(strm) ? strm_li(strm)->luid : 0);
3223
Willy Tarreau71e34c12019-07-17 15:07:06 +02003224 switch (conn && conn_get_dst(conn) ? addr_to_str(conn->dst, pn, sizeof(pn)) : AF_UNSPEC) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003225 case AF_INET:
3226 case AF_INET6:
3227 chunk_appendf(&trash, " addr=%s:%d\n",
Willy Tarreau71e34c12019-07-17 15:07:06 +02003228 pn, get_host_port(conn->dst));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003229 break;
3230 case AF_UNIX:
3231 chunk_appendf(&trash, " addr=unix:%d\n", strm_li(strm)->luid);
3232 break;
3233 default:
3234 /* no more information to print right now */
3235 chunk_appendf(&trash, "\n");
3236 break;
3237 }
3238
3239 if (strm->be->cap & PR_CAP_BE)
3240 chunk_appendf(&trash,
3241 " backend=%s (id=%u mode=%s)",
3242 strm->be->id,
William Lallemandb0dfd092022-03-08 12:05:31 +01003243 strm->be->uuid, proxy_mode_str(strm->be->mode));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003244 else
3245 chunk_appendf(&trash, " backend=<NONE> (id=-1 mode=-)");
3246
Willy Tarreaufd9417b2022-05-18 16:23:22 +02003247 conn = sc_conn(strm->scb);
Willy Tarreau71e34c12019-07-17 15:07:06 +02003248 switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003249 case AF_INET:
3250 case AF_INET6:
3251 chunk_appendf(&trash, " addr=%s:%d\n",
Willy Tarreau71e34c12019-07-17 15:07:06 +02003252 pn, get_host_port(conn->src));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003253 break;
3254 case AF_UNIX:
3255 chunk_appendf(&trash, " addr=unix\n");
3256 break;
3257 default:
3258 /* no more information to print right now */
3259 chunk_appendf(&trash, "\n");
3260 break;
3261 }
3262
3263 if (strm->be->cap & PR_CAP_BE)
3264 chunk_appendf(&trash,
3265 " server=%s (id=%u)",
Willy Tarreau88bc8002021-12-06 07:01:02 +00003266 objt_server(strm->target) ? __objt_server(strm->target)->id : "<none>",
3267 objt_server(strm->target) ? __objt_server(strm->target)->puid : 0);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003268 else
3269 chunk_appendf(&trash, " server=<NONE> (id=-1)");
3270
Willy Tarreau71e34c12019-07-17 15:07:06 +02003271 switch (conn && conn_get_dst(conn) ? addr_to_str(conn->dst, pn, sizeof(pn)) : AF_UNSPEC) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003272 case AF_INET:
3273 case AF_INET6:
3274 chunk_appendf(&trash, " addr=%s:%d\n",
Willy Tarreau71e34c12019-07-17 15:07:06 +02003275 pn, get_host_port(conn->dst));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003276 break;
3277 case AF_UNIX:
3278 chunk_appendf(&trash, " addr=unix\n");
3279 break;
3280 default:
3281 /* no more information to print right now */
3282 chunk_appendf(&trash, "\n");
3283 break;
3284 }
3285
3286 chunk_appendf(&trash,
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003287 " task=%p (state=0x%02x nice=%d calls=%u rate=%u exp=%s tid=%d tmask=0x%lx%s",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003288 strm->task,
3289 strm->task->state,
Willy Tarreau2e9c1d22019-04-24 08:28:31 +02003290 strm->task->nice, strm->task->calls, read_freq_ctr(&strm->call_rate),
William Lallemand4c5b4d52016-11-21 08:51:11 +01003291 strm->task->expire ?
3292 tick_is_expired(strm->task->expire, now_ms) ? "<PAST>" :
3293 human_time(TICKS_TO_MS(strm->task->expire - now_ms),
3294 TICKS_TO_MS(1000)) : "<NEVER>",
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003295 strm->task->tid,
Christopher Fauletf0205062017-11-15 20:56:43 +01003296 strm->task->thread_mask,
William Lallemand4c5b4d52016-11-21 08:51:11 +01003297 task_in_rq(strm->task) ? ", running" : "");
3298
3299 chunk_appendf(&trash,
3300 " age=%s)\n",
3301 human_time(now.tv_sec - strm->logs.accept_date.tv_sec, 1));
3302
3303 if (strm->txn)
3304 chunk_appendf(&trash,
Christopher Fauletbcac7862019-07-17 10:46:50 +02003305 " txn=%p flags=0x%x meth=%d status=%d req.st=%s rsp.st=%s req.f=0x%02x rsp.f=0x%02x\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003306 strm->txn, strm->txn->flags, strm->txn->meth, strm->txn->status,
Willy Tarreau7778b592019-01-07 10:38:10 +01003307 h1_msg_state_str(strm->txn->req.msg_state), h1_msg_state_str(strm->txn->rsp.msg_state),
Christopher Fauletbcac7862019-07-17 10:46:50 +02003308 strm->txn->req.flags, strm->txn->rsp.flags);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003309
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003310 scf = strm->scf;
3311 chunk_appendf(&trash, " scf=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
Willy Tarreau74568cf2022-05-27 09:03:30 +02003312 scf, scf->flags, sc_state_str(scf->state),
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003313 (sc_ep_test(scf, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scf, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
3314 scf->sedesc->se, sc_ep_get(scf), scf->wait_event.events);
Olivier Houchard9aaf7782017-09-13 18:30:23 +02003315
Willy Tarreaufd9417b2022-05-18 16:23:22 +02003316 if ((conn = sc_conn(scf)) != NULL) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003317 chunk_appendf(&trash,
Christopher Faulet13a35e52021-12-20 15:34:16 +01003318 " co0=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003319 conn,
3320 conn_get_ctrl_name(conn),
3321 conn_get_xprt_name(conn),
Willy Tarreau53a47662017-08-28 10:53:00 +02003322 conn_get_mux_name(conn),
Willy Tarreauf8d0ab52022-05-18 18:00:31 +02003323 sc_get_data_name(scf),
William Lallemand4c5b4d52016-11-21 08:51:11 +01003324 obj_type_name(conn->target),
3325 obj_base_ptr(conn->target));
3326
3327 chunk_appendf(&trash,
Willy Tarreau76913d32019-08-30 14:33:11 +02003328 " flags=0x%08x fd=%d fd.state=%02x updt=%d fd.tmask=0x%lx\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003329 conn->flags,
Willy Tarreaua57f3452022-04-11 17:58:06 +02003330 conn_fd(conn),
3331 conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].state : 0,
3332 conn_fd(conn) >= 0 ? !!(fdtab[conn->handle.fd].update_mask & tid_bit) : 0,
3333 conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0);
Willy Tarreaufb3b1b02018-12-18 14:28:24 +01003334
William Lallemand4c5b4d52016-11-21 08:51:11 +01003335 }
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02003336 else if ((tmpctx = sc_appctx(scf)) != NULL) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003337 chunk_appendf(&trash,
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003338 " app0=%p st0=%d st1=%d st2=%d applet=%s tid=%d tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003339 tmpctx,
3340 tmpctx->st0,
3341 tmpctx->st1,
Willy Tarreauc7afedc2022-05-05 20:01:54 +02003342 tmpctx->_st2,
Christopher Fauletf0205062017-11-15 20:56:43 +01003343 tmpctx->applet->name,
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003344 tmpctx->t->tid,
Willy Tarreau4c6986a2021-07-13 18:01:46 +02003345 tmpctx->t->thread_mask,
Willy Tarreau22d63a22019-04-24 08:41:29 +02003346 tmpctx->t->nice, tmpctx->t->calls, read_freq_ctr(&tmpctx->call_rate),
Willy Tarreau9efd7452018-05-31 14:48:54 +02003347 (unsigned long long)tmpctx->t->cpu_time, (unsigned long long)tmpctx->t->lat_time);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003348 }
3349
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003350 scb = strm->scb;
3351 chunk_appendf(&trash, " scb=%p flags=0x%08x state=%s endp=%s,%p,0x%08x sub=%d\n",
Willy Tarreau74568cf2022-05-27 09:03:30 +02003352 scb, scb->flags, sc_state_str(scb->state),
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003353 (sc_ep_test(scb, SE_FL_T_MUX) ? "CONN" : (sc_ep_test(scb, SE_FL_T_APPLET) ? "APPCTX" : "NONE")),
3354 scb->sedesc->se, sc_ep_get(scb), scb->wait_event.events);
Willy Tarreaub605c422022-05-17 17:04:55 +02003355
Willy Tarreaufd9417b2022-05-18 16:23:22 +02003356 if ((conn = sc_conn(scb)) != NULL) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003357 chunk_appendf(&trash,
Christopher Faulet13a35e52021-12-20 15:34:16 +01003358 " co1=%p ctrl=%s xprt=%s mux=%s data=%s target=%s:%p\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003359 conn,
3360 conn_get_ctrl_name(conn),
3361 conn_get_xprt_name(conn),
Willy Tarreau53a47662017-08-28 10:53:00 +02003362 conn_get_mux_name(conn),
Willy Tarreauf8d0ab52022-05-18 18:00:31 +02003363 sc_get_data_name(scb),
William Lallemand4c5b4d52016-11-21 08:51:11 +01003364 obj_type_name(conn->target),
3365 obj_base_ptr(conn->target));
3366
3367 chunk_appendf(&trash,
Willy Tarreau76913d32019-08-30 14:33:11 +02003368 " flags=0x%08x fd=%d fd.state=%02x updt=%d fd.tmask=0x%lx\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003369 conn->flags,
Willy Tarreaua57f3452022-04-11 17:58:06 +02003370 conn_fd(conn),
3371 conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].state : 0,
3372 conn_fd(conn) >= 0 ? !!(fdtab[conn->handle.fd].update_mask & tid_bit) : 0,
3373 conn_fd(conn) >= 0 ? fdtab[conn->handle.fd].thread_mask: 0);
Willy Tarreaufb3b1b02018-12-18 14:28:24 +01003374
William Lallemand4c5b4d52016-11-21 08:51:11 +01003375 }
Willy Tarreau8e7c6e62022-05-18 17:58:02 +02003376 else if ((tmpctx = sc_appctx(scb)) != NULL) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003377 chunk_appendf(&trash,
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003378 " app1=%p st0=%d st1=%d st2=%d applet=%s tid=%d tmask=0x%lx nice=%d calls=%u rate=%u cpu=%llu lat=%llu\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003379 tmpctx,
3380 tmpctx->st0,
3381 tmpctx->st1,
Willy Tarreauc7afedc2022-05-05 20:01:54 +02003382 tmpctx->_st2,
Christopher Fauletf0205062017-11-15 20:56:43 +01003383 tmpctx->applet->name,
Willy Tarreau6ef52f42022-06-15 14:19:48 +02003384 tmpctx->t->tid,
Willy Tarreau4c6986a2021-07-13 18:01:46 +02003385 tmpctx->t->thread_mask,
Willy Tarreau22d63a22019-04-24 08:41:29 +02003386 tmpctx->t->nice, tmpctx->t->calls, read_freq_ctr(&tmpctx->call_rate),
Willy Tarreau9efd7452018-05-31 14:48:54 +02003387 (unsigned long long)tmpctx->t->cpu_time, (unsigned long long)tmpctx->t->lat_time);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003388 }
3389
3390 chunk_appendf(&trash,
3391 " req=%p (f=0x%06x an=0x%x pipe=%d tofwd=%d total=%lld)\n"
3392 " an_exp=%s",
3393 &strm->req,
3394 strm->req.flags, strm->req.analysers,
3395 strm->req.pipe ? strm->req.pipe->data : 0,
3396 strm->req.to_forward, strm->req.total,
3397 strm->req.analyse_exp ?
3398 human_time(TICKS_TO_MS(strm->req.analyse_exp - now_ms),
3399 TICKS_TO_MS(1000)) : "<NEVER>");
3400
3401 chunk_appendf(&trash,
3402 " rex=%s",
3403 strm->req.rex ?
3404 human_time(TICKS_TO_MS(strm->req.rex - now_ms),
3405 TICKS_TO_MS(1000)) : "<NEVER>");
3406
3407 chunk_appendf(&trash,
3408 " wex=%s\n"
Christopher Fauletbcac7862019-07-17 10:46:50 +02003409 " buf=%p data=%p o=%u p=%u i=%u size=%u\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003410 strm->req.wex ?
3411 human_time(TICKS_TO_MS(strm->req.wex - now_ms),
3412 TICKS_TO_MS(1000)) : "<NEVER>",
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003413 &strm->req.buf,
3414 b_orig(&strm->req.buf), (unsigned int)co_data(&strm->req),
Christopher Fauletbcac7862019-07-17 10:46:50 +02003415 (unsigned int)ci_head_ofs(&strm->req), (unsigned int)ci_data(&strm->req),
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003416 (unsigned int)strm->req.buf.size);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003417
Christopher Fauletb9af8812019-01-04 14:30:44 +01003418 if (IS_HTX_STRM(strm)) {
3419 struct htx *htx = htxbuf(&strm->req.buf);
3420
3421 chunk_appendf(&trash,
Willy Tarreaub84e67f2019-01-07 10:01:34 +01003422 " htx=%p flags=0x%x size=%u data=%u used=%u wrap=%s extra=%llu\n",
Christopher Faulet192c6a22019-06-11 16:32:24 +02003423 htx, htx->flags, htx->size, htx->data, htx_nbblks(htx),
Christopher Faulet28f29c72019-04-30 17:55:45 +02003424 (htx->tail >= htx->head) ? "NO" : "YES",
Christopher Fauletb9af8812019-01-04 14:30:44 +01003425 (unsigned long long)htx->extra);
3426 }
Christopher Fauletd4762b82021-10-12 11:02:48 +02003427 if (HAS_FILTERS(strm) && strm_flt(strm)->current[0]) {
3428 struct filter *flt = strm_flt(strm)->current[0];
3429
3430 chunk_appendf(&trash, " current_filter=%p (id=\"%s\" flags=0x%x pre=0x%x post=0x%x) \n",
3431 flt, flt->config->id, flt->flags, flt->pre_analyzers, flt->post_analyzers);
3432 }
Christopher Fauletb9af8812019-01-04 14:30:44 +01003433
William Lallemand4c5b4d52016-11-21 08:51:11 +01003434 chunk_appendf(&trash,
3435 " res=%p (f=0x%06x an=0x%x pipe=%d tofwd=%d total=%lld)\n"
3436 " an_exp=%s",
3437 &strm->res,
3438 strm->res.flags, strm->res.analysers,
3439 strm->res.pipe ? strm->res.pipe->data : 0,
3440 strm->res.to_forward, strm->res.total,
3441 strm->res.analyse_exp ?
3442 human_time(TICKS_TO_MS(strm->res.analyse_exp - now_ms),
3443 TICKS_TO_MS(1000)) : "<NEVER>");
3444
3445 chunk_appendf(&trash,
3446 " rex=%s",
3447 strm->res.rex ?
3448 human_time(TICKS_TO_MS(strm->res.rex - now_ms),
3449 TICKS_TO_MS(1000)) : "<NEVER>");
3450
3451 chunk_appendf(&trash,
3452 " wex=%s\n"
Christopher Fauletbcac7862019-07-17 10:46:50 +02003453 " buf=%p data=%p o=%u p=%u i=%u size=%u\n",
William Lallemand4c5b4d52016-11-21 08:51:11 +01003454 strm->res.wex ?
3455 human_time(TICKS_TO_MS(strm->res.wex - now_ms),
3456 TICKS_TO_MS(1000)) : "<NEVER>",
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003457 &strm->res.buf,
3458 b_orig(&strm->res.buf), (unsigned int)co_data(&strm->res),
Christopher Fauletbcac7862019-07-17 10:46:50 +02003459 (unsigned int)ci_head_ofs(&strm->res), (unsigned int)ci_data(&strm->res),
Willy Tarreauc9fa0482018-07-10 17:43:27 +02003460 (unsigned int)strm->res.buf.size);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003461
Christopher Fauletb9af8812019-01-04 14:30:44 +01003462 if (IS_HTX_STRM(strm)) {
3463 struct htx *htx = htxbuf(&strm->res.buf);
3464
3465 chunk_appendf(&trash,
3466 " htx=%p flags=0x%x size=%u data=%u used=%u wrap=%s extra=%llu\n",
Christopher Faulet192c6a22019-06-11 16:32:24 +02003467 htx, htx->flags, htx->size, htx->data, htx_nbblks(htx),
Christopher Faulet28f29c72019-04-30 17:55:45 +02003468 (htx->tail >= htx->head) ? "NO" : "YES",
Christopher Fauletb9af8812019-01-04 14:30:44 +01003469 (unsigned long long)htx->extra);
3470 }
Christopher Fauletd4762b82021-10-12 11:02:48 +02003471 if (HAS_FILTERS(strm) && strm_flt(strm)->current[1]) {
3472 struct filter *flt = strm_flt(strm)->current[1];
3473
3474 chunk_appendf(&trash, " current_filter=%p (id=\"%s\" flags=0x%x pre=0x%x post=0x%x) \n",
3475 flt, flt->config->id, flt->flags, flt->pre_analyzers, flt->post_analyzers);
3476 }
Christopher Fauletb9af8812019-01-04 14:30:44 +01003477
Willy Tarreau1274e102021-10-11 09:49:03 +02003478 if (strm->current_rule_list && strm->current_rule) {
3479 const struct act_rule *rule = strm->current_rule;
Christopher Faulet8c67ece2021-10-12 11:10:31 +02003480 chunk_appendf(&trash, " current_rule=\"%s\" [%s:%d]\n", rule->kw->kw, rule->conf.file, rule->conf.line);
Willy Tarreau1274e102021-10-11 09:49:03 +02003481 }
3482
Willy Tarreaud0a06d52022-05-18 15:07:19 +02003483 if (applet_putchk(appctx, &trash) == -1)
Willy Tarreaue6e52362019-01-04 17:42:57 +01003484 goto full;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003485
3486 /* use other states to dump the contents */
3487 }
3488 /* end of dump */
Willy Tarreaue6e52362019-01-04 17:42:57 +01003489 done:
Willy Tarreau39f097d2022-05-03 10:49:00 +02003490 ctx->uid = 0;
3491 ctx->section = 0;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003492 return 1;
Willy Tarreaue6e52362019-01-04 17:42:57 +01003493 full:
3494 return 0;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003495}
3496
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003497static int cli_parse_show_sess(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand4c5b4d52016-11-21 08:51:11 +01003498{
Willy Tarreau39f097d2022-05-03 10:49:00 +02003499 struct show_sess_ctx *ctx = applet_reserve_svcctx(appctx, sizeof(*ctx));
3500
William Lallemand4c5b4d52016-11-21 08:51:11 +01003501 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
3502 return 1;
3503
3504 if (*args[2] && strcmp(args[2], "all") == 0)
Willy Tarreau39f097d2022-05-03 10:49:00 +02003505 ctx->target = (void *)-1;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003506 else if (*args[2])
Willy Tarreau39f097d2022-05-03 10:49:00 +02003507 ctx->target = (void *)strtoul(args[2], NULL, 0);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003508 else
Willy Tarreau39f097d2022-05-03 10:49:00 +02003509 ctx->target = NULL;
3510 ctx->section = 0; /* start with stream status */
3511 ctx->pos = 0;
3512 ctx->thr = 0;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003513
Willy Tarreauf3629f82022-05-03 11:05:39 +02003514 /* The back-ref must be reset, it will be detected and set by
3515 * the dump code upon first invocation.
3516 */
3517 LIST_INIT(&ctx->bref.users);
3518
Willy Tarreaub9813182021-02-24 11:29:51 +01003519 /* let's set our own stream's epoch to the current one and increment
3520 * it so that we know which streams were already there before us.
3521 */
Willy Tarreau0698c802022-05-11 14:09:57 +02003522 appctx_strm(appctx)->stream_epoch = _HA_ATOMIC_FETCH_ADD(&stream_epoch, 1);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003523 return 0;
3524}
3525
Willy Tarreau4596fe22022-05-17 19:07:51 +02003526/* This function dumps all streams' states onto the stream connector's
William Lallemand4c5b4d52016-11-21 08:51:11 +01003527 * read buffer. It returns 0 if the output buffer is full and it needs
Willy Tarreaue6e52362019-01-04 17:42:57 +01003528 * to be called again, otherwise non-zero. It proceeds in an isolated
3529 * thread so there is no thread safety issue here.
William Lallemand4c5b4d52016-11-21 08:51:11 +01003530 */
3531static int cli_io_handler_dump_sess(struct appctx *appctx)
3532{
Willy Tarreau39f097d2022-05-03 10:49:00 +02003533 struct show_sess_ctx *ctx = appctx->svcctx;
Willy Tarreauc12b3212022-05-27 11:08:15 +02003534 struct stconn *sc = appctx_sc(appctx);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003535 struct connection *conn;
3536
Willy Tarreaue6e52362019-01-04 17:42:57 +01003537 thread_isolate();
3538
Willy Tarreaubb4e2892022-05-03 11:10:19 +02003539 if (ctx->thr >= global.nbthread) {
3540 /* already terminated */
3541 goto done;
3542 }
3543
Willy Tarreaub49672d2022-05-27 10:13:37 +02003544 if (unlikely(sc_ic(sc)->flags & (CF_WRITE_ERROR|CF_SHUTW))) {
William Lallemand4c5b4d52016-11-21 08:51:11 +01003545 /* If we're forced to shut down, we might have to remove our
3546 * reference to the last stream being dumped.
3547 */
Willy Tarreauf3629f82022-05-03 11:05:39 +02003548 if (!LIST_ISEMPTY(&ctx->bref.users)) {
3549 LIST_DELETE(&ctx->bref.users);
3550 LIST_INIT(&ctx->bref.users);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003551 }
Willy Tarreaue6e52362019-01-04 17:42:57 +01003552 goto done;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003553 }
3554
3555 chunk_reset(&trash);
3556
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003557 /* first, let's detach the back-ref from a possible previous stream */
3558 if (!LIST_ISEMPTY(&ctx->bref.users)) {
3559 LIST_DELETE(&ctx->bref.users);
3560 LIST_INIT(&ctx->bref.users);
3561 } else if (!ctx->bref.ref) {
3562 /* first call, start with first stream */
3563 ctx->bref.ref = ha_thread_ctx[ctx->thr].streams.n;
3564 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003565
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003566 /* and start from where we stopped */
3567 while (1) {
3568 char pn[INET6_ADDRSTRLEN];
3569 struct stream *curr_strm;
3570 int done= 0;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003571
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003572 if (ctx->bref.ref == &ha_thread_ctx[ctx->thr].streams)
3573 done = 1;
3574 else {
3575 /* check if we've found a stream created after issuing the "show sess" */
3576 curr_strm = LIST_ELEM(ctx->bref.ref, struct stream *, list);
Willy Tarreau0698c802022-05-11 14:09:57 +02003577 if ((int)(curr_strm->stream_epoch - appctx_strm(appctx)->stream_epoch) > 0)
Willy Tarreaua698eb62021-02-24 10:37:01 +01003578 done = 1;
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003579 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003580
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003581 if (done) {
3582 ctx->thr++;
3583 if (ctx->thr >= global.nbthread)
3584 break;
3585 ctx->bref.ref = ha_thread_ctx[ctx->thr].streams.n;
3586 continue;
3587 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003588
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003589 if (ctx->target) {
3590 if (ctx->target != (void *)-1 && ctx->target != curr_strm)
3591 goto next_sess;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003592
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003593 LIST_APPEND(&curr_strm->back_refs, &ctx->bref.users);
3594 /* call the proper dump() function and return if we're missing space */
Willy Tarreaub49672d2022-05-27 10:13:37 +02003595 if (!stats_dump_full_strm_to_buffer(sc, curr_strm))
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003596 goto full;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003597
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003598 /* stream dump complete */
3599 LIST_DELETE(&ctx->bref.users);
3600 LIST_INIT(&ctx->bref.users);
3601 if (ctx->target != (void *)-1) {
3602 ctx->target = NULL;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003603 break;
3604 }
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003605 else
3606 goto next_sess;
3607 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003608
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003609 chunk_appendf(&trash,
3610 "%p: proto=%s",
3611 curr_strm,
3612 strm_li(curr_strm) ? strm_li(curr_strm)->rx.proto->name : "?");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003613
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003614 conn = objt_conn(strm_orig(curr_strm));
3615 switch (conn && conn_get_src(conn) ? addr_to_str(conn->src, pn, sizeof(pn)) : AF_UNSPEC) {
3616 case AF_INET:
3617 case AF_INET6:
William Lallemand4c5b4d52016-11-21 08:51:11 +01003618 chunk_appendf(&trash,
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003619 " src=%s:%d fe=%s be=%s srv=%s",
3620 pn,
3621 get_host_port(conn->src),
3622 strm_fe(curr_strm)->id,
3623 (curr_strm->be->cap & PR_CAP_BE) ? curr_strm->be->id : "<NONE>",
3624 objt_server(curr_strm->target) ? __objt_server(curr_strm->target)->id : "<none>"
3625 );
3626 break;
3627 case AF_UNIX:
William Lallemand4c5b4d52016-11-21 08:51:11 +01003628 chunk_appendf(&trash,
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003629 " src=unix:%d fe=%s be=%s srv=%s",
3630 strm_li(curr_strm)->luid,
3631 strm_fe(curr_strm)->id,
3632 (curr_strm->be->cap & PR_CAP_BE) ? curr_strm->be->id : "<NONE>",
3633 objt_server(curr_strm->target) ? __objt_server(curr_strm->target)->id : "<none>"
3634 );
3635 break;
3636 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003637
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003638 chunk_appendf(&trash,
3639 " ts=%02x epoch=%#x age=%s calls=%u rate=%u cpu=%llu lat=%llu",
3640 curr_strm->task->state, curr_strm->stream_epoch,
3641 human_time(now.tv_sec - curr_strm->logs.tv_accept.tv_sec, 1),
3642 curr_strm->task->calls, read_freq_ctr(&curr_strm->call_rate),
3643 (unsigned long long)curr_strm->task->cpu_time, (unsigned long long)curr_strm->task->lat_time);
William Lallemand4c5b4d52016-11-21 08:51:11 +01003644
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003645 chunk_appendf(&trash,
3646 " rq[f=%06xh,i=%u,an=%02xh,rx=%s",
3647 curr_strm->req.flags,
3648 (unsigned int)ci_data(&curr_strm->req),
3649 curr_strm->req.analysers,
3650 curr_strm->req.rex ?
3651 human_time(TICKS_TO_MS(curr_strm->req.rex - now_ms),
3652 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003653
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003654 chunk_appendf(&trash,
3655 ",wx=%s",
3656 curr_strm->req.wex ?
3657 human_time(TICKS_TO_MS(curr_strm->req.wex - now_ms),
3658 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003659
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003660 chunk_appendf(&trash,
3661 ",ax=%s]",
3662 curr_strm->req.analyse_exp ?
3663 human_time(TICKS_TO_MS(curr_strm->req.analyse_exp - now_ms),
3664 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003665
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003666 chunk_appendf(&trash,
3667 " rp[f=%06xh,i=%u,an=%02xh,rx=%s",
3668 curr_strm->res.flags,
3669 (unsigned int)ci_data(&curr_strm->res),
3670 curr_strm->res.analysers,
3671 curr_strm->res.rex ?
3672 human_time(TICKS_TO_MS(curr_strm->res.rex - now_ms),
3673 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003674
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003675 chunk_appendf(&trash,
3676 ",wx=%s",
3677 curr_strm->res.wex ?
3678 human_time(TICKS_TO_MS(curr_strm->res.wex - now_ms),
3679 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003680
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003681 chunk_appendf(&trash,
3682 ",ax=%s]",
3683 curr_strm->res.analyse_exp ?
3684 human_time(TICKS_TO_MS(curr_strm->res.analyse_exp - now_ms),
3685 TICKS_TO_MS(1000)) : "");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003686
Willy Tarreaufd9417b2022-05-18 16:23:22 +02003687 conn = sc_conn(curr_strm->scf);
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003688 chunk_appendf(&trash,
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003689 " scf=[%d,%1xh,fd=%d]",
3690 curr_strm->scf->state,
3691 curr_strm->scf->flags,
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003692 conn_fd(conn));
William Lallemand4c5b4d52016-11-21 08:51:11 +01003693
Willy Tarreaufd9417b2022-05-18 16:23:22 +02003694 conn = sc_conn(curr_strm->scb);
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003695 chunk_appendf(&trash,
Willy Tarreau7cb9e6c2022-05-17 19:40:40 +02003696 " scb=[%d,%1xh,fd=%d]",
3697 curr_strm->scb->state,
3698 curr_strm->scb->flags,
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003699 conn_fd(conn));
3700
3701 chunk_appendf(&trash,
3702 " exp=%s rc=%d c_exp=%s",
3703 curr_strm->task->expire ?
3704 human_time(TICKS_TO_MS(curr_strm->task->expire - now_ms),
3705 TICKS_TO_MS(1000)) : "",
3706 curr_strm->conn_retries,
3707 curr_strm->conn_exp ?
3708 human_time(TICKS_TO_MS(curr_strm->conn_exp - now_ms),
3709 TICKS_TO_MS(1000)) : "");
3710 if (task_in_rq(curr_strm->task))
3711 chunk_appendf(&trash, " run(nice=%d)", curr_strm->task->nice);
3712
3713 chunk_appendf(&trash, "\n");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003714
Willy Tarreaud0a06d52022-05-18 15:07:19 +02003715 if (applet_putchk(appctx, &trash) == -1) {
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003716 /* let's try again later from this stream. We add ourselves into
3717 * this stream's users so that it can remove us upon termination.
3718 */
3719 LIST_APPEND(&curr_strm->back_refs, &ctx->bref.users);
3720 goto full;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003721 }
3722
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003723 next_sess:
3724 ctx->bref.ref = curr_strm->list.n;
3725 }
William Lallemand4c5b4d52016-11-21 08:51:11 +01003726
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003727 if (ctx->target && ctx->target != (void *)-1) {
3728 /* specified stream not found */
3729 if (ctx->section > 0)
3730 chunk_appendf(&trash, " *** session terminated while we were watching it ***\n");
3731 else
3732 chunk_appendf(&trash, "Session not found.\n");
William Lallemand4c5b4d52016-11-21 08:51:11 +01003733
Willy Tarreaud0a06d52022-05-18 15:07:19 +02003734 if (applet_putchk(appctx, &trash) == -1)
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003735 goto full;
3736
3737 ctx->target = NULL;
3738 ctx->uid = 0;
3739 goto done;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003740 }
Willy Tarreau6177cfc2022-05-03 11:17:35 +02003741
Willy Tarreaue6e52362019-01-04 17:42:57 +01003742 done:
3743 thread_release();
3744 return 1;
3745 full:
3746 thread_release();
Willy Tarreaue6e52362019-01-04 17:42:57 +01003747 return 0;
William Lallemand4c5b4d52016-11-21 08:51:11 +01003748}
3749
3750static void cli_release_show_sess(struct appctx *appctx)
3751{
Willy Tarreau39f097d2022-05-03 10:49:00 +02003752 struct show_sess_ctx *ctx = appctx->svcctx;
3753
Willy Tarreaubb4e2892022-05-03 11:10:19 +02003754 if (ctx->thr < global.nbthread) {
Willy Tarreau49de6852021-02-24 13:46:12 +01003755 /* a dump was aborted, either in error or timeout. We need to
3756 * safely detach from the target stream's list. It's mandatory
3757 * to lock because a stream on the target thread could be moving
3758 * our node.
3759 */
3760 thread_isolate();
Willy Tarreau39f097d2022-05-03 10:49:00 +02003761 if (!LIST_ISEMPTY(&ctx->bref.users))
3762 LIST_DELETE(&ctx->bref.users);
Willy Tarreau49de6852021-02-24 13:46:12 +01003763 thread_release();
William Lallemand4c5b4d52016-11-21 08:51:11 +01003764 }
3765}
3766
Willy Tarreau61b65212016-11-24 11:09:25 +01003767/* Parses the "shutdown session" directive, it always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003768static int cli_parse_shutdown_session(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau61b65212016-11-24 11:09:25 +01003769{
3770 struct stream *strm, *ptr;
Willy Tarreaua698eb62021-02-24 10:37:01 +01003771 int thr;
Willy Tarreau61b65212016-11-24 11:09:25 +01003772
3773 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3774 return 1;
3775
Willy Tarreauc40c4072022-03-31 14:49:45 +02003776 ptr = (void *)strtoul(args[2], NULL, 0);
3777 if (!ptr)
Willy Tarreau9d008692019-08-09 11:21:01 +02003778 return cli_err(appctx, "Session pointer expected (use 'show sess').\n");
Willy Tarreau61b65212016-11-24 11:09:25 +01003779
Willy Tarreaua698eb62021-02-24 10:37:01 +01003780 strm = NULL;
Willy Tarreau61b65212016-11-24 11:09:25 +01003781
Willy Tarreau3f5dd292021-02-24 11:11:06 +01003782 thread_isolate();
3783
Willy Tarreau61b65212016-11-24 11:09:25 +01003784 /* first, look for the requested stream in the stream table */
Willy Tarreauc40c4072022-03-31 14:49:45 +02003785 for (thr = 0; strm != ptr && thr < global.nbthread; thr++) {
Willy Tarreaub4e34762021-09-30 19:02:18 +02003786 list_for_each_entry(strm, &ha_thread_ctx[thr].streams, list) {
Willy Tarreaua698eb62021-02-24 10:37:01 +01003787 if (strm == ptr) {
3788 stream_shutdown(strm, SF_ERR_KILLED);
3789 break;
3790 }
Willy Tarreau3f5dd292021-02-24 11:11:06 +01003791 }
Willy Tarreau61b65212016-11-24 11:09:25 +01003792 }
3793
Willy Tarreau3f5dd292021-02-24 11:11:06 +01003794 thread_release();
3795
Willy Tarreau61b65212016-11-24 11:09:25 +01003796 /* do we have the stream ? */
Willy Tarreauc40c4072022-03-31 14:49:45 +02003797 if (strm != ptr)
Willy Tarreau9d008692019-08-09 11:21:01 +02003798 return cli_err(appctx, "No such session (use 'show sess').\n");
Willy Tarreau61b65212016-11-24 11:09:25 +01003799
Willy Tarreau61b65212016-11-24 11:09:25 +01003800 return 1;
3801}
3802
Willy Tarreau4e46b622016-11-23 16:50:48 +01003803/* Parses the "shutdown session server" directive, it always returns 1 */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02003804static int cli_parse_shutdown_sessions_server(char **args, char *payload, struct appctx *appctx, void *private)
Willy Tarreau4e46b622016-11-23 16:50:48 +01003805{
3806 struct server *sv;
Willy Tarreau4e46b622016-11-23 16:50:48 +01003807
3808 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
3809 return 1;
3810
3811 sv = cli_find_server(appctx, args[3]);
3812 if (!sv)
3813 return 1;
3814
3815 /* kill all the stream that are on this server */
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003816 HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
Willy Tarreaud9e26a72019-11-14 16:37:16 +01003817 srv_shutdown_streams(sv, SF_ERR_KILLED);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01003818 HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
Willy Tarreau4e46b622016-11-23 16:50:48 +01003819 return 1;
3820}
3821
William Lallemand4c5b4d52016-11-21 08:51:11 +01003822/* register cli keywords */
3823static struct cli_kw_list cli_kws = {{ },{
Willy Tarreaub205bfd2021-05-07 11:38:37 +02003824 { { "show", "sess", NULL }, "show sess [id] : report the list of current sessions or dump this exact session", cli_parse_show_sess, cli_io_handler_dump_sess, cli_release_show_sess },
3825 { { "shutdown", "session", NULL }, "shutdown session [id] : kill a specific session", cli_parse_shutdown_session, NULL, NULL },
3826 { { "shutdown", "sessions", "server" }, "shutdown sessions server <bk>/<srv> : kill sessions on a server", cli_parse_shutdown_sessions_server, NULL, NULL },
William Lallemand4c5b4d52016-11-21 08:51:11 +01003827 {{},}
3828}};
3829
Willy Tarreau0108d902018-11-25 19:14:37 +01003830INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
3831
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003832/* main configuration keyword registration. */
Christopher Faulet551a6412021-06-25 14:35:29 +02003833static struct action_kw_list stream_tcp_req_keywords = { ILH, {
3834 { "set-log-level", stream_parse_set_log_level },
Christopher Faulet1da374a2021-06-25 14:46:02 +02003835 { "set-nice", stream_parse_set_nice },
Christopher Faulet551a6412021-06-25 14:35:29 +02003836 { "switch-mode", stream_parse_switch_mode },
3837 { "use-service", stream_parse_use_service },
3838 { /* END */ }
3839}};
3840
3841INITCALL1(STG_REGISTER, tcp_req_cont_keywords_register, &stream_tcp_req_keywords);
3842
3843/* main configuration keyword registration. */
3844static struct action_kw_list stream_tcp_res_keywords = { ILH, {
3845 { "set-log-level", stream_parse_set_log_level },
Christopher Faulet1da374a2021-06-25 14:46:02 +02003846 { "set-nice", stream_parse_set_nice },
Christopher Faulet551a6412021-06-25 14:35:29 +02003847 { /* END */ }
3848}};
3849
3850INITCALL1(STG_REGISTER, tcp_res_cont_keywords_register, &stream_tcp_res_keywords);
3851
3852static struct action_kw_list stream_http_req_keywords = { ILH, {
3853 { "set-log-level", stream_parse_set_log_level },
Christopher Faulet1da374a2021-06-25 14:46:02 +02003854 { "set-nice", stream_parse_set_nice },
Christopher Faulet551a6412021-06-25 14:35:29 +02003855 { "use-service", stream_parse_use_service },
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003856 { /* END */ }
3857}};
3858
Christopher Faulet551a6412021-06-25 14:35:29 +02003859INITCALL1(STG_REGISTER, http_req_keywords_register, &stream_http_req_keywords);
Willy Tarreau0108d902018-11-25 19:14:37 +01003860
Christopher Faulet551a6412021-06-25 14:35:29 +02003861static struct action_kw_list stream_http_res_keywords = { ILH, {
3862 { "set-log-level", stream_parse_set_log_level },
Christopher Faulet1da374a2021-06-25 14:46:02 +02003863 { "set-nice", stream_parse_set_nice },
Thierry FOURNIER5a363e72015-09-27 19:29:33 +02003864 { /* END */ }
3865}};
3866
Christopher Faulet551a6412021-06-25 14:35:29 +02003867INITCALL1(STG_REGISTER, http_res_keywords_register, &stream_http_res_keywords);
Willy Tarreau8b22a712010-06-18 17:46:06 +02003868
Amaury Denoyellef7719a22020-12-10 13:43:58 +01003869static int smp_fetch_cur_server_timeout(const struct arg *args, struct sample *smp, const char *km, void *private)
3870{
3871 smp->flags = SMP_F_VOL_TXN;
3872 smp->data.type = SMP_T_SINT;
3873 if (!smp->strm)
3874 return 0;
3875
3876 smp->data.u.sint = TICKS_TO_MS(smp->strm->res.rto);
3877 return 1;
3878}
3879
3880static int smp_fetch_cur_tunnel_timeout(const struct arg *args, struct sample *smp, const char *km, void *private)
3881{
3882 smp->flags = SMP_F_VOL_TXN;
3883 smp->data.type = SMP_T_SINT;
3884 if (!smp->strm)
3885 return 0;
3886
3887 smp->data.u.sint = TICKS_TO_MS(smp->strm->tunnel_timeout);
3888 return 1;
3889}
3890
Willy Tarreau0657b932022-03-09 17:33:05 +01003891static int smp_fetch_last_rule_file(const struct arg *args, struct sample *smp, const char *km, void *private)
3892{
3893 smp->flags = SMP_F_VOL_TXN;
3894 smp->data.type = SMP_T_STR;
3895 if (!smp->strm || !smp->strm->last_rule_file)
3896 return 0;
3897
3898 smp->flags |= SMP_F_CONST;
3899 smp->data.u.str.area = (char *)smp->strm->last_rule_file;
3900 smp->data.u.str.data = strlen(smp->strm->last_rule_file);
3901 return 1;
3902}
3903
3904static int smp_fetch_last_rule_line(const struct arg *args, struct sample *smp, const char *km, void *private)
3905{
3906 smp->flags = SMP_F_VOL_TXN;
3907 smp->data.type = SMP_T_SINT;
3908 if (!smp->strm || !smp->strm->last_rule_line)
3909 return 0;
3910
3911 smp->data.u.sint = smp->strm->last_rule_line;
3912 return 1;
3913}
3914
Amaury Denoyelle12bada52020-12-10 13:43:57 +01003915/* Note: must not be declared <const> as its list will be overwritten.
3916 * Please take care of keeping this list alphabetically sorted.
3917 */
3918static struct sample_fetch_kw_list smp_kws = {ILH, {
Amaury Denoyellef7719a22020-12-10 13:43:58 +01003919 { "cur_server_timeout", smp_fetch_cur_server_timeout, 0, NULL, SMP_T_SINT, SMP_USE_BKEND, },
3920 { "cur_tunnel_timeout", smp_fetch_cur_tunnel_timeout, 0, NULL, SMP_T_SINT, SMP_USE_BKEND, },
Willy Tarreau0657b932022-03-09 17:33:05 +01003921 { "last_rule_file", smp_fetch_last_rule_file, 0, NULL, SMP_T_STR, SMP_USE_INTRN, },
3922 { "last_rule_line", smp_fetch_last_rule_line, 0, NULL, SMP_T_SINT, SMP_USE_INTRN, },
Amaury Denoyelle12bada52020-12-10 13:43:57 +01003923 { NULL, NULL, 0, 0, 0 },
3924}};
3925
3926INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3927
Willy Tarreaubaaee002006-06-26 02:48:02 +02003928/*
3929 * Local variables:
3930 * c-indent-level: 8
3931 * c-basic-offset: 8
3932 * End:
3933 */