blob: 00f452c163f10571bb1b7df22e3efc58f8d00e63 [file] [log] [blame]
Willy TARREAU3dc06442006-06-15 21:48:13 +02001/*
Willy Tarreau87b09662015-04-03 00:22:06 +02002 * include/proto/stream.h
3 * This file defines everything related to streams.
Willy Tarreau81f9aa32010-06-01 17:45:26 +02004 *
5 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation, version 2.1
10 * exclusively.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
Willy TARREAU3dc06442006-06-15 21:48:13 +020021
Willy Tarreau87b09662015-04-03 00:22:06 +020022#ifndef _PROTO_STREAM_H
23#define _PROTO_STREAM_H
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020025#include <common/config.h>
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020026#include <common/memory.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020027#include <types/stream.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010028#include <proto/fd.h>
Willy Tarreau91c43d72010-06-20 11:19:22 +020029#include <proto/freq_ctr.h>
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020030#include <proto/stick_table.h>
Willy Tarreaua24adf02014-11-27 01:11:56 +010031#include <proto/task.h>
Willy TARREAU3dc06442006-06-15 21:48:13 +020032
Willy Tarreau87b09662015-04-03 00:22:06 +020033extern struct pool_head *pool2_stream;
34extern struct list streams;
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020035
Willy Tarreaubc174aa2012-11-19 16:10:32 +010036extern struct data_cb sess_conn_cb;
37
Willy Tarreau87787ac2017-08-28 16:22:54 +020038struct stream *stream_new(struct session *sess, enum obj_type *origin);
Willy Tarreau5790eb02017-08-28 17:18:36 +020039int stream_create_from_conn(struct connection *conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +020040
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020041/* perform minimal intializations, report 0 in case of error, 1 if OK. */
Willy Tarreau87b09662015-04-03 00:22:06 +020042int init_stream();
Willy Tarreaubaaee002006-06-26 02:48:02 +020043
Willy Tarreaue7dff022015-04-03 01:14:29 +020044/* kill a stream and set the termination flags to <why> (one of SF_ERR_*) */
Willy Tarreau87b09662015-04-03 00:22:06 +020045void stream_shutdown(struct stream *stream, int why);
Simon Hormandec5be42011-06-08 09:19:07 +090046
Willy Tarreau87b09662015-04-03 00:22:06 +020047void stream_process_counters(struct stream *s);
48void sess_change_server(struct stream *sess, struct server *newsrv);
49struct task *process_stream(struct task *t);
50void default_srv_error(struct stream *s, struct stream_interface *si);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020051int parse_track_counters(char **args, int *arg,
52 int section_type, struct proxy *curpx,
53 struct track_ctr_prm *prm,
Willy Tarreau0a3dd742012-05-08 19:47:01 +020054 struct proxy *defpx, char **err);
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020055
Willy Tarreau87b09662015-04-03 00:22:06 +020056/* Update the stream's backend and server time stats */
57void stream_update_time_stats(struct stream *s);
Willy Tarreau87b09662015-04-03 00:22:06 +020058void stream_release_buffers(struct stream *s);
Willy Tarreau4bfc5802014-06-17 12:19:18 +020059
Willy Tarreaub1ec8c42015-04-03 13:53:24 +020060/* returns the session this stream belongs to */
61static inline struct session *strm_sess(const struct stream *strm)
62{
63 return strm->sess;
64}
65
Willy Tarreaud0d8da92015-04-04 02:10:38 +020066/* returns the frontend this stream was initiated from */
67static inline struct proxy *strm_fe(const struct stream *strm)
68{
69 return strm->sess->fe;
70}
71
72/* returns the listener this stream was initiated from */
73static inline struct listener *strm_li(const struct stream *strm)
74{
75 return strm->sess->listener;
76}
77
78/* returns a pointer to the origin of the session which created this stream */
79static inline enum obj_type *strm_orig(const struct stream *strm)
80{
81 return strm->sess->origin;
82}
83
Willy Tarreau87b09662015-04-03 00:22:06 +020084/* Remove the refcount from the stream to the tracked counters, and clear the
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020085 * pointer to ensure this is only performed once. The caller is responsible for
Willy Tarreaua68f7622015-09-21 17:48:24 +020086 * ensuring that the pointer is valid first. We must be extremely careful not
87 * to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020088 */
Willy Tarreau87b09662015-04-03 00:22:06 +020089static inline void stream_store_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +020090{
Willy Tarreauf059a0f2010-08-03 16:29:52 +020091 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +010092 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +020093
Willy Tarreaub4c84932013-07-23 19:15:30 +020094 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +010095 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +010096 continue;
Willy Tarreaua68f7622015-09-21 17:48:24 +020097
98 if (stkctr_entry(&s->sess->stkctr[i]))
99 continue;
100
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100101 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200102 if (ptr)
103 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100104 stkctr_entry(&s->stkctr[i])->ref_cnt--;
105 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
106 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau38285c12010-06-18 16:35:43 +0200107 }
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200108}
109
Willy Tarreau87b09662015-04-03 00:22:06 +0200110/* Remove the refcount from the stream counters tracked at the content level if
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200111 * any, and clear the pointer to ensure this is only performed once. The caller
Willy Tarreaua68f7622015-09-21 17:48:24 +0200112 * is responsible for ensuring that the pointer is valid first. We must be
113 * extremely careful not to touch the entries we inherited from the session.
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200114 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200115static inline void stream_stop_content_counters(struct stream *s)
Willy Tarreau9ba2dcc2010-06-14 21:04:55 +0200116{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200117 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100118 int i;
Willy Tarreaue3487932010-06-18 21:03:20 +0200119
Willy Tarreaub4c84932013-07-23 19:15:30 +0200120 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100121 if (!stkctr_entry(&s->stkctr[i]))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100122 continue;
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200123
Willy Tarreaua68f7622015-09-21 17:48:24 +0200124 if (stkctr_entry(&s->sess->stkctr[i]))
125 continue;
126
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100127 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_CONTENT))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100128 continue;
129
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100130 ptr = stktable_data_ptr(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]), STKTABLE_DT_CONN_CUR);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200131 if (ptr)
132 stktable_data_cast(ptr, conn_cur)--;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100133 stkctr_entry(&s->stkctr[i])->ref_cnt--;
134 stksess_kill_if_expired(s->stkctr[i].table, stkctr_entry(&s->stkctr[i]));
135 stkctr_set_entry(&s->stkctr[i], NULL);
Willy Tarreau0a4838c2010-08-06 20:11:05 +0200136 }
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200137}
Willy Tarreaue3487932010-06-18 21:03:20 +0200138
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200139/* Increase total and concurrent connection count for stick entry <ts> of table
140 * <t>. The caller is responsible for ensuring that <t> and <ts> are valid
141 * pointers, and for calling this only once per connection.
142 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200143static inline void stream_start_counters(struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200144{
145 void *ptr;
Willy Tarreau91c43d72010-06-20 11:19:22 +0200146
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200147 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CUR);
148 if (ptr)
149 stktable_data_cast(ptr, conn_cur)++;
150
151 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_CNT);
152 if (ptr)
153 stktable_data_cast(ptr, conn_cnt)++;
154
155 ptr = stktable_data_ptr(t, ts, STKTABLE_DT_CONN_RATE);
156 if (ptr)
157 update_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
158 t->data_arg[STKTABLE_DT_CONN_RATE].u, 1);
159 if (tick_isset(t->expire))
160 ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
161}
162
Willy Tarreau87b09662015-04-03 00:22:06 +0200163/* Enable tracking of stream counters as <stkctr> on stksess <ts>. The caller is
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200164 * responsible for ensuring that <t> and <ts> are valid pointers. Some controls
165 * are performed to ensure the state can still change.
166 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200167static inline void stream_track_stkctr(struct stkctr *ctr, struct stktable *t, struct stksess *ts)
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200168{
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100169 if (stkctr_entry(ctr))
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200170 return;
171
172 ts->ref_cnt++;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100173 ctr->table = t;
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100174 stkctr_set_entry(ctr, ts);
Willy Tarreau87b09662015-04-03 00:22:06 +0200175 stream_start_counters(t, ts);
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200176}
177
Willy Tarreauda7ff642010-06-23 11:44:09 +0200178/* Increase the number of cumulated HTTP requests in the tracked counters */
Willy Tarreau87b09662015-04-03 00:22:06 +0200179static void inline stream_inc_http_req_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200180{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200181 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100182 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200183
Willy Tarreaub4c84932013-07-23 19:15:30 +0200184 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200185 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200186
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200187 if (!stkctr_entry(stkctr)) {
188 stkctr = &s->sess->stkctr[i];
189 if (!stkctr_entry(stkctr))
190 continue;
191 }
192
193 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200194 if (ptr)
195 stktable_data_cast(ptr, http_req_cnt)++;
196
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200197 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200198 if (ptr)
199 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200200 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200201 }
202}
203
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200204/* Increase the number of cumulated HTTP requests in the backend's tracked
205 * counters. We don't look up the session since it cannot happen in the bakcend.
206 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200207static void inline stream_inc_be_http_req_ctr(struct stream *s)
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100208{
209 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100210 int i;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100211
Willy Tarreaub4c84932013-07-23 19:15:30 +0200212 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200213 struct stkctr *stkctr = &s->stkctr[i];
214
215 if (!stkctr_entry(stkctr))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100216 continue;
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100217
Willy Tarreaucc08d2c2014-01-28 23:18:23 +0100218 if (!(stkctr_flags(&s->stkctr[i]) & STKCTR_TRACK_BACKEND))
Willy Tarreau20d46a52012-12-09 15:55:40 +0100219 continue;
220
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200221 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_CNT);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100222 if (ptr)
223 stktable_data_cast(ptr, http_req_cnt)++;
224
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200225 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_REQ_RATE);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100226 if (ptr)
227 update_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200228 stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
Willy Tarreau5d5b5d82012-12-09 12:00:04 +0100229 }
230}
231
Willy Tarreauda7ff642010-06-23 11:44:09 +0200232/* Increase the number of cumulated failed HTTP requests in the tracked
233 * counters. Only 4xx requests should be counted here so that we can
234 * distinguish between errors caused by client behaviour and other ones.
235 * Note that even 404 are interesting because they're generally caused by
236 * vulnerability scans.
237 */
Willy Tarreau87b09662015-04-03 00:22:06 +0200238static void inline stream_inc_http_err_ctr(struct stream *s)
Willy Tarreauda7ff642010-06-23 11:44:09 +0200239{
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200240 void *ptr;
Willy Tarreau20d46a52012-12-09 15:55:40 +0100241 int i;
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200242
Willy Tarreaub4c84932013-07-23 19:15:30 +0200243 for (i = 0; i < MAX_SESS_STKCTR; i++) {
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200244 struct stkctr *stkctr = &s->stkctr[i];
Willy Tarreauf059a0f2010-08-03 16:29:52 +0200245
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200246 if (!stkctr_entry(stkctr)) {
247 stkctr = &s->sess->stkctr[i];
248 if (!stkctr_entry(stkctr))
249 continue;
250 }
251
252 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_CNT);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200253 if (ptr)
254 stktable_data_cast(ptr, http_err_cnt)++;
255
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200256 ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_HTTP_ERR_RATE);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200257 if (ptr)
258 update_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
Willy Tarreau8b7f8682015-04-04 16:29:12 +0200259 stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1);
Willy Tarreauda7ff642010-06-23 11:44:09 +0200260 }
261}
262
Willy Tarreau87b09662015-04-03 00:22:06 +0200263static void inline stream_add_srv_conn(struct stream *sess, struct server *srv)
Simon Hormanaf514952011-06-21 14:34:57 +0900264{
265 sess->srv_conn = srv;
266 LIST_ADD(&srv->actconns, &sess->by_srv);
267}
268
Willy Tarreau87b09662015-04-03 00:22:06 +0200269static void inline stream_del_srv_conn(struct stream *sess)
Simon Hormanaf514952011-06-21 14:34:57 +0900270{
271 if (!sess->srv_conn)
272 return;
273
274 sess->srv_conn = NULL;
275 LIST_DEL(&sess->by_srv);
276}
277
Willy Tarreau87b09662015-04-03 00:22:06 +0200278static void inline stream_init_srv_conn(struct stream *sess)
Willy Tarreau9bd0d742011-07-20 00:17:39 +0200279{
280 sess->srv_conn = NULL;
281 LIST_INIT(&sess->by_srv);
282}
283
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100284/* Callback used to wake up a stream when a buffer is available. The stream <s>
285 * is woken up is if it is not already running and if it is not already in the
286 * task run queue. This functions returns 1 is the stream is woken up, otherwise
287 * it returns 0. */
288static int inline stream_res_wakeup(struct stream *s)
Willy Tarreaua24adf02014-11-27 01:11:56 +0100289{
Emeric Brunff449172017-03-31 12:04:09 +0200290 if (s->task->state & TASK_RUNNING)
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100291 return 0;
292 task_wakeup(s->task, TASK_WOKEN_RES);
293 return 1;
Willy Tarreaua24adf02014-11-27 01:11:56 +0100294}
295
Thierry FOURNIER5a363e72015-09-27 19:29:33 +0200296void service_keywords_register(struct action_kw_list *kw_list);
297
Willy Tarreau87b09662015-04-03 00:22:06 +0200298#endif /* _PROTO_STREAM_H */
Willy TARREAU3dc06442006-06-15 21:48:13 +0200299
Willy Tarreaubaaee002006-06-26 02:48:02 +0200300/*
301 * Local variables:
302 * c-indent-level: 8
303 * c-basic-offset: 8
304 * End:
305 */