blob: 7fc6d7e21d125b63239b2d70d0952900164b3ffb [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
36/* main event functions used to move data between sockets and buffers */
Willy Tarreau269358d2009-09-20 20:14:49 +020037int stream_int_check_timeouts(struct stream_interface *si);
Willy Tarreaucff64112008-11-03 06:26:53 +010038void stream_int_report_error(struct stream_interface *si);
Willy Tarreau83061a82018-07-13 11:56:34 +020039void stream_int_retnclose(struct stream_interface *si,
40 const struct buffer *msg);
Willy Tarreau2c6be842012-07-06 17:12:34 +020041int conn_si_send_proxy(struct connection *conn, unsigned int flag);
Willy Tarreau9bf9c142012-08-20 15:38:41 +020042void stream_sock_read0(struct stream_interface *si);
Willy Tarreaucff64112008-11-03 06:26:53 +010043
Willy Tarreauc5788912012-08-24 18:12:41 +020044extern struct si_ops si_embedded_ops;
Willy Tarreauc5788912012-08-24 18:12:41 +020045extern struct si_ops si_conn_ops;
Willy Tarreaud45b9f82015-04-13 16:30:14 +020046extern struct si_ops si_applet_ops;
Willy Tarreau74beec32012-10-03 00:41:04 +020047extern struct data_cb si_conn_cb;
Willy Tarreau27375622013-12-17 00:00:28 +010048extern struct data_cb si_idle_conn_cb;
Willy Tarreau5c979a92012-05-07 17:15:39 +020049
Willy Tarreau30576452015-04-13 13:50:30 +020050struct appctx *stream_int_register_handler(struct stream_interface *si, struct applet *app);
Willy Tarreauaa977ba2015-09-25 11:45:06 +020051void si_applet_wake_cb(struct stream_interface *si);
Willy Tarreau25f13102015-09-24 11:32:22 +020052void stream_int_update(struct stream_interface *si);
Willy Tarreau615f28b2015-09-23 18:40:09 +020053void stream_int_notify(struct stream_interface *si);
Olivier Houchard0e367bb2018-09-14 19:41:13 +020054int si_cs_recv(struct conn_stream *cs);
55int si_cs_send(struct conn_stream *cs);
Olivier Houchard91894cb2018-08-02 18:06:28 +020056struct task *si_cs_io_cb(struct task *t, void *ctx, unsigned short state);
Willy Tarreaud14844a2018-11-08 18:15:29 +010057void si_update_both(struct stream_interface *si_f, struct stream_interface *si_b);
Willy Tarreaufb90d942009-09-05 20:57:35 +020058
Willy Tarreau2bb4a962014-11-28 11:11:05 +010059/* returns the channel which receives data from this stream interface (input channel) */
60static inline struct channel *si_ic(struct stream_interface *si)
61{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010062 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020063 return &LIST_ELEM(si, struct stream *, si[1])->res;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010064 else
Willy Tarreau87b09662015-04-03 00:22:06 +020065 return &LIST_ELEM(si, struct stream *, si[0])->req;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010066}
67
68/* returns the channel which feeds data to this stream interface (output channel) */
69static inline struct channel *si_oc(struct stream_interface *si)
70{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010071 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020072 return &LIST_ELEM(si, struct stream *, si[1])->req;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010073 else
Willy Tarreau87b09662015-04-03 00:22:06 +020074 return &LIST_ELEM(si, struct stream *, si[0])->res;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010075}
76
Willy Tarreau4e4292b2014-11-28 12:18:45 +010077/* returns the buffer which receives data from this stream interface (input channel's buffer) */
78static inline struct buffer *si_ib(struct stream_interface *si)
79{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020080 return &si_ic(si)->buf;
Willy Tarreau4e4292b2014-11-28 12:18:45 +010081}
82
83/* returns the buffer which feeds data to this stream interface (output channel's buffer) */
84static inline struct buffer *si_ob(struct stream_interface *si)
85{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020086 return &si_oc(si)->buf;
Willy Tarreau4e4292b2014-11-28 12:18:45 +010087}
88
Willy Tarreau87b09662015-04-03 00:22:06 +020089/* returns the stream associated to a stream interface */
90static inline struct stream *si_strm(struct stream_interface *si)
Willy Tarreauaefd7902014-11-28 12:03:32 +010091{
92 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020093 return LIST_ELEM(si, struct stream *, si[1]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010094 else
Willy Tarreau87b09662015-04-03 00:22:06 +020095 return LIST_ELEM(si, struct stream *, si[0]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010096}
97
Willy Tarreau07373b82014-11-28 12:08:47 +010098/* returns the task associated to this stream interface */
99static inline struct task *si_task(struct stream_interface *si)
100{
101 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +0200102 return LIST_ELEM(si, struct stream *, si[1])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +0100103 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200104 return LIST_ELEM(si, struct stream *, si[0])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +0100105}
106
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100107/* returns the stream interface on the other side. Used during forwarding. */
108static inline struct stream_interface *si_opposite(struct stream_interface *si)
109{
110 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +0200111 return &LIST_ELEM(si, struct stream *, si[1])->si[0];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100112 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200113 return &LIST_ELEM(si, struct stream *, si[0])->si[1];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100114}
115
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200116/* initializes a stream interface in the SI_ST_INI state. It's detached from
Willy Tarreau819d3322014-11-28 12:12:34 +0100117 * any endpoint and only keeps its side which is expected to have already been
118 * set.
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200119 */
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200120static inline int si_reset(struct stream_interface *si)
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200121{
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200122 si->err_type = SI_ET_NONE;
123 si->conn_retries = 0; /* used for logging too */
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200124 si->exp = TICK_ETERNITY;
Willy Tarreaua5f5d8d2014-11-28 11:26:07 +0100125 si->flags &= SI_FL_ISBACK;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200126 si->end = NULL;
127 si->state = si->prev_state = SI_ST_INI;
Willy Tarreau7365dad2015-04-20 01:03:17 +0200128 si->ops = &si_embedded_ops;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200129 si->wait_event.task = tasklet_new();
130 if (!si->wait_event.task)
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200131 return -1;
Olivier Houchardfa8aa862018-10-10 18:25:41 +0200132 si->wait_event.task->process = si_cs_io_cb;
133 si->wait_event.task->context = si;
134 si->wait_event.wait_reason = 0;
Olivier Houchard8f0b4c62018-08-02 18:21:38 +0200135 return 0;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200136}
137
138/* sets the current and previous state of a stream interface to <state>. This
139 * is mainly used to create one in the established state on incoming
140 * conncetions.
141 */
142static inline void si_set_state(struct stream_interface *si, int state)
143{
144 si->state = si->prev_state = state;
145}
146
Willy Tarreau41b09f42015-08-04 20:44:05 +0200147/* only detaches the endpoint from the SI, which means that it's set to
148 * NULL and that ->ops is mapped to si_embedded_ops. The previous endpoint
149 * is returned.
150 */
151static inline enum obj_type *si_detach_endpoint(struct stream_interface *si)
152{
153 enum obj_type *prev = si->end;
154
155 si->end = NULL;
156 si->ops = &si_embedded_ops;
157 return prev;
158}
159
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100160/* Release the endpoint if it's a connection or an applet, then nullify it.
161 * Note: released connections are closed then freed.
162 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200163static inline void si_release_endpoint(struct stream_interface *si)
Willy Tarreau372d6702013-09-29 17:19:56 +0200164{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200165 struct conn_stream *cs;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100166 struct appctx *appctx;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200167
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100168 if (!si->end)
169 return;
170
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200171 if ((cs = objt_cs(si->end))) {
172 if (si->wait_event.wait_reason != 0)
173 cs->conn->mux->unsubscribe(cs, si->wait_event.wait_reason,
174 &si->wait_event);
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200175 cs_destroy(cs);
Olivier Houchard4fdec7a2018-10-11 17:09:14 +0200176 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100177 else if ((appctx = objt_appctx(si->end))) {
Willy Tarreau958f0742015-09-25 20:24:26 +0200178 if (appctx->applet->release && si->state < SI_ST_DIS)
Willy Tarreau00a37f02015-04-13 12:05:19 +0200179 appctx->applet->release(appctx);
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100180 appctx_free(appctx); /* we share the connection pool */
181 }
Willy Tarreau41b09f42015-08-04 20:44:05 +0200182 si_detach_endpoint(si);
Willy Tarreau372d6702013-09-29 17:19:56 +0200183}
184
Willy Tarreau4320eaa2015-08-05 11:08:30 +0200185/* Turn an existing connection endpoint of stream interface <si> to idle mode,
186 * which means that the connection will be polled for incoming events and might
187 * be killed by the underlying I/O handler. If <pool> is not null, the
188 * connection will also be added at the head of this list. This connection
189 * remains assigned to the stream interface it is currently attached to.
Willy Tarreau27375622013-12-17 00:00:28 +0100190 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200191static inline void si_idle_cs(struct stream_interface *si, struct list *pool)
Willy Tarreau27375622013-12-17 00:00:28 +0100192{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200193 struct conn_stream *cs = __objt_cs(si->end);
194 struct connection *conn = cs->conn;
Willy Tarreau27375622013-12-17 00:00:28 +0100195
Olivier Houchard1fddc9b2018-10-21 00:32:01 +0200196 conn_force_unsubscribe(conn);
Willy Tarreau323a2d92015-08-04 19:00:17 +0200197 if (pool)
198 LIST_ADD(pool, &conn->list);
199
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200200 cs_attach(cs, si, &si_idle_conn_cb);
Willy Tarreau27375622013-12-17 00:00:28 +0100201}
202
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200203/* Attach conn_stream <cs> to the stream interface <si>. The stream interface
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200204 * is configured to work with a connection and the connection it configured
205 * with a stream interface data layer.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200206 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200207static inline void si_attach_cs(struct stream_interface *si, struct conn_stream *cs)
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200208{
209 si->ops = &si_conn_ops;
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200210 si->end = &cs->obj_type;
211 cs_attach(cs, si, &si_conn_cb);
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200212}
213
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100214/* Returns true if a connection is attached to the stream interface <si> and
215 * if this connection is ready.
216 */
217static inline int si_conn_ready(struct stream_interface *si)
218{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200219 struct connection *conn = cs_conn(objt_cs(si->end));
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100220
221 return conn && conn_ctrl_ready(conn) && conn_xprt_ready(conn);
222}
223
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100224/* Attach appctx <appctx> to the stream interface <si>. The stream interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200225 * is configured to work with an applet context.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100226 */
227static inline void si_attach_appctx(struct stream_interface *si, struct appctx *appctx)
Willy Tarreauc5788912012-08-24 18:12:41 +0200228{
Willy Tarreaud45b9f82015-04-13 16:30:14 +0200229 si->ops = &si_applet_ops;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100230 si->end = &appctx->obj_type;
Willy Tarreau19c81612015-04-13 11:48:16 +0200231 appctx->owner = si;
Willy Tarreauc5788912012-08-24 18:12:41 +0200232}
233
Willy Tarreau4ae49232018-09-20 11:08:47 +0200234/* returns a pointer to the appctx being run in the SI, which must be valid */
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100235static inline struct appctx *si_appctx(struct stream_interface *si)
236{
Willy Tarreau4ae49232018-09-20 11:08:47 +0200237 return __objt_appctx(si->end);
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100238}
239
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200240/* call the applet's release function if any. Needs to be called upon close() */
241static inline void si_applet_release(struct stream_interface *si)
242{
Willy Tarreau00a37f02015-04-13 12:05:19 +0200243 struct appctx *appctx;
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200244
Willy Tarreau4ae49232018-09-20 11:08:47 +0200245 appctx = objt_appctx(si->end);
Willy Tarreau958f0742015-09-25 20:24:26 +0200246 if (appctx && appctx->applet->release && si->state < SI_ST_DIS)
Willy Tarreau00a37f02015-04-13 12:05:19 +0200247 appctx->applet->release(appctx);
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200248}
249
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100250/* Report that a stream interface wants to put some data into the input buffer */
251static inline void si_want_put(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200252{
253 si->flags |= SI_FL_WANT_PUT;
254}
255
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100256/* Report that a stream interface failed to put some data into the input buffer */
257static inline void si_cant_put(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200258{
259 si->flags |= SI_FL_WANT_PUT | SI_FL_WAIT_ROOM;
260}
261
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100262/* Report that a stream interface doesn't want to put data into the input buffer */
263static inline void si_stop_put(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200264{
265 si->flags &= ~SI_FL_WANT_PUT;
266}
267
Willy Tarreau394970c2018-11-06 19:17:31 +0100268/* Report that a stream interface won't put any more data into the input buffer */
269static inline void si_done_put(struct stream_interface *si)
270{
271 si->flags &= ~(SI_FL_WANT_PUT | SI_FL_WAIT_ROOM);
272}
273
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100274/* Report that a stream interface wants to get some data from the output buffer */
275static inline void si_want_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200276{
277 si->flags |= SI_FL_WANT_GET;
278}
279
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100280/* Report that a stream interface failed to get some data from the output buffer */
281static inline void si_cant_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200282{
283 si->flags |= SI_FL_WANT_GET | SI_FL_WAIT_DATA;
284}
285
Willy Tarreau0cd3bd62018-11-06 18:46:37 +0100286/* Report that a stream interface doesn't want to get data from the output buffer */
287static inline void si_stop_get(struct stream_interface *si)
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200288{
289 si->flags &= ~SI_FL_WANT_GET;
290}
291
Willy Tarreau394970c2018-11-06 19:17:31 +0100292/* Report that a stream interface won't get any more data from the output buffer */
293static inline void si_done_get(struct stream_interface *si)
294{
295 si->flags &= ~(SI_FL_WANT_GET | SI_FL_WAIT_DATA);
296}
297
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200298/* Try to allocate a new conn_stream and assign it to the interface. If
Willy Tarreau973a5422015-08-05 21:47:23 +0200299 * an endpoint was previously allocated, it is released first. The newly
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200300 * allocated conn_stream is initialized, assigned to the stream interface,
Willy Tarreau973a5422015-08-05 21:47:23 +0200301 * and returned.
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100302 */
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200303static inline struct conn_stream *si_alloc_cs(struct stream_interface *si, struct connection *conn)
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200304{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200305 struct conn_stream *cs;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200306
Willy Tarreau973a5422015-08-05 21:47:23 +0200307 si_release_endpoint(si);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200308
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200309 cs = cs_new(conn);
310 if (cs)
311 si_attach_cs(si, cs);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200312
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200313 return cs;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200314}
315
Willy Tarreau09799162018-10-25 10:16:07 +0200316/* Try to allocate a buffer for the stream-int's input channel. It relies on
Willy Tarreauabf531c2018-11-07 18:53:29 +0100317 * channel_alloc_buffer() for this so it abides by its rules. It returns 0 on
318 * failure, non-zero otherwise. If no buffer is available, the requester,
Willy Tarreau09799162018-10-25 10:16:07 +0200319 * represented by <wait> pointer, will be added in the list of objects waiting
320 * for an available buffer, and SI_FL_WAIT_ROOM will be set on the stream-int.
321 * The requester will be responsible for calling this function to try again
322 * once woken up.
323 */
324static inline int si_alloc_ibuf(struct stream_interface *si, struct buffer_wait *wait)
325{
326 int ret;
327
Willy Tarreau09799162018-10-25 10:16:07 +0200328 ret = channel_alloc_buffer(si_ic(si), wait);
329 if (!ret)
Willy Tarreauaf4f6f62018-11-06 19:10:53 +0100330 si_cant_put(si);
Willy Tarreau09799162018-10-25 10:16:07 +0200331 return ret;
332}
333
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100334/* Release the interface's existing endpoint (connection or appctx) and
335 * allocate then initialize a new appctx which is assigned to the interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200336 * and returned. NULL may be returned upon memory shortage. Applet <applet>
337 * is assigned to the appctx, but it may be NULL.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100338 */
Willy Tarreau30576452015-04-13 13:50:30 +0200339static inline struct appctx *si_alloc_appctx(struct stream_interface *si, struct applet *applet)
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100340{
341 struct appctx *appctx;
342
343 si_release_endpoint(si);
Emeric Brun1138fd02017-06-19 12:38:55 +0200344 appctx = appctx_new(applet, tid_bit);
Willy Tarreau10d81b82018-05-31 14:44:25 +0200345 if (appctx) {
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100346 si_attach_appctx(si, appctx);
Willy Tarreau10d81b82018-05-31 14:44:25 +0200347 appctx->t->nice = si_strm(si)->task->nice;
348 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100349
350 return appctx;
351}
352
Willy Tarreau73b013b2012-05-21 16:31:45 +0200353/* Sends a shutr to the connection using the data layer */
354static inline void si_shutr(struct stream_interface *si)
355{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200356 si->ops->shutr(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200357}
358
359/* Sends a shutw to the connection using the data layer */
360static inline void si_shutw(struct stream_interface *si)
361{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200362 si->ops->shutw(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200363}
364
Willy Tarreau96aadd52018-11-07 11:55:54 +0100365/* This is to be used after making some room available in a channel. It will
Willy Tarreau8fe516f2018-11-09 16:21:43 +0100366 * return without doing anything if {SI_FL_WANT_PUT,SI_FL_WAIT_ROOM} != {1,0}.
367 * It will then call ->chk_rcv() to enable receipt of new data.
Willy Tarreau96aadd52018-11-07 11:55:54 +0100368 */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200369static inline void si_chk_rcv(struct stream_interface *si)
370{
Willy Tarreau8fe516f2018-11-09 16:21:43 +0100371 if (si->flags & SI_FL_WAIT_ROOM)
372 return;
Willy Tarreau96aadd52018-11-07 11:55:54 +0100373
374 if (!(si->flags & SI_FL_WANT_PUT))
375 return;
376
Willy Tarreau1bdb5982018-11-07 14:59:45 +0100377 if (si->state > SI_ST_EST)
378 return;
379
Willy Tarreau1f9de212018-11-07 15:07:35 +0100380 si->flags &= ~SI_FL_WANT_PUT;
Willy Tarreau57f08bb2018-11-07 11:28:12 +0100381 si->ops->chk_rcv(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200382}
383
384/* Calls chk_snd on the connection using the data layer */
385static inline void si_chk_snd(struct stream_interface *si)
386{
Willy Tarreau57f08bb2018-11-07 11:28:12 +0100387 si->ops->chk_snd(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200388}
389
390/* Calls chk_snd on the connection using the ctrl layer */
391static inline int si_connect(struct stream_interface *si)
392{
Olivier Houchard9aaf7782017-09-13 18:30:23 +0200393 struct conn_stream *cs = objt_cs(si->end);
394 struct connection *conn = cs_conn(cs);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200395 int ret = SF_ERR_NONE;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200396
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200397 if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect))
Willy Tarreaue7dff022015-04-03 01:14:29 +0200398 return SF_ERR_INTERNAL;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200399
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100400 if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) {
Willy Tarreau2bb4a962014-11-28 11:11:05 +0100401 ret = conn->ctrl->connect(conn, !channel_is_empty(si_oc(si)), 0);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200402 if (ret != SF_ERR_NONE)
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100403 return ret;
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100404
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100405 /* we're in the process of establishing a connection */
406 si->state = SI_ST_CON;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100407 }
Christopher Fauletc34d19f2015-12-23 09:33:35 +0100408 else {
409 /* reuse the existing connection */
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100410
411 /* the connection is established */
412 si->state = SI_ST_EST;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100413 }
Willy Tarreau14f8e862012-08-30 22:23:13 +0200414
415 /* needs src ip/port for logging */
416 if (si->flags & SI_FL_SRC_ADDR)
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200417 conn_get_from_addr(conn);
Willy Tarreau14f8e862012-08-30 22:23:13 +0200418
Willy Tarreau14f8e862012-08-30 22:23:13 +0200419 return ret;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200420}
Willy Tarreau59b94792012-05-11 16:16:40 +0200421
Willy Tarreau55e4ecd2012-12-08 17:48:47 +0100422/* for debugging, reports the stream interface state name */
423static inline const char *si_state_str(int state)
424{
425 switch (state) {
426 case SI_ST_INI: return "INI";
427 case SI_ST_REQ: return "REQ";
428 case SI_ST_QUE: return "QUE";
429 case SI_ST_TAR: return "TAR";
430 case SI_ST_ASS: return "ASS";
431 case SI_ST_CON: return "CON";
432 case SI_ST_CER: return "CER";
433 case SI_ST_EST: return "EST";
434 case SI_ST_DIS: return "DIS";
435 case SI_ST_CLO: return "CLO";
436 default: return "???";
437 }
438}
439
Willy Tarreaucff64112008-11-03 06:26:53 +0100440#endif /* _PROTO_STREAM_INTERFACE_H */
441
442/*
443 * Local variables:
444 * c-indent-level: 8
445 * c-basic-offset: 8
446 * End:
447 */