blob: 801e4d884534aab069d7733e83051545fd6f3151 [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 Tarreau87b09662015-04-03 00:22:06 +020028#include <types/stream.h>
Willy Tarreaucff64112008-11-03 06:26:53 +010029#include <types/stream_interface.h>
Willy Tarreau14f8e862012-08-30 22:23:13 +020030#include <proto/channel.h>
Willy Tarreauf9dabec2012-08-17 17:33:53 +020031#include <proto/connection.h>
Willy Tarreaucff64112008-11-03 06:26:53 +010032
33
34/* main event functions used to move data between sockets and buffers */
Willy Tarreau269358d2009-09-20 20:14:49 +020035int stream_int_check_timeouts(struct stream_interface *si);
Willy Tarreaucff64112008-11-03 06:26:53 +010036void stream_int_report_error(struct stream_interface *si);
Willy Tarreaudded32d2008-11-30 19:48:07 +010037void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg);
Willy Tarreau2c6be842012-07-06 17:12:34 +020038int conn_si_send_proxy(struct connection *conn, unsigned int flag);
Willy Tarreau9bf9c142012-08-20 15:38:41 +020039void stream_sock_read0(struct stream_interface *si);
Willy Tarreaucff64112008-11-03 06:26:53 +010040
Willy Tarreauc5788912012-08-24 18:12:41 +020041extern struct si_ops si_embedded_ops;
Willy Tarreauc5788912012-08-24 18:12:41 +020042extern struct si_ops si_conn_ops;
Willy Tarreau74beec32012-10-03 00:41:04 +020043extern struct data_cb si_conn_cb;
Willy Tarreau27375622013-12-17 00:00:28 +010044extern struct data_cb si_idle_conn_cb;
Willy Tarreau5c979a92012-05-07 17:15:39 +020045
Willy Tarreau1fbe1c92013-12-01 09:35:41 +010046struct appctx *stream_int_register_handler(struct stream_interface *si, struct si_applet *app);
Willy Tarreaufb90d942009-09-05 20:57:35 +020047void stream_int_unregister_handler(struct stream_interface *si);
48
Willy Tarreau2bb4a962014-11-28 11:11:05 +010049/* returns the channel which receives data from this stream interface (input channel) */
50static inline struct channel *si_ic(struct stream_interface *si)
51{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010052 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020053 return &LIST_ELEM(si, struct stream *, si[1])->res;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010054 else
Willy Tarreau87b09662015-04-03 00:22:06 +020055 return &LIST_ELEM(si, struct stream *, si[0])->req;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010056}
57
58/* returns the channel which feeds data to this stream interface (output channel) */
59static inline struct channel *si_oc(struct stream_interface *si)
60{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010061 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020062 return &LIST_ELEM(si, struct stream *, si[1])->req;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010063 else
Willy Tarreau87b09662015-04-03 00:22:06 +020064 return &LIST_ELEM(si, struct stream *, si[0])->res;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010065}
66
Willy Tarreau4e4292b2014-11-28 12:18:45 +010067/* returns the buffer which receives data from this stream interface (input channel's buffer) */
68static inline struct buffer *si_ib(struct stream_interface *si)
69{
70 return si_ic(si)->buf;
71}
72
73/* returns the buffer which feeds data to this stream interface (output channel's buffer) */
74static inline struct buffer *si_ob(struct stream_interface *si)
75{
76 return si_oc(si)->buf;
77}
78
Willy Tarreau87b09662015-04-03 00:22:06 +020079/* returns the stream associated to a stream interface */
80static inline struct stream *si_strm(struct stream_interface *si)
Willy Tarreauaefd7902014-11-28 12:03:32 +010081{
82 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020083 return LIST_ELEM(si, struct stream *, si[1]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010084 else
Willy Tarreau87b09662015-04-03 00:22:06 +020085 return LIST_ELEM(si, struct stream *, si[0]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010086}
87
Willy Tarreau07373b82014-11-28 12:08:47 +010088/* returns the task associated to this stream interface */
89static inline struct task *si_task(struct stream_interface *si)
90{
91 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020092 return LIST_ELEM(si, struct stream *, si[1])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +010093 else
Willy Tarreau87b09662015-04-03 00:22:06 +020094 return LIST_ELEM(si, struct stream *, si[0])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +010095}
96
Willy Tarreau50fe03b2014-11-28 13:59:31 +010097/* returns the stream interface on the other side. Used during forwarding. */
98static inline struct stream_interface *si_opposite(struct stream_interface *si)
99{
100 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +0200101 return &LIST_ELEM(si, struct stream *, si[1])->si[0];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100102 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200103 return &LIST_ELEM(si, struct stream *, si[0])->si[1];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100104}
105
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100106/* Initializes all required fields for a new appctx. Note that it does the
107 * minimum acceptable initialization for an appctx. This means only the
108 * 3 integer states st0, st1, st2 are zeroed.
109 */
110static inline void appctx_init(struct appctx *appctx)
111{
112 appctx->st0 = appctx->st1 = appctx->st2 = 0;
113}
114
115/* sets <appctx>'s applet to point to <applet> */
116static inline void appctx_set_applet(struct appctx *appctx, struct si_applet *applet)
117{
118 appctx->applet = applet;
119}
120
121/* Tries to allocate a new appctx and initialize its main fields. The
122 * appctx is returned on success, NULL on failure. The appctx must be
123 * released using pool_free2(connection) or appctx_free(), since it's
124 * allocated from the connection pool.
125 */
126static inline struct appctx *appctx_new()
127{
128 struct appctx *appctx;
129
130 appctx = pool_alloc2(pool2_connection);
131 if (likely(appctx != NULL)) {
132 appctx->obj_type = OBJ_TYPE_APPCTX;
133 appctx->applet = NULL;
134 appctx_init(appctx);
135 }
136 return appctx;
137}
138
139/* Releases an appctx previously allocated by appctx_new(). Note that
140 * we share the connection pool.
141 */
142static inline void appctx_free(struct appctx *appctx)
143{
144 pool_free2(pool2_connection, appctx);
145}
146
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200147/* initializes a stream interface in the SI_ST_INI state. It's detached from
Willy Tarreau819d3322014-11-28 12:12:34 +0100148 * any endpoint and only keeps its side which is expected to have already been
149 * set.
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200150 */
Willy Tarreau819d3322014-11-28 12:12:34 +0100151static inline void si_reset(struct stream_interface *si)
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200152{
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200153 si->err_type = SI_ET_NONE;
154 si->conn_retries = 0; /* used for logging too */
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200155 si->exp = TICK_ETERNITY;
Willy Tarreaua5f5d8d2014-11-28 11:26:07 +0100156 si->flags &= SI_FL_ISBACK;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200157 si->end = NULL;
158 si->state = si->prev_state = SI_ST_INI;
159}
160
161/* sets the current and previous state of a stream interface to <state>. This
162 * is mainly used to create one in the established state on incoming
163 * conncetions.
164 */
165static inline void si_set_state(struct stream_interface *si, int state)
166{
167 si->state = si->prev_state = state;
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{
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200175 struct connection *conn;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100176 struct appctx *appctx;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200177
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100178 if (!si->end)
179 return;
180
181 if ((conn = objt_conn(si->end))) {
182 conn_force_close(conn);
183 conn_free(conn);
184 }
185 else if ((appctx = objt_appctx(si->end))) {
186 if (appctx->applet->release)
187 appctx->applet->release(si);
188 appctx_free(appctx); /* we share the connection pool */
189 }
Willy Tarreau7d67d7b2013-09-29 16:05:22 +0200190 si->end = NULL;
Willy Tarreau372d6702013-09-29 17:19:56 +0200191}
192
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200193static inline void si_detach(struct stream_interface *si)
194{
195 si_release_endpoint(si);
196 si->ops = &si_embedded_ops;
197}
198
Willy Tarreau27375622013-12-17 00:00:28 +0100199/* Turn a possibly existing connection endpoint of stream interface <si> to
200 * idle mode, which means that the connection will be polled for incoming events
201 * and might be killed by the underlying I/O handler.
202 */
203static inline void si_idle_conn(struct stream_interface *si)
204{
205 struct connection *conn = objt_conn(si->end);
206
207 if (!conn)
208 return;
209
210 conn_attach(conn, si, &si_idle_conn_cb);
211 conn_data_want_recv(conn);
212}
213
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200214/* Attach connection <conn> to the stream interface <si>. The stream interface
215 * is configured to work with a connection and the connection it configured
216 * with a stream interface data layer.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200217 */
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200218static inline void si_attach_conn(struct stream_interface *si, struct connection *conn)
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200219{
220 si->ops = &si_conn_ops;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200221 si->end = &conn->obj_type;
Willy Tarreau7abddb52013-10-24 15:31:04 +0200222 conn_attach(conn, si, &si_conn_cb);
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200223}
224
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100225/* Returns true if a connection is attached to the stream interface <si> and
226 * if this connection is ready.
227 */
228static inline int si_conn_ready(struct stream_interface *si)
229{
230 struct connection *conn = objt_conn(si->end);
231
232 return conn && conn_ctrl_ready(conn) && conn_xprt_ready(conn);
233}
234
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100235/* Attach appctx <appctx> to the stream interface <si>. The stream interface
236 * is configured to work with an applet context. It is left to the caller to
237 * call appctx_set_applet() to assign an applet to this context.
238 */
239static inline void si_attach_appctx(struct stream_interface *si, struct appctx *appctx)
Willy Tarreauc5788912012-08-24 18:12:41 +0200240{
241 si->ops = &si_embedded_ops;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100242 appctx->obj_type = OBJ_TYPE_APPCTX;
243 si->end = &appctx->obj_type;
Willy Tarreauc5788912012-08-24 18:12:41 +0200244}
245
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100246/* returns a pointer to the appctx being run in the SI or NULL if none */
247static inline struct appctx *si_appctx(struct stream_interface *si)
248{
249 return objt_appctx(si->end);
250}
251
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200252/* returns a pointer to the applet being run in the SI or NULL if none */
253static inline const struct si_applet *si_applet(struct stream_interface *si)
254{
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100255 const struct appctx *appctx;
256
257 appctx = si_appctx(si);
258 if (appctx)
259 return appctx->applet;
Willy Tarreaucf644ed2013-09-29 17:19:56 +0200260 return NULL;
261}
262
263/* Call the applet's main function when an appctx is attached to the stream
264 * interface. Returns zero if no call was made, or non-zero if a call was made.
265 */
266static inline int si_applet_call(struct stream_interface *si)
267{
268 const struct si_applet *applet;
269
270 applet = si_applet(si);
271 if (applet) {
272 applet->fct(si);
273 return 1;
274 }
275 return 0;
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200276}
277
278/* call the applet's release function if any. Needs to be called upon close() */
279static inline void si_applet_release(struct stream_interface *si)
280{
281 const struct si_applet *applet;
282
283 applet = si_applet(si);
284 if (applet && applet->release)
285 applet->release(si);
286}
287
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100288/* Try to allocate a new connection and assign it to the interface. If
289 * a connection was previously allocated and the <reuse> flag is set,
290 * it is returned unmodified. Otherwise it is reset.
291 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200292/* Returns the stream interface's existing connection if one such already
293 * exists, or tries to allocate and initialize a new one which is then
294 * assigned to the stream interface.
295 */
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100296static inline struct connection *si_alloc_conn(struct stream_interface *si, int reuse)
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200297{
298 struct connection *conn;
299
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100300 /* If we find a connection, we return it, otherwise it's an applet
301 * and we start by releasing it.
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200302 */
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100303 if (si->end) {
304 conn = objt_conn(si->end);
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100305 if (conn) {
306 if (!reuse) {
307 conn_force_close(conn);
308 conn_init(conn);
309 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100310 return conn;
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100311 }
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100312 /* it was an applet then */
313 si_release_endpoint(si);
314 }
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200315
316 conn = conn_new();
317 if (conn)
318 si_attach_conn(si, conn);
319
320 return conn;
321}
322
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100323/* Release the interface's existing endpoint (connection or appctx) and
324 * allocate then initialize a new appctx which is assigned to the interface
325 * and returned. NULL may be returned upon memory shortage. It is left to the
326 * caller to call appctx_set_applet() to assign an applet to this context.
327 */
328static inline struct appctx *si_alloc_appctx(struct stream_interface *si)
329{
330 struct appctx *appctx;
331
332 si_release_endpoint(si);
333 appctx = appctx_new();
334 if (appctx)
335 si_attach_appctx(si, appctx);
336
337 return appctx;
338}
339
Willy Tarreau73b013b2012-05-21 16:31:45 +0200340/* Sends a shutr to the connection using the data layer */
341static inline void si_shutr(struct stream_interface *si)
342{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200343 si->ops->shutr(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200344}
345
346/* Sends a shutw to the connection using the data layer */
347static inline void si_shutw(struct stream_interface *si)
348{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200349 si->ops->shutw(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200350}
351
352/* Calls the data state update on the stream interfaace */
353static inline void si_update(struct stream_interface *si)
354{
Willy Tarreauc5788912012-08-24 18:12:41 +0200355 si->ops->update(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200356}
357
358/* Calls chk_rcv on the connection using the data layer */
359static inline void si_chk_rcv(struct stream_interface *si)
360{
Willy Tarreauc5788912012-08-24 18:12:41 +0200361 si->ops->chk_rcv(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200362}
363
364/* Calls chk_snd on the connection using the data layer */
365static inline void si_chk_snd(struct stream_interface *si)
366{
Willy Tarreauc5788912012-08-24 18:12:41 +0200367 si->ops->chk_snd(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200368}
369
370/* Calls chk_snd on the connection using the ctrl layer */
371static inline int si_connect(struct stream_interface *si)
372{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200373 struct connection *conn = objt_conn(si->end);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200374 int ret = SF_ERR_NONE;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200375
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200376 if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect))
Willy Tarreaue7dff022015-04-03 01:14:29 +0200377 return SF_ERR_INTERNAL;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200378
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100379 if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) {
Willy Tarreau2bb4a962014-11-28 11:11:05 +0100380 ret = conn->ctrl->connect(conn, !channel_is_empty(si_oc(si)), 0);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200381 if (ret != SF_ERR_NONE)
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100382 return ret;
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100383
384 /* we need to be notified about connection establishment */
385 conn->flags |= CO_FL_WAKE_DATA;
386
387 /* we're in the process of establishing a connection */
388 si->state = SI_ST_CON;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100389 }
Willy Tarreau2bb4a962014-11-28 11:11:05 +0100390 else if (!channel_is_empty(si_oc(si))) {
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100391 /* reuse the existing connection, we'll have to send a
392 * request there.
393 */
394 conn_data_want_send(conn);
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100395
396 /* the connection is established */
397 si->state = SI_ST_EST;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100398 }
Willy Tarreau14f8e862012-08-30 22:23:13 +0200399
400 /* needs src ip/port for logging */
401 if (si->flags & SI_FL_SRC_ADDR)
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200402 conn_get_from_addr(conn);
Willy Tarreau14f8e862012-08-30 22:23:13 +0200403
Willy Tarreau14f8e862012-08-30 22:23:13 +0200404 return ret;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200405}
Willy Tarreau59b94792012-05-11 16:16:40 +0200406
Willy Tarreau55e4ecd2012-12-08 17:48:47 +0100407/* for debugging, reports the stream interface state name */
408static inline const char *si_state_str(int state)
409{
410 switch (state) {
411 case SI_ST_INI: return "INI";
412 case SI_ST_REQ: return "REQ";
413 case SI_ST_QUE: return "QUE";
414 case SI_ST_TAR: return "TAR";
415 case SI_ST_ASS: return "ASS";
416 case SI_ST_CON: return "CON";
417 case SI_ST_CER: return "CER";
418 case SI_ST_EST: return "EST";
419 case SI_ST_DIS: return "DIS";
420 case SI_ST_CLO: return "CLO";
421 default: return "???";
422 }
423}
424
Willy Tarreaucff64112008-11-03 06:26:53 +0100425#endif /* _PROTO_STREAM_INTERFACE_H */
426
427/*
428 * Local variables:
429 * c-indent-level: 8
430 * c-basic-offset: 8
431 * End:
432 */