blob: 70a323425de295c74051d927eece2206285e71fe [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 Tarreaudded32d2008-11-30 19:48:07 +010039void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg);
Willy Tarreau2c6be842012-07-06 17:12:34 +020040int conn_si_send_proxy(struct connection *conn, unsigned int flag);
Willy Tarreau9bf9c142012-08-20 15:38:41 +020041void stream_sock_read0(struct stream_interface *si);
Willy Tarreaucff64112008-11-03 06:26:53 +010042
Willy Tarreauc5788912012-08-24 18:12:41 +020043extern struct si_ops si_embedded_ops;
Willy Tarreauc5788912012-08-24 18:12:41 +020044extern struct si_ops si_conn_ops;
Willy Tarreaud45b9f82015-04-13 16:30:14 +020045extern struct si_ops si_applet_ops;
Willy Tarreau74beec32012-10-03 00:41:04 +020046extern struct data_cb si_conn_cb;
Willy Tarreau27375622013-12-17 00:00:28 +010047extern struct data_cb si_idle_conn_cb;
Willy Tarreau5c979a92012-05-07 17:15:39 +020048
Willy Tarreau30576452015-04-13 13:50:30 +020049struct appctx *stream_int_register_handler(struct stream_interface *si, struct applet *app);
Willy Tarreauaa977ba2015-09-25 11:45:06 +020050void si_applet_wake_cb(struct stream_interface *si);
Willy Tarreau25f13102015-09-24 11:32:22 +020051void stream_int_update(struct stream_interface *si);
Willy Tarreaucbc32602015-09-25 11:01:42 +020052void stream_int_update_conn(struct stream_interface *si);
53void stream_int_update_applet(struct stream_interface *si);
Willy Tarreau615f28b2015-09-23 18:40:09 +020054void stream_int_notify(struct stream_interface *si);
Willy Tarreaufb90d942009-09-05 20:57:35 +020055
Willy Tarreau2bb4a962014-11-28 11:11:05 +010056/* returns the channel which receives data from this stream interface (input channel) */
57static inline struct channel *si_ic(struct stream_interface *si)
58{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010059 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020060 return &LIST_ELEM(si, struct stream *, si[1])->res;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010061 else
Willy Tarreau87b09662015-04-03 00:22:06 +020062 return &LIST_ELEM(si, struct stream *, si[0])->req;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010063}
64
65/* returns the channel which feeds data to this stream interface (output channel) */
66static inline struct channel *si_oc(struct stream_interface *si)
67{
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010068 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020069 return &LIST_ELEM(si, struct stream *, si[1])->req;
Willy Tarreau0b2fb7f2014-11-28 11:50:38 +010070 else
Willy Tarreau87b09662015-04-03 00:22:06 +020071 return &LIST_ELEM(si, struct stream *, si[0])->res;
Willy Tarreau2bb4a962014-11-28 11:11:05 +010072}
73
Willy Tarreau4e4292b2014-11-28 12:18:45 +010074/* returns the buffer which receives data from this stream interface (input channel's buffer) */
75static inline struct buffer *si_ib(struct stream_interface *si)
76{
77 return si_ic(si)->buf;
78}
79
80/* returns the buffer which feeds data to this stream interface (output channel's buffer) */
81static inline struct buffer *si_ob(struct stream_interface *si)
82{
83 return si_oc(si)->buf;
84}
85
Willy Tarreau87b09662015-04-03 00:22:06 +020086/* returns the stream associated to a stream interface */
87static inline struct stream *si_strm(struct stream_interface *si)
Willy Tarreauaefd7902014-11-28 12:03:32 +010088{
89 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020090 return LIST_ELEM(si, struct stream *, si[1]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010091 else
Willy Tarreau87b09662015-04-03 00:22:06 +020092 return LIST_ELEM(si, struct stream *, si[0]);
Willy Tarreauaefd7902014-11-28 12:03:32 +010093}
94
Willy Tarreau07373b82014-11-28 12:08:47 +010095/* returns the task associated to this stream interface */
96static inline struct task *si_task(struct stream_interface *si)
97{
98 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +020099 return LIST_ELEM(si, struct stream *, si[1])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +0100100 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200101 return LIST_ELEM(si, struct stream *, si[0])->task;
Willy Tarreau07373b82014-11-28 12:08:47 +0100102}
103
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100104/* returns the stream interface on the other side. Used during forwarding. */
105static inline struct stream_interface *si_opposite(struct stream_interface *si)
106{
107 if (si->flags & SI_FL_ISBACK)
Willy Tarreau87b09662015-04-03 00:22:06 +0200108 return &LIST_ELEM(si, struct stream *, si[1])->si[0];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100109 else
Willy Tarreau87b09662015-04-03 00:22:06 +0200110 return &LIST_ELEM(si, struct stream *, si[0])->si[1];
Willy Tarreau50fe03b2014-11-28 13:59:31 +0100111}
112
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200113/* initializes a stream interface in the SI_ST_INI state. It's detached from
Willy Tarreau819d3322014-11-28 12:12:34 +0100114 * any endpoint and only keeps its side which is expected to have already been
115 * set.
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200116 */
Willy Tarreau819d3322014-11-28 12:12:34 +0100117static inline void si_reset(struct stream_interface *si)
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200118{
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200119 si->err_type = SI_ET_NONE;
120 si->conn_retries = 0; /* used for logging too */
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200121 si->exp = TICK_ETERNITY;
Willy Tarreaua5f5d8d2014-11-28 11:26:07 +0100122 si->flags &= SI_FL_ISBACK;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200123 si->end = NULL;
124 si->state = si->prev_state = SI_ST_INI;
Willy Tarreau7365dad2015-04-20 01:03:17 +0200125 si->ops = &si_embedded_ops;
Willy Tarreau3ed35ef2013-10-24 11:51:38 +0200126}
127
128/* sets the current and previous state of a stream interface to <state>. This
129 * is mainly used to create one in the established state on incoming
130 * conncetions.
131 */
132static inline void si_set_state(struct stream_interface *si, int state)
133{
134 si->state = si->prev_state = state;
135}
136
Willy Tarreau41b09f42015-08-04 20:44:05 +0200137/* only detaches the endpoint from the SI, which means that it's set to
138 * NULL and that ->ops is mapped to si_embedded_ops. The previous endpoint
139 * is returned.
140 */
141static inline enum obj_type *si_detach_endpoint(struct stream_interface *si)
142{
143 enum obj_type *prev = si->end;
144
145 si->end = NULL;
146 si->ops = &si_embedded_ops;
147 return prev;
148}
149
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100150/* Release the endpoint if it's a connection or an applet, then nullify it.
151 * Note: released connections are closed then freed.
152 */
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200153static inline void si_release_endpoint(struct stream_interface *si)
Willy Tarreau372d6702013-09-29 17:19:56 +0200154{
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200155 struct connection *conn;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100156 struct appctx *appctx;
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200157
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100158 if (!si->end)
159 return;
160
161 if ((conn = objt_conn(si->end))) {
Willy Tarreau323a2d92015-08-04 19:00:17 +0200162 LIST_DEL(&conn->list);
Willy Tarreau3b737c92017-10-22 09:39:11 +0200163 conn_stop_tracking(conn);
164 conn_full_close(conn);
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100165 conn_free(conn);
166 }
167 else if ((appctx = objt_appctx(si->end))) {
Willy Tarreau958f0742015-09-25 20:24:26 +0200168 if (appctx->applet->release && si->state < SI_ST_DIS)
Willy Tarreau00a37f02015-04-13 12:05:19 +0200169 appctx->applet->release(appctx);
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100170 appctx_free(appctx); /* we share the connection pool */
171 }
Willy Tarreau41b09f42015-08-04 20:44:05 +0200172 si_detach_endpoint(si);
Willy Tarreau372d6702013-09-29 17:19:56 +0200173}
174
Willy Tarreau4320eaa2015-08-05 11:08:30 +0200175/* Turn an existing connection endpoint of stream interface <si> to idle mode,
176 * which means that the connection will be polled for incoming events and might
177 * be killed by the underlying I/O handler. If <pool> is not null, the
178 * connection will also be added at the head of this list. This connection
179 * remains assigned to the stream interface it is currently attached to.
Willy Tarreau27375622013-12-17 00:00:28 +0100180 */
Willy Tarreau323a2d92015-08-04 19:00:17 +0200181static inline void si_idle_conn(struct stream_interface *si, struct list *pool)
Willy Tarreau27375622013-12-17 00:00:28 +0100182{
Willy Tarreau4320eaa2015-08-05 11:08:30 +0200183 struct connection *conn = __objt_conn(si->end);
Willy Tarreau27375622013-12-17 00:00:28 +0100184
Willy Tarreau323a2d92015-08-04 19:00:17 +0200185 if (pool)
186 LIST_ADD(pool, &conn->list);
187
Willy Tarreau27375622013-12-17 00:00:28 +0100188 conn_attach(conn, si, &si_idle_conn_cb);
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200189 conn_xprt_want_recv(conn);
Willy Tarreau27375622013-12-17 00:00:28 +0100190}
191
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200192/* Attach connection <conn> to the stream interface <si>. The stream interface
193 * is configured to work with a connection and the connection it configured
194 * with a stream interface data layer.
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200195 */
Willy Tarreau2a6e8802013-10-24 15:50:53 +0200196static inline void si_attach_conn(struct stream_interface *si, struct connection *conn)
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200197{
198 si->ops = &si_conn_ops;
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200199 si->end = &conn->obj_type;
Willy Tarreau7abddb52013-10-24 15:31:04 +0200200 conn_attach(conn, si, &si_conn_cb);
Willy Tarreaubd99aab2012-10-02 20:57:19 +0200201}
202
Willy Tarreaud02cdd22013-12-15 10:23:20 +0100203/* Returns true if a connection is attached to the stream interface <si> and
204 * if this connection is ready.
205 */
206static inline int si_conn_ready(struct stream_interface *si)
207{
208 struct connection *conn = objt_conn(si->end);
209
210 return conn && conn_ctrl_ready(conn) && conn_xprt_ready(conn);
211}
212
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100213/* Attach appctx <appctx> to the stream interface <si>. The stream interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200214 * is configured to work with an applet context.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100215 */
216static inline void si_attach_appctx(struct stream_interface *si, struct appctx *appctx)
Willy Tarreauc5788912012-08-24 18:12:41 +0200217{
Willy Tarreaud45b9f82015-04-13 16:30:14 +0200218 si->ops = &si_applet_ops;
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100219 si->end = &appctx->obj_type;
Willy Tarreau19c81612015-04-13 11:48:16 +0200220 appctx->owner = si;
Willy Tarreauc5788912012-08-24 18:12:41 +0200221}
222
Willy Tarreau7b4b4992013-12-01 09:15:12 +0100223/* returns a pointer to the appctx being run in the SI or NULL if none */
224static inline struct appctx *si_appctx(struct stream_interface *si)
225{
226 return objt_appctx(si->end);
227}
228
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200229/* call the applet's release function if any. Needs to be called upon close() */
230static inline void si_applet_release(struct stream_interface *si)
231{
Willy Tarreau00a37f02015-04-13 12:05:19 +0200232 struct appctx *appctx;
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200233
Willy Tarreau00a37f02015-04-13 12:05:19 +0200234 appctx = si_appctx(si);
Willy Tarreau958f0742015-09-25 20:24:26 +0200235 if (appctx && appctx->applet->release && si->state < SI_ST_DIS)
Willy Tarreau00a37f02015-04-13 12:05:19 +0200236 appctx->applet->release(appctx);
Willy Tarreau4a59f2f2013-10-24 20:10:45 +0200237}
238
Willy Tarreaueb406dc2015-04-21 18:44:02 +0200239/* let an applet indicate that it wants to put some data into the input buffer */
240static inline void si_applet_want_put(struct stream_interface *si)
241{
242 si->flags |= SI_FL_WANT_PUT;
243}
244
245/* let an applet indicate that it wanted to put some data into the input buffer
246 * but it couldn't.
247 */
248static inline void si_applet_cant_put(struct stream_interface *si)
249{
250 si->flags |= SI_FL_WANT_PUT | SI_FL_WAIT_ROOM;
251}
252
253/* let an applet indicate that it doesn't want to put data into the input buffer */
254static inline void si_applet_stop_put(struct stream_interface *si)
255{
256 si->flags &= ~SI_FL_WANT_PUT;
257}
258
259/* let an applet indicate that it wants to get some data from the output buffer */
260static inline void si_applet_want_get(struct stream_interface *si)
261{
262 si->flags |= SI_FL_WANT_GET;
263}
264
265/* let an applet indicate that it wanted to get some data from the output buffer
266 * but it couldn't.
267 */
268static inline void si_applet_cant_get(struct stream_interface *si)
269{
270 si->flags |= SI_FL_WANT_GET | SI_FL_WAIT_DATA;
271}
272
273/* let an applet indicate that it doesn't want to get data from the input buffer */
274static inline void si_applet_stop_get(struct stream_interface *si)
275{
276 si->flags &= ~SI_FL_WANT_GET;
277}
278
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100279/* Try to allocate a new connection and assign it to the interface. If
Willy Tarreau973a5422015-08-05 21:47:23 +0200280 * an endpoint was previously allocated, it is released first. The newly
281 * allocated connection is initialized, assigned to the stream interface,
282 * and returned.
Willy Tarreau9471b8c2013-12-15 13:31:35 +0100283 */
Willy Tarreau973a5422015-08-05 21:47:23 +0200284static inline struct connection *si_alloc_conn(struct stream_interface *si)
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200285{
286 struct connection *conn;
287
Willy Tarreau973a5422015-08-05 21:47:23 +0200288 si_release_endpoint(si);
Willy Tarreau32e3c6a2013-10-11 19:34:20 +0200289
290 conn = conn_new();
291 if (conn)
292 si_attach_conn(si, conn);
293
294 return conn;
295}
296
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100297/* Release the interface's existing endpoint (connection or appctx) and
298 * allocate then initialize a new appctx which is assigned to the interface
Willy Tarreaua7513f52015-04-05 00:15:26 +0200299 * and returned. NULL may be returned upon memory shortage. Applet <applet>
300 * is assigned to the appctx, but it may be NULL.
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100301 */
Willy Tarreau30576452015-04-13 13:50:30 +0200302static inline struct appctx *si_alloc_appctx(struct stream_interface *si, struct applet *applet)
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100303{
304 struct appctx *appctx;
305
306 si_release_endpoint(si);
Willy Tarreaua7513f52015-04-05 00:15:26 +0200307 appctx = appctx_new(applet);
Willy Tarreau0a23bcb2013-12-01 11:31:38 +0100308 if (appctx)
309 si_attach_appctx(si, appctx);
310
311 return appctx;
312}
313
Willy Tarreau73b013b2012-05-21 16:31:45 +0200314/* Sends a shutr to the connection using the data layer */
315static inline void si_shutr(struct stream_interface *si)
316{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200317 si->ops->shutr(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200318}
319
320/* Sends a shutw to the connection using the data layer */
321static inline void si_shutw(struct stream_interface *si)
322{
Willy Tarreau6fe15412013-09-29 15:16:03 +0200323 si->ops->shutw(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200324}
325
Willy Tarreau5d5b2fe2015-09-25 10:59:38 +0200326/* Updates the stream interface and timers, then updates the data layer below */
Willy Tarreau73b013b2012-05-21 16:31:45 +0200327static inline void si_update(struct stream_interface *si)
328{
Willy Tarreau5d5b2fe2015-09-25 10:59:38 +0200329 stream_int_update(si);
Willy Tarreau33552032015-09-24 18:05:45 +0200330 if (si->ops->update)
331 si->ops->update(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200332}
333
334/* Calls chk_rcv on the connection using the data layer */
335static inline void si_chk_rcv(struct stream_interface *si)
336{
Willy Tarreauc5788912012-08-24 18:12:41 +0200337 si->ops->chk_rcv(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200338}
339
340/* Calls chk_snd on the connection using the data layer */
341static inline void si_chk_snd(struct stream_interface *si)
342{
Willy Tarreauc5788912012-08-24 18:12:41 +0200343 si->ops->chk_snd(si);
Willy Tarreau73b013b2012-05-21 16:31:45 +0200344}
345
346/* Calls chk_snd on the connection using the ctrl layer */
347static inline int si_connect(struct stream_interface *si)
348{
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200349 struct connection *conn = objt_conn(si->end);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200350 int ret = SF_ERR_NONE;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200351
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200352 if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect))
Willy Tarreaue7dff022015-04-03 01:14:29 +0200353 return SF_ERR_INTERNAL;
Willy Tarreau14f8e862012-08-30 22:23:13 +0200354
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100355 if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) {
Willy Tarreau2bb4a962014-11-28 11:11:05 +0100356 ret = conn->ctrl->connect(conn, !channel_is_empty(si_oc(si)), 0);
Willy Tarreaue7dff022015-04-03 01:14:29 +0200357 if (ret != SF_ERR_NONE)
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100358 return ret;
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100359
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100360 /* we're in the process of establishing a connection */
361 si->state = SI_ST_CON;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100362 }
Christopher Fauletc34d19f2015-12-23 09:33:35 +0100363 else {
364 /* reuse the existing connection */
365 if (!channel_is_empty(si_oc(si))) {
366 /* we'll have to send a request there. */
Olivier Houchard1a0545f2017-09-13 18:30:23 +0200367 conn_xprt_want_send(conn);
Christopher Fauletc34d19f2015-12-23 09:33:35 +0100368 }
Willy Tarreau9e5a3aa2013-12-31 23:32:12 +0100369
370 /* the connection is established */
371 si->state = SI_ST_EST;
Willy Tarreaub490b4e2013-12-15 16:20:50 +0100372 }
Willy Tarreau14f8e862012-08-30 22:23:13 +0200373
374 /* needs src ip/port for logging */
375 if (si->flags & SI_FL_SRC_ADDR)
Willy Tarreaub363a1f2013-10-01 10:45:07 +0200376 conn_get_from_addr(conn);
Willy Tarreau14f8e862012-08-30 22:23:13 +0200377
Willy Tarreau14f8e862012-08-30 22:23:13 +0200378 return ret;
Willy Tarreau73b013b2012-05-21 16:31:45 +0200379}
Willy Tarreau59b94792012-05-11 16:16:40 +0200380
Willy Tarreau55e4ecd2012-12-08 17:48:47 +0100381/* for debugging, reports the stream interface state name */
382static inline const char *si_state_str(int state)
383{
384 switch (state) {
385 case SI_ST_INI: return "INI";
386 case SI_ST_REQ: return "REQ";
387 case SI_ST_QUE: return "QUE";
388 case SI_ST_TAR: return "TAR";
389 case SI_ST_ASS: return "ASS";
390 case SI_ST_CON: return "CON";
391 case SI_ST_CER: return "CER";
392 case SI_ST_EST: return "EST";
393 case SI_ST_DIS: return "DIS";
394 case SI_ST_CLO: return "CLO";
395 default: return "???";
396 }
397}
398
Willy Tarreaucff64112008-11-03 06:26:53 +0100399#endif /* _PROTO_STREAM_INTERFACE_H */
400
401/*
402 * Local variables:
403 * c-indent-level: 8
404 * c-basic-offset: 8
405 * End:
406 */