blob: c0f88b265c59b74fe651549d80c72946f9ab84c3 [file] [log] [blame]
Willy Tarreaucff64112008-11-03 06:26:53 +01001/*
Willy Tarreau8e89b842009-10-18 23:56:35 +02002 * include/proto/stream_interface.h
3 * This file contains stream_interface function prototypes
4 *
Willy Tarreau2bb4a962014-11-28 11:11:05 +01005 * Copyright (C) 2000-2014 Willy Tarreau - w@1wt.eu
Willy Tarreau8e89b842009-10-18 23:56:35 +02006 *
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 Tarreaucff64112008-11-03 06:26:53 +010021
22#ifndef _PROTO_STREAM_INTERFACE_H
23#define _PROTO_STREAM_INTERFACE_H
24
25#include <stdlib.h>
26
27#include <common/config.h>
Willy Tarreau323a2d92015-08-04 19:00:17 +020028#include <types/server.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020029#include <types/stream.h>
Willy Tarreaucff64112008-11-03 06:26:53 +010030#include <types/stream_interface.h>
Willy Tarreau8a8d83b2015-04-13 13:24:54 +020031#include <proto/applet.h>
Willy Tarreau14f8e862012-08-30 22:23:13 +020032#include <proto/channel.h>
Willy Tarreauf9dabec2012-08-17 17:33:53 +020033#include <proto/connection.h>
Willy Tarreaucff64112008-11-03 06:26:53 +010034
35
Willy Tarreauc5788912012-08-24 18:12:41 +020036extern struct si_ops si_embedded_ops;
Willy Tarreauc5788912012-08-24 18:12:41 +020037extern struct si_ops si_conn_ops;
Willy Tarreaud45b9f82015-04-13 16:30:14 +020038extern struct si_ops si_applet_ops;
Willy Tarreau74beec32012-10-03 00:41:04 +020039extern struct data_cb si_conn_cb;
Willy Tarreau5c979a92012-05-07 17:15:39 +020040
Willy Tarreau14bfe9a2018-12-19 15:19:27 +010041/* main event functions used to move data between sockets and buffers */
42int si_check_timeouts(struct stream_interface *si);
43void si_report_error(struct stream_interface *si);
44void si_retnclose(struct stream_interface *si, const struct buffer *msg);
45int conn_si_send_proxy(struct connection *conn, unsigned int flag);
46struct appctx *si_register_handler(struct stream_interface *si, struct applet *app);
Willy Tarreauaa977ba2015-09-25 11:45:06 +020047void si_applet_wake_cb(struct stream_interface *si);
Willy Tarreau236c4292019-06-06 08:19:20 +020048void si_update_rx(struct stream_interface *si);
49void si_update_tx(struct stream_interface *si);
Olivier Houchard0e367bb2018-09-14 19:41:13 +020050int si_cs_recv(struct conn_stream *cs);
Olivier Houchard91894cb2018-08-02 18:06:28 +020051struct task *si_cs_io_cb(struct task *t, void *ctx, unsigned short state);
Willy Tarreaud14844a2018-11-08 18:15:29 +010052void si_update_both(struct stream_interface *si_f, struct stream_interface *si_b);
Willy Tarreau3b285d72019-06-06 08:20:17 +020053void si_sync_send(struct stream_interface *si);
Willy Tarreaufb90d942009-09-05 20:57:35 +020054
Willy Tarreau2bb4a962014-11-28 11:11:05 +010055/* returns the channel which receives data from this stream interface (input channel) */
56static inline struct channel *si_ic(struct stream_interface *si)
57{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010058 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020059 return &LIST_ELEM(si, struct stream *, si[1])->res;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010060 else
Willy Tarreau87b09662015-04-03 00:22:06 +020061 return &LIST_ELEM(si, struct stream *, si[0])->req;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010062}
63
64/* returns the channel which feeds data to this stream interface (output channel) */
65static inline struct channel *si_oc(struct stream_interface *si)
66{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010067 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020068 return &LIST_ELEM(si, struct stream *, si[1])->req;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010069 else
Willy Tarreau87b09662015-04-03 00:22:06 +020070 return &LIST_ELEM(si, struct stream *, si[0])->res;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010071}
72
Willy Tarreau4e4292b2014-11-28 12:18:45 +010073/* returns the buffer which receives data from this stream interface (input channel's buffer) */
74static inline struct buffer *si_ib(struct stream_interface *si)
75{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020076 return &si_ic(si)->buf;
Willy Tarreau4e4292b2014-11-28 12:18:45 +010077}
78
79/* returns the buffer which feeds data to this stream interface (output channel's buffer) */
80static inline struct buffer *si_ob(struct stream_interface *si)
81{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020082 return &si_oc(si)->buf;
Willy Tarreau4e4292b2014-11-28 12:18:45 +010083}
84
Willy Tarreau87b09662015-04-03 00:22:06 +020085/* returns the stream associated to a stream interface */
86static inline struct stream *si_strm(struct stream_interface *si)
Willy Tarreauaefd7902014-11-28 12:03:32 +010087{
88 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020089 return LIST_ELEM(si, struct stream *, si[1]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010090 else
Willy Tarreau87b09662015-04-03 00:22:06 +020091 return LIST_ELEM(si, struct stream *, si[0]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010092}
93
Willy Tarreau07373b82014-11-28 12:08:47 +010094/* returns the task associated to this stream interface */
95static inline struct task *si_task(struct stream_interface *si)
96{
97 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020098 return LIST_ELEM(si, struct stream *, si[1])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +010099 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200100 return LIST_ELEM(si, struct stream *, si[0])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +0100101}
102
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100103/* returns the stream interface on the other side. Used during forwarding. */
104static inline struct stream_interface *si_opposite(struct stream_interface *si)
105{
106 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +0200107 return &LIST_ELEM(si, struct stream *, si[1])->si[0];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100108 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200109 return &LIST_ELEM(si, struct stream *, si[0])->si[1];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100110}
111
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200112/* initializes a stream interface in the SI_ST_INI state. It's detached from
Willy Tarreau819d3322014-11-28 12:12:34 +0100113 * any endpoint and only keeps its side which is expected to have already been
114 * set.
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200115 */
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200116static inline int si_reset(struct stream_interface *si)
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200117{
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200118 si->err_type = SI_ET_NONE;
119 si->conn_retries = 0; /* used for logging too */
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200120 si->exp = TICK_ETERNITY;
Willy Tarreaua5f5d8d2014-11-28 11:26:07 +0100121 si->flags &= SI_FL_ISBACK;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200122 si->end = NULL;
123 si->state = si->prev_state = SI_ST_INI;
Willy Tarreau7365dad2015-04-20 01:03:17 +0200124 si->ops = &si_embedded_ops;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200125 si->wait_event.tasklet = tasklet_new();
126 if (!si->wait_event.tasklet)
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200127 return -1;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +0200128 si->wait_event.tasklet->process = si_cs_io_cb;
129 si->wait_event.tasklet->context = si;
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100130 si->wait_event.events = 0;
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200131 return 0;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200132}
133
134/* sets the current and previous state of a stream interface to <state>. This
135 * is mainly used to create one in the established state on incoming
136 * conncetions.
137 */
138static inline void si_set_state(struct stream_interface *si, int state)
139{
140 si->state = si->prev_state = state;
141}
142
Willy Tarreaubedcd692019-06-05 14:45:06 +0200143/* returns a bit for a stream-int state, to match against SI_SB_* */
144static inline enum si_state_bit si_state_bit(enum si_state state)
145{
Willy Tarreauad660e32019-06-06 16:38:40 +0200146 BUG_ON(state > SI_ST_CLO);
Willy Tarreaubedcd692019-06-05 14:45:06 +0200147 return 1U << state;
148}
149
150/* returns true if <state> matches one of the SI_SB_* bits in <mask> */
151static inline int si_state_in(enum si_state state, enum si_state_bit mask)
152{
153 BUG_ON(mask & ~SI_SB_ALL);
154 return !!(si_state_bit(state) & mask);
155}
156
Willy Tarreau41b09f42015-08-04 20:44:05 +0200157/* only detaches the endpoint from the SI, which means that it's set to
158 * NULL and that ->ops is mapped to si_embedded_ops. The previous endpoint
159 * is returned.
160 */
161static inline enum obj_type *si_detach_endpoint(struct stream_interface *si)
162{
163 enum obj_type *prev = si->end;
164
165 si->end = NULL;
166 si->ops = &si_embedded_ops;
167 return prev;
168}
169
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100170/* Release the endpoint if it's a connection or an applet, then nullify it.
171 * Note: released connections are closed then freed.
172 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200173static inline void si_release_endpoint(struct stream_interface *si)
Willy Tarreau372d6702013-09-29 17:19:56 +0200174{
Olivier Houchardee23b2a2018-11-23 17:07:04 +0100175 struct connection *conn;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200176 struct conn_stream *cs;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100177 struct appctx *appctx;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200178
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100179 if (!si->end)
180 return;
181
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200182 if ((cs = objt_cs(si->end))) {
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100183 if (si->wait_event.events != 0)
184 cs->conn->mux->unsubscribe(cs, si->wait_event.events,
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200185 &si->wait_event);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200186 cs_destroy(cs);
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200187 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100188 else if ((appctx = objt_appctx(si->end))) {
Willy Tarreau7ab22adb2019-06-05 14:53:22 +0200189 if (appctx->applet->release && !si_state_in(si->state, SI_SB_DIS|SI_SB_CLO))
Willy Tarreau00a37f02015-04-13 12:05:19 +0200190 appctx->applet->release(appctx);
Willy Tarreau8280ea92019-07-18 10:41:36 +0200191 appctx_free(appctx);
Olivier Houchard8ab8a6e2018-12-19 23:21:46 +0100192 } else if ((conn = objt_conn(si->end))) {
193 conn_stop_tracking(conn);
194 conn_full_close(conn);
Olivier Houchardee23b2a2018-11-23 17:07:04 +0100195 conn_free(conn);
Olivier Houchard8ab8a6e2018-12-19 23:21:46 +0100196 }
Willy Tarreau41b09f42015-08-04 20:44:05 +0200197 si_detach_endpoint(si);
Willy Tarreau372d6702013-09-29 17:19:56 +0200198}
199
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200200/* Attach conn_stream <cs> to the stream interface <si>. The stream interface
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200201 * is configured to work with a connection and the connection it configured
202 * with a stream interface data layer.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200203 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200204static inline void si_attach_cs(struct stream_interface *si, struct conn_stream *cs)
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200205{
206 si->ops = &si_conn_ops;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200207 si->end = &cs->obj_type;
208 cs_attach(cs, si, &si_conn_cb);
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200209}
210
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100211/* Returns true if a connection is attached to the stream interface <si> and
212 * if this connection is ready.
213 */
214static inline int si_conn_ready(struct stream_interface *si)
215{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200216 struct connection *conn = cs_conn(objt_cs(si->end));
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100217
218 return conn && conn_ctrl_ready(conn) && conn_xprt_ready(conn);
219}
220
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100221/* Attach appctx <appctx> to the stream interface <si>. The stream interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200222 * is configured to work with an applet context.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100223 */
224static inline void si_attach_appctx(struct stream_interface *si, struct appctx *appctx)
Willy Tarreauc5788912012-08-24 18:12:41 +0200225{
Willy Tarreaud45b9f82015-04-13 16:30:14 +0200226 si->ops = &si_applet_ops;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100227 si->end = &appctx->obj_type;
Willy Tarreau19c81612015-04-13 11:48:16 +0200228 appctx->owner = si;
Willy Tarreauc5788912012-08-24 18:12:41 +0200229}
230
Willy Tarreau4ae49232018-09-20 11:08:47 +0200231/* returns a pointer to the appctx being run in the SI, which must be valid */
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100232static inline struct appctx *si_appctx(struct stream_interface *si)
233{
Willy Tarreau4ae49232018-09-20 11:08:47 +0200234 return __objt_appctx(si->end);
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100235}
236
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200237/* call the applet's release function if any. Needs to be called upon close() */
238static inline void si_applet_release(struct stream_interface *si)
239{
Willy Tarreau00a37f02015-04-13 12:05:19 +0200240 struct appctx *appctx;
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200241
Willy Tarreau4ae49232018-09-20 11:08:47 +0200242 appctx = objt_appctx(si->end);
Willy Tarreau7ab22adb2019-06-05 14:53:22 +0200243 if (appctx && appctx->applet->release && !si_state_in(si->state, SI_SB_DIS|SI_SB_CLO))
Willy Tarreau00a37f02015-04-13 12:05:19 +0200244 appctx->applet->release(appctx);
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200245}
246
Willy Tarreau78dcace2018-11-14 14:01:40 +0100247/* Returns non-zero if the stream interface's Rx path is blocked */
248static inline int si_rx_blocked(const struct stream_interface *si)
249{
250 return !!(si->flags & SI_FL_RXBLK_ANY);
251}
252
253/* Returns non-zero if the stream interface's endpoint is ready to receive */
254static inline int si_rx_endp_ready(const struct stream_interface *si)
255{
256 return !(si->flags & SI_FL_RX_WAIT_EP);
257}
258
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +0100259/* The stream interface announces it is ready to try to deliver more data to the input buffer */
260static inline void si_rx_endp_more(struct stream_interface *si)
Willy Tarreau394970c2018-11-06 19:17:31 +0100261{
Willy Tarreau8bb2ffb2018-11-14 17:54:13 +0100262 si->flags &= ~SI_FL_RX_WAIT_EP;
263}
264
265/* The stream interface announces it doesn't have more data for the input buffer */
266static inline void si_rx_endp_done(struct stream_interface *si)
267{
Willy Tarreau05b9b642018-11-14 13:43:35 +0100268 si->flags |= SI_FL_RX_WAIT_EP;
Willy Tarreau394970c2018-11-06 19:17:31 +0100269}
270
Willy Tarreaub26a6f92018-11-14 17:10:36 +0100271/* Tell a stream interface the input channel is OK with it sending it some data */
272static inline void si_rx_chan_rdy(struct stream_interface *si)
273{
274 si->flags &= ~SI_FL_RXBLK_CHAN;
275}
276
277/* Tell a stream interface the input channel is not OK with it sending it some data */
278static inline void si_rx_chan_blk(struct stream_interface *si)
279{
280 si->flags |= SI_FL_RXBLK_CHAN;
281}
282
Willy Tarreaua3b62d32018-12-06 15:24:01 +0100283/* Tell a stream interface the other side is connected */
284static inline void si_rx_conn_rdy(struct stream_interface *si)
285{
286 si->flags &= ~SI_FL_RXBLK_CONN;
287}
288
289/* Tell a stream interface it must wait for the other side to connect */
290static inline void si_rx_conn_blk(struct stream_interface *si)
291{
292 si->flags |= SI_FL_RXBLK_CONN;
293}
294
Willy Tarreau8be7cd72018-11-14 15:12:08 +0100295/* The stream interface just got the input buffer it was waiting for */
296static inline void si_rx_buff_rdy(struct stream_interface *si)
297{
298 si->flags &= ~SI_FL_RXBLK_BUFF;
299}
300
301/* The stream interface failed to get an input buffer and is waiting for it.
302 * Since it indicates a willingness to deliver data to the buffer that will
303 * have to be retried, we automatically clear RXBLK_ENDP to be called again
304 * as soon as RXBLK_BUFF is cleared.
305 */
306static inline void si_rx_buff_blk(struct stream_interface *si)
307{
308 si->flags |= SI_FL_RXBLK_BUFF;
309}
310
Willy Tarreaudb398432018-11-15 11:08:52 +0100311/* Tell a stream interface some room was made in the input buffer */
312static inline void si_rx_room_rdy(struct stream_interface *si)
313{
314 si->flags &= ~SI_FL_RXBLK_ROOM;
315}
316
317/* The stream interface announces it failed to put data into the input buffer
318 * by lack of room. Since it indicates a willingness to deliver data to the
319 * buffer that will have to be retried, we automatically clear RXBLK_ENDP to
320 * be called again as soon as RXBLK_ROOM is cleared.
321 */
322static inline void si_rx_room_blk(struct stream_interface *si)
323{
324 si->flags |= SI_FL_RXBLK_ROOM;
325}
326
Willy Tarreauabb5d422018-11-14 16:58:52 +0100327/* The stream interface announces it will never put new data into the input
328 * buffer and that it's not waiting for its endpoint to deliver anything else.
329 * This function obviously doesn't have a _rdy equivalent.
330 */
331static inline void si_rx_shut_blk(struct stream_interface *si)
332{
333 si->flags |= SI_FL_RXBLK_SHUT;
334}
335
Willy Tarreau78dcace2018-11-14 14:01:40 +0100336/* Returns non-zero if the stream interface's Rx path is blocked */
337static inline int si_tx_blocked(const struct stream_interface *si)
338{
339 return !!(si->flags & SI_FL_WAIT_DATA);
340}
341
342/* Returns non-zero if the stream interface's endpoint is ready to transmit */
343static inline int si_tx_endp_ready(const struct stream_interface *si)
344{
345 return (si->flags & SI_FL_WANT_GET);
346}
347
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100348/* Report that a stream interface wants to get some data from the output buffer */
349static inline void si_want_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200350{
351 si->flags |= SI_FL_WANT_GET;
352}
353
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100354/* Report that a stream interface failed to get some data from the output buffer */
355static inline void si_cant_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200356{
357 si->flags |= SI_FL_WANT_GET | SI_FL_WAIT_DATA;
358}
359
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100360/* Report that a stream interface doesn't want to get data from the output buffer */
361static inline void si_stop_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200362{
363 si->flags &= ~SI_FL_WANT_GET;
364}
365
Willy Tarreau394970c2018-11-06 19:17:31 +0100366/* Report that a stream interface won't get any more data from the output buffer */
367static inline void si_done_get(struct stream_interface *si)
368{
369 si->flags &= ~(SI_FL_WANT_GET | SI_FL_WAIT_DATA);
370}
371
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200372/* Try to allocate a new conn_stream and assign it to the interface. If
Willy Tarreau973a5422015-08-05 21:47:23 +0200373 * an endpoint was previously allocated, it is released first. The newly
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200374 * allocated conn_stream is initialized, assigned to the stream interface,
Willy Tarreau973a5422015-08-05 21:47:23 +0200375 * and returned.
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100376 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200377static inline struct conn_stream *si_alloc_cs(struct stream_interface *si, struct connection *conn)
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200378{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200379 struct conn_stream *cs;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200380
Willy Tarreau973a5422015-08-05 21:47:23 +0200381 si_release_endpoint(si);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200382
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200383 cs = cs_new(conn);
384 if (cs)
385 si_attach_cs(si, cs);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200386
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200387 return cs;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200388}
389
Willy Tarreau09799162018-10-25 10:16:07 +0200390/* Try to allocate a buffer for the stream-int's input channel. It relies on
Willy Tarreauabf531c2018-11-07 18:53:29 +0100391 * channel_alloc_buffer() for this so it abides by its rules. It returns 0 on
392 * failure, non-zero otherwise. If no buffer is available, the requester,
Willy Tarreau8be7cd72018-11-14 15:12:08 +0100393 * represented by the <wait> pointer, will be added in the list of objects
394 * waiting for an available buffer, and SI_FL_RXBLK_BUFF will be set on the
395 * stream-int and SI_FL_RX_WAIT_EP cleared. The requester will be responsible
396 * for calling this function to try again once woken up.
Willy Tarreau09799162018-10-25 10:16:07 +0200397 */
398static inline int si_alloc_ibuf(struct stream_interface *si, struct buffer_wait *wait)
399{
400 int ret;
401
Willy Tarreau09799162018-10-25 10:16:07 +0200402 ret = channel_alloc_buffer(si_ic(si), wait);
403 if (!ret)
Willy Tarreau8be7cd72018-11-14 15:12:08 +0100404 si_rx_buff_blk(si);
Willy Tarreau09799162018-10-25 10:16:07 +0200405 return ret;
406}
407
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100408/* Release the interface's existing endpoint (connection or appctx) and
409 * allocate then initialize a new appctx which is assigned to the interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200410 * and returned. NULL may be returned upon memory shortage. Applet <applet>
411 * is assigned to the appctx, but it may be NULL.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100412 */
Willy Tarreau30576452015-04-13 13:50:30 +0200413static inline struct appctx *si_alloc_appctx(struct stream_interface *si, struct applet *applet)
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100414{
415 struct appctx *appctx;
416
417 si_release_endpoint(si);
Emeric Brun1138fd02017-06-19 12:38:55 +0200418 appctx = appctx_new(applet, tid_bit);
Willy Tarreau10d81b82018-05-31 14:44:25 +0200419 if (appctx) {
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100420 si_attach_appctx(si, appctx);
Willy Tarreau10d81b82018-05-31 14:44:25 +0200421 appctx->t->nice = si_strm(si)->task->nice;
422 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100423
424 return appctx;
425}
426
Willy Tarreau73b013b2012-05-21 16:31:45 +0200427/* Sends a shutr to the connection using the data layer */
428static inline void si_shutr(struct stream_interface *si)
429{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200430 si->ops->shutr(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200431}
432
433/* Sends a shutw to the connection using the data layer */
434static inline void si_shutw(struct stream_interface *si)
435{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200436 si->ops->shutw(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200437}
438
Willy Tarreau0f9cd7b2019-01-31 19:02:43 +0100439/* Marks on the stream-interface that next shutw must kill the whole connection */
440static inline void si_must_kill_conn(struct stream_interface *si)
441{
442 si->flags |= SI_FL_KILL_CONN;
443}
444
Willy Tarreau96aadd52018-11-07 11:55:54 +0100445/* This is to be used after making some room available in a channel. It will
Willy Tarreau32742fd2018-11-14 14:07:59 +0100446 * return without doing anything if the stream interface's RX path is blocked.
447 * It will automatically mark the stream interface as busy processing the end
448 * point in order to avoid useless repeated wakeups.
Willy Tarreau8fe516f2018-11-09 16:21:43 +0100449 * It will then call ->chk_rcv() to enable receipt of new data.
Willy Tarreau96aadd52018-11-07 11:55:54 +0100450 */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200451static inline void si_chk_rcv(struct stream_interface *si)
452{
Willy Tarreau4f283fa2019-06-05 14:34:03 +0200453 if (si->flags & SI_FL_RXBLK_CONN && si_state_in(si_opposite(si)->state, SI_SB_RDY|SI_SB_EST|SI_SB_DIS|SI_SB_CLO))
Willy Tarreaua3b62d32018-12-06 15:24:01 +0100454 si_rx_conn_rdy(si);
455
Willy Tarreau32742fd2018-11-14 14:07:59 +0100456 if (si_rx_blocked(si) || !si_rx_endp_ready(si))
Willy Tarreau96aadd52018-11-07 11:55:54 +0100457 return;
458
Willy Tarreau4f283fa2019-06-05 14:34:03 +0200459 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST))
Willy Tarreau1bdb5982018-11-07 14:59:45 +0100460 return;
461
Willy Tarreau05b9b642018-11-14 13:43:35 +0100462 si->flags |= SI_FL_RX_WAIT_EP;
Willy Tarreau57f08bb2018-11-07 11:28:12 +0100463 si->ops->chk_rcv(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200464}
465
Willy Tarreauade64782018-11-17 19:51:07 +0100466/* This tries to perform a synchronous receive on the stream interface to
467 * try to collect last arrived data. In practice it's only implemented on
468 * conn_streams. Returns 0 if nothing was done, non-zero if new data or a
469 * shutdown were collected. This may result on some delayed receive calls
470 * to be programmed and performed later, though it doesn't provide any
471 * such guarantee.
472 */
473static inline int si_sync_recv(struct stream_interface *si)
474{
475 struct conn_stream *cs;
476
Willy Tarreau4f283fa2019-06-05 14:34:03 +0200477 if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST))
Willy Tarreauade64782018-11-17 19:51:07 +0100478 return 0;
479
480 cs = objt_cs(si->end);
481 if (!cs)
482 return 0; // only conn_streams are supported
483
Willy Tarreau4f6516d2018-12-19 13:59:17 +0100484 if (si->wait_event.events & SUB_RETRY_RECV)
Willy Tarreauade64782018-11-17 19:51:07 +0100485 return 0; // already subscribed
486
Willy Tarreau7f494d02018-11-16 14:26:11 +0100487 if (!si_rx_endp_ready(si) || si_rx_blocked(si))
Willy Tarreauade64782018-11-17 19:51:07 +0100488 return 0; // already failed
489
490 return si_cs_recv(cs);
491}
492
Willy Tarreau73b013b2012-05-21 16:31:45 +0200493/* Calls chk_snd on the connection using the data layer */
494static inline void si_chk_snd(struct stream_interface *si)
495{
Willy Tarreau57f08bb2018-11-07 11:28:12 +0100496 si->ops->chk_snd(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200497}
498
499/* Calls chk_snd on the connection using the ctrl layer */
Olivier Houchard201b9f42018-11-21 00:16:29 +0100500static inline int si_connect(struct stream_interface *si, struct connection *conn)
Willy Tarreau73b013b2012-05-21 16:31:45 +0200501{
Willy Tarreaue7dff022015-04-03 01:14:29 +0200502 int ret = SF_ERR_NONE;
Willy Tarreau034c88c2017-01-23 23:36:45 +0100503 int conn_flags = 0;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200504
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200505 if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect))
Willy Tarreaue7dff022015-04-03 01:14:29 +0200506 return SF_ERR_INTERNAL;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200507
Willy Tarreau034c88c2017-01-23 23:36:45 +0100508 if (!channel_is_empty(si_oc(si)))
509 conn_flags |= CONNECT_HAS_DATA;
510 if (si->conn_retries == si_strm(si)->be->conn_retries)
511 conn_flags |= CONNECT_CAN_USE_TFO;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100512 if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) {
Willy Tarreau034c88c2017-01-23 23:36:45 +0100513 ret = conn->ctrl->connect(conn, conn_flags);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200514 if (ret != SF_ERR_NONE)
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100515 return ret;
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100516
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100517 /* we're in the process of establishing a connection */
518 si->state = SI_ST_CON;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100519 }
Christopher Fauletc34d19f2015-12-23 09:33:35 +0100520 else {
Willy Tarreaubf66bd12019-01-23 15:15:09 +0100521 /* try to reuse the existing connection, it will be
522 * confirmed once we can send on it.
523 */
Olivier Houchard6e8e2ec2019-10-25 16:25:20 +0200524 /* Is the connection really ready ? */
525 if (conn->mux->ctl(conn, MUX_STATUS, NULL) & MUX_STATUS_READY)
526 si->state = SI_ST_RDY;
527 else
528 si->state = SI_ST_CON;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100529 }
Willy Tarreau14f8e862012-08-30 22:23:13 +0200530
531 /* needs src ip/port for logging */
532 if (si->flags & SI_FL_SRC_ADDR)
Willy Tarreau3cc01d82019-07-17 11:27:38 +0200533 conn_get_src(conn);
Willy Tarreau14f8e862012-08-30 22:23:13 +0200534
Willy Tarreau14f8e862012-08-30 22:23:13 +0200535 return ret;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200536}
Willy Tarreau59b94792012-05-11 16:16:40 +0200537
Willy Tarreau236c4292019-06-06 08:19:20 +0200538/* Combines both si_update_rx() and si_update_tx() at once */
539static inline void si_update(struct stream_interface *si)
540{
541 si_update_rx(si);
542 si_update_tx(si);
543}
544
Christopher Faulet3bc1b112018-11-29 11:29:26 +0100545/* Returns info about the conn_stream <cs>, if not NULL. It call the mux layer's
546 * get_cs_info() function, if it exists. On success, it returns a cs_info
547 * structure. Otherwise, on error, if the mux does not implement get_cs_info()
548 * or if conn_stream is NULL, NULL is returned.
549 */
550static inline const struct cs_info *si_get_cs_info(struct conn_stream *cs)
551{
552 if (cs && cs->conn->mux->get_cs_info)
553 return cs->conn->mux->get_cs_info(cs);
554 return NULL;
555}
556
Willy Tarreau55e4ecd2012-12-08 17:48:47 +0100557/* for debugging, reports the stream interface state name */
558static inline const char *si_state_str(int state)
559{
560 switch (state) {
561 case SI_ST_INI: return "INI";
562 case SI_ST_REQ: return "REQ";
563 case SI_ST_QUE: return "QUE";
564 case SI_ST_TAR: return "TAR";
565 case SI_ST_ASS: return "ASS";
566 case SI_ST_CON: return "CON";
567 case SI_ST_CER: return "CER";
Willy Tarreau4f283fa2019-06-05 14:34:03 +0200568 case SI_ST_RDY: return "RDY";
Willy Tarreau55e4ecd2012-12-08 17:48:47 +0100569 case SI_ST_EST: return "EST";
570 case SI_ST_DIS: return "DIS";
571 case SI_ST_CLO: return "CLO";
572 default: return "???";
573 }
574}
575
Willy Tarreaucff64112008-11-03 06:26:53 +0100576#endif /* _PROTO_STREAM_INTERFACE_H */
577
578/*
579 * Local variables:
580 * c-indent-level: 8
581 * c-basic-offset: 8
582 * End:
583 */