Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 1 | /* |
Willy Tarreau | 5e539c9 | 2020-06-04 20:45:39 +0200 | [diff] [blame] | 2 | * include/haproxy/stream_interface.h |
Willy Tarreau | 8e89b84 | 2009-10-18 23:56:35 +0200 | [diff] [blame] | 3 | * This file contains stream_interface function prototypes |
| 4 | * |
Willy Tarreau | 2bb4a96 | 2014-11-28 11:11:05 +0100 | [diff] [blame] | 5 | * Copyright (C) 2000-2014 Willy Tarreau - w@1wt.eu |
Willy Tarreau | 8e89b84 | 2009-10-18 23:56:35 +0200 | [diff] [blame] | 6 | * |
| 7 | * This library is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU Lesser General Public |
| 9 | * License as published by the Free Software Foundation, version 2.1 |
| 10 | * exclusively. |
| 11 | * |
| 12 | * This library is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * Lesser General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU Lesser General Public |
| 18 | * License along with this library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | */ |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 21 | |
Willy Tarreau | 5e539c9 | 2020-06-04 20:45:39 +0200 | [diff] [blame] | 22 | #ifndef _HAPROXY_STREAM_INTERFACE_H |
| 23 | #define _HAPROXY_STREAM_INTERFACE_H |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 24 | |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 25 | #include <haproxy/api.h> |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 26 | #include <haproxy/applet.h> |
Willy Tarreau | f1d32c4 | 2020-06-04 21:07:02 +0200 | [diff] [blame] | 27 | #include <haproxy/channel.h> |
Willy Tarreau | 7ea393d | 2020-06-04 18:02:10 +0200 | [diff] [blame] | 28 | #include <haproxy/connection.h> |
Willy Tarreau | dfd3de8 | 2020-06-04 23:46:14 +0200 | [diff] [blame] | 29 | #include <haproxy/stream-t.h> |
Willy Tarreau | 5e539c9 | 2020-06-04 20:45:39 +0200 | [diff] [blame] | 30 | #include <haproxy/stream_interface-t.h> |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 31 | |
| 32 | |
Willy Tarreau | c578891 | 2012-08-24 18:12:41 +0200 | [diff] [blame] | 33 | extern struct si_ops si_embedded_ops; |
Willy Tarreau | c578891 | 2012-08-24 18:12:41 +0200 | [diff] [blame] | 34 | extern struct si_ops si_conn_ops; |
Willy Tarreau | d45b9f8 | 2015-04-13 16:30:14 +0200 | [diff] [blame] | 35 | extern struct si_ops si_applet_ops; |
Willy Tarreau | 74beec3 | 2012-10-03 00:41:04 +0200 | [diff] [blame] | 36 | extern struct data_cb si_conn_cb; |
Willy Tarreau | 5c979a9 | 2012-05-07 17:15:39 +0200 | [diff] [blame] | 37 | |
Willy Tarreau | 14bfe9a | 2018-12-19 15:19:27 +0100 | [diff] [blame] | 38 | /* main event functions used to move data between sockets and buffers */ |
| 39 | int si_check_timeouts(struct stream_interface *si); |
| 40 | void si_report_error(struct stream_interface *si); |
| 41 | void si_retnclose(struct stream_interface *si, const struct buffer *msg); |
| 42 | int conn_si_send_proxy(struct connection *conn, unsigned int flag); |
| 43 | struct appctx *si_register_handler(struct stream_interface *si, struct applet *app); |
Willy Tarreau | aa977ba | 2015-09-25 11:45:06 +0200 | [diff] [blame] | 44 | void si_applet_wake_cb(struct stream_interface *si); |
Willy Tarreau | 236c429 | 2019-06-06 08:19:20 +0200 | [diff] [blame] | 45 | void si_update_rx(struct stream_interface *si); |
| 46 | void si_update_tx(struct stream_interface *si); |
Olivier Houchard | 0e367bb | 2018-09-14 19:41:13 +0200 | [diff] [blame] | 47 | int si_cs_recv(struct conn_stream *cs); |
Olivier Houchard | 91894cb | 2018-08-02 18:06:28 +0200 | [diff] [blame] | 48 | struct task *si_cs_io_cb(struct task *t, void *ctx, unsigned short state); |
Willy Tarreau | d14844a | 2018-11-08 18:15:29 +0100 | [diff] [blame] | 49 | void si_update_both(struct stream_interface *si_f, struct stream_interface *si_b); |
Willy Tarreau | 3b285d7 | 2019-06-06 08:20:17 +0200 | [diff] [blame] | 50 | void si_sync_send(struct stream_interface *si); |
Willy Tarreau | fb90d94 | 2009-09-05 20:57:35 +0200 | [diff] [blame] | 51 | |
Willy Tarreau | 2bb4a96 | 2014-11-28 11:11:05 +0100 | [diff] [blame] | 52 | /* returns the channel which receives data from this stream interface (input channel) */ |
| 53 | static inline struct channel *si_ic(struct stream_interface *si) |
| 54 | { |
Willy Tarreau | 0b2fb7f | 2014-11-28 11:50:38 +0100 | [diff] [blame] | 55 | if (si->flags & SI_FL_ISBACK) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 56 | return &LIST_ELEM(si, struct stream *, si[1])->res; |
Willy Tarreau | 0b2fb7f | 2014-11-28 11:50:38 +0100 | [diff] [blame] | 57 | else |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 58 | return &LIST_ELEM(si, struct stream *, si[0])->req; |
Willy Tarreau | 2bb4a96 | 2014-11-28 11:11:05 +0100 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | /* returns the channel which feeds data to this stream interface (output channel) */ |
| 62 | static inline struct channel *si_oc(struct stream_interface *si) |
| 63 | { |
Willy Tarreau | 0b2fb7f | 2014-11-28 11:50:38 +0100 | [diff] [blame] | 64 | if (si->flags & SI_FL_ISBACK) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 65 | return &LIST_ELEM(si, struct stream *, si[1])->req; |
Willy Tarreau | 0b2fb7f | 2014-11-28 11:50:38 +0100 | [diff] [blame] | 66 | else |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 67 | return &LIST_ELEM(si, struct stream *, si[0])->res; |
Willy Tarreau | 2bb4a96 | 2014-11-28 11:11:05 +0100 | [diff] [blame] | 68 | } |
| 69 | |
Willy Tarreau | 4e4292b | 2014-11-28 12:18:45 +0100 | [diff] [blame] | 70 | /* returns the buffer which receives data from this stream interface (input channel's buffer) */ |
| 71 | static inline struct buffer *si_ib(struct stream_interface *si) |
| 72 | { |
Willy Tarreau | c9fa048 | 2018-07-10 17:43:27 +0200 | [diff] [blame] | 73 | return &si_ic(si)->buf; |
Willy Tarreau | 4e4292b | 2014-11-28 12:18:45 +0100 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | /* returns the buffer which feeds data to this stream interface (output channel's buffer) */ |
| 77 | static inline struct buffer *si_ob(struct stream_interface *si) |
| 78 | { |
Willy Tarreau | c9fa048 | 2018-07-10 17:43:27 +0200 | [diff] [blame] | 79 | return &si_oc(si)->buf; |
Willy Tarreau | 4e4292b | 2014-11-28 12:18:45 +0100 | [diff] [blame] | 80 | } |
| 81 | |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 82 | /* returns the stream associated to a stream interface */ |
| 83 | static inline struct stream *si_strm(struct stream_interface *si) |
Willy Tarreau | aefd790 | 2014-11-28 12:03:32 +0100 | [diff] [blame] | 84 | { |
| 85 | if (si->flags & SI_FL_ISBACK) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 86 | return LIST_ELEM(si, struct stream *, si[1]); |
Willy Tarreau | aefd790 | 2014-11-28 12:03:32 +0100 | [diff] [blame] | 87 | else |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 88 | return LIST_ELEM(si, struct stream *, si[0]); |
Willy Tarreau | aefd790 | 2014-11-28 12:03:32 +0100 | [diff] [blame] | 89 | } |
| 90 | |
Willy Tarreau | 07373b8 | 2014-11-28 12:08:47 +0100 | [diff] [blame] | 91 | /* returns the task associated to this stream interface */ |
| 92 | static inline struct task *si_task(struct stream_interface *si) |
| 93 | { |
| 94 | if (si->flags & SI_FL_ISBACK) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 95 | return LIST_ELEM(si, struct stream *, si[1])->task; |
Willy Tarreau | 07373b8 | 2014-11-28 12:08:47 +0100 | [diff] [blame] | 96 | else |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 97 | return LIST_ELEM(si, struct stream *, si[0])->task; |
Willy Tarreau | 07373b8 | 2014-11-28 12:08:47 +0100 | [diff] [blame] | 98 | } |
| 99 | |
Willy Tarreau | 50fe03b | 2014-11-28 13:59:31 +0100 | [diff] [blame] | 100 | /* returns the stream interface on the other side. Used during forwarding. */ |
| 101 | static inline struct stream_interface *si_opposite(struct stream_interface *si) |
| 102 | { |
| 103 | if (si->flags & SI_FL_ISBACK) |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 104 | return &LIST_ELEM(si, struct stream *, si[1])->si[0]; |
Willy Tarreau | 50fe03b | 2014-11-28 13:59:31 +0100 | [diff] [blame] | 105 | else |
Willy Tarreau | 87b0966 | 2015-04-03 00:22:06 +0200 | [diff] [blame] | 106 | return &LIST_ELEM(si, struct stream *, si[0])->si[1]; |
Willy Tarreau | 50fe03b | 2014-11-28 13:59:31 +0100 | [diff] [blame] | 107 | } |
| 108 | |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 109 | /* initializes a stream interface in the SI_ST_INI state. It's detached from |
Willy Tarreau | 819d332 | 2014-11-28 12:12:34 +0100 | [diff] [blame] | 110 | * any endpoint and only keeps its side which is expected to have already been |
| 111 | * set. |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 112 | */ |
Olivier Houchard | 8f0b4c6 | 2018-08-02 18:21:38 +0200 | [diff] [blame] | 113 | static inline int si_reset(struct stream_interface *si) |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 114 | { |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 115 | si->err_type = SI_ET_NONE; |
| 116 | si->conn_retries = 0; /* used for logging too */ |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 117 | si->exp = TICK_ETERNITY; |
Willy Tarreau | a5f5d8d | 2014-11-28 11:26:07 +0100 | [diff] [blame] | 118 | si->flags &= SI_FL_ISBACK; |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 119 | si->end = NULL; |
| 120 | si->state = si->prev_state = SI_ST_INI; |
Willy Tarreau | 7365dad | 2015-04-20 01:03:17 +0200 | [diff] [blame] | 121 | si->ops = &si_embedded_ops; |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 122 | si->wait_event.tasklet = tasklet_new(); |
| 123 | if (!si->wait_event.tasklet) |
Olivier Houchard | 8f0b4c6 | 2018-08-02 18:21:38 +0200 | [diff] [blame] | 124 | return -1; |
Willy Tarreau | 3c39a7d | 2019-06-14 14:42:29 +0200 | [diff] [blame] | 125 | si->wait_event.tasklet->process = si_cs_io_cb; |
| 126 | si->wait_event.tasklet->context = si; |
Willy Tarreau | 4f6516d | 2018-12-19 13:59:17 +0100 | [diff] [blame] | 127 | si->wait_event.events = 0; |
Olivier Houchard | 8f0b4c6 | 2018-08-02 18:21:38 +0200 | [diff] [blame] | 128 | return 0; |
Willy Tarreau | 3ed35ef | 2013-10-24 11:51:38 +0200 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | /* sets the current and previous state of a stream interface to <state>. This |
| 132 | * is mainly used to create one in the established state on incoming |
| 133 | * conncetions. |
| 134 | */ |
| 135 | static inline void si_set_state(struct stream_interface *si, int state) |
| 136 | { |
| 137 | si->state = si->prev_state = state; |
| 138 | } |
| 139 | |
Willy Tarreau | bedcd69 | 2019-06-05 14:45:06 +0200 | [diff] [blame] | 140 | /* returns a bit for a stream-int state, to match against SI_SB_* */ |
| 141 | static inline enum si_state_bit si_state_bit(enum si_state state) |
| 142 | { |
Willy Tarreau | ad660e3 | 2019-06-06 16:38:40 +0200 | [diff] [blame] | 143 | BUG_ON(state > SI_ST_CLO); |
Willy Tarreau | bedcd69 | 2019-06-05 14:45:06 +0200 | [diff] [blame] | 144 | return 1U << state; |
| 145 | } |
| 146 | |
| 147 | /* returns true if <state> matches one of the SI_SB_* bits in <mask> */ |
| 148 | static inline int si_state_in(enum si_state state, enum si_state_bit mask) |
| 149 | { |
| 150 | BUG_ON(mask & ~SI_SB_ALL); |
| 151 | return !!(si_state_bit(state) & mask); |
| 152 | } |
| 153 | |
Willy Tarreau | 41b09f4 | 2015-08-04 20:44:05 +0200 | [diff] [blame] | 154 | /* only detaches the endpoint from the SI, which means that it's set to |
| 155 | * NULL and that ->ops is mapped to si_embedded_ops. The previous endpoint |
| 156 | * is returned. |
| 157 | */ |
| 158 | static inline enum obj_type *si_detach_endpoint(struct stream_interface *si) |
| 159 | { |
| 160 | enum obj_type *prev = si->end; |
| 161 | |
| 162 | si->end = NULL; |
| 163 | si->ops = &si_embedded_ops; |
| 164 | return prev; |
| 165 | } |
| 166 | |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 167 | /* Release the endpoint if it's a connection or an applet, then nullify it. |
| 168 | * Note: released connections are closed then freed. |
| 169 | */ |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 170 | static inline void si_release_endpoint(struct stream_interface *si) |
Willy Tarreau | 372d670 | 2013-09-29 17:19:56 +0200 | [diff] [blame] | 171 | { |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 172 | struct conn_stream *cs; |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 173 | struct appctx *appctx; |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 174 | |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 175 | if (!si->end) |
| 176 | return; |
| 177 | |
Olivier Houchard | 4fdec7a | 2018-10-11 17:09:14 +0200 | [diff] [blame] | 178 | if ((cs = objt_cs(si->end))) { |
Willy Tarreau | 4f6516d | 2018-12-19 13:59:17 +0100 | [diff] [blame] | 179 | if (si->wait_event.events != 0) |
| 180 | cs->conn->mux->unsubscribe(cs, si->wait_event.events, |
Olivier Houchard | 4fdec7a | 2018-10-11 17:09:14 +0200 | [diff] [blame] | 181 | &si->wait_event); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 182 | cs_destroy(cs); |
Olivier Houchard | 4fdec7a | 2018-10-11 17:09:14 +0200 | [diff] [blame] | 183 | } |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 184 | else if ((appctx = objt_appctx(si->end))) { |
Willy Tarreau | 7ab22adb | 2019-06-05 14:53:22 +0200 | [diff] [blame] | 185 | if (appctx->applet->release && !si_state_in(si->state, SI_SB_DIS|SI_SB_CLO)) |
Willy Tarreau | 00a37f0 | 2015-04-13 12:05:19 +0200 | [diff] [blame] | 186 | appctx->applet->release(appctx); |
Willy Tarreau | 8280ea9 | 2019-07-18 10:41:36 +0200 | [diff] [blame] | 187 | appctx_free(appctx); |
Olivier Houchard | 8ab8a6e | 2018-12-19 23:21:46 +0100 | [diff] [blame] | 188 | } |
Willy Tarreau | 41b09f4 | 2015-08-04 20:44:05 +0200 | [diff] [blame] | 189 | si_detach_endpoint(si); |
Willy Tarreau | 372d670 | 2013-09-29 17:19:56 +0200 | [diff] [blame] | 190 | } |
| 191 | |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 192 | /* Attach conn_stream <cs> to the stream interface <si>. The stream interface |
Willy Tarreau | 2a6e880 | 2013-10-24 15:50:53 +0200 | [diff] [blame] | 193 | * is configured to work with a connection and the connection it configured |
| 194 | * with a stream interface data layer. |
Willy Tarreau | b363a1f | 2013-10-01 10:45:07 +0200 | [diff] [blame] | 195 | */ |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 196 | static inline void si_attach_cs(struct stream_interface *si, struct conn_stream *cs) |
Willy Tarreau | bd99aab | 2012-10-02 20:57:19 +0200 | [diff] [blame] | 197 | { |
| 198 | si->ops = &si_conn_ops; |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 199 | si->end = &cs->obj_type; |
| 200 | cs_attach(cs, si, &si_conn_cb); |
Willy Tarreau | bd99aab | 2012-10-02 20:57:19 +0200 | [diff] [blame] | 201 | } |
| 202 | |
Willy Tarreau | d02cdd2 | 2013-12-15 10:23:20 +0100 | [diff] [blame] | 203 | /* Returns true if a connection is attached to the stream interface <si> and |
| 204 | * if this connection is ready. |
| 205 | */ |
| 206 | static inline int si_conn_ready(struct stream_interface *si) |
| 207 | { |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 208 | struct connection *conn = cs_conn(objt_cs(si->end)); |
Willy Tarreau | d02cdd2 | 2013-12-15 10:23:20 +0100 | [diff] [blame] | 209 | |
| 210 | return conn && conn_ctrl_ready(conn) && conn_xprt_ready(conn); |
| 211 | } |
| 212 | |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 213 | /* Attach appctx <appctx> to the stream interface <si>. The stream interface |
Willy Tarreau | a7513f5 | 2015-04-05 00:15:26 +0200 | [diff] [blame] | 214 | * is configured to work with an applet context. |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 215 | */ |
| 216 | static inline void si_attach_appctx(struct stream_interface *si, struct appctx *appctx) |
Willy Tarreau | c578891 | 2012-08-24 18:12:41 +0200 | [diff] [blame] | 217 | { |
Willy Tarreau | d45b9f8 | 2015-04-13 16:30:14 +0200 | [diff] [blame] | 218 | si->ops = &si_applet_ops; |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 219 | si->end = &appctx->obj_type; |
Willy Tarreau | 19c8161 | 2015-04-13 11:48:16 +0200 | [diff] [blame] | 220 | appctx->owner = si; |
Willy Tarreau | c578891 | 2012-08-24 18:12:41 +0200 | [diff] [blame] | 221 | } |
| 222 | |
Willy Tarreau | 4ae4923 | 2018-09-20 11:08:47 +0200 | [diff] [blame] | 223 | /* returns a pointer to the appctx being run in the SI, which must be valid */ |
Willy Tarreau | 7b4b499 | 2013-12-01 09:15:12 +0100 | [diff] [blame] | 224 | static inline struct appctx *si_appctx(struct stream_interface *si) |
| 225 | { |
Willy Tarreau | 4ae4923 | 2018-09-20 11:08:47 +0200 | [diff] [blame] | 226 | return __objt_appctx(si->end); |
Willy Tarreau | 7b4b499 | 2013-12-01 09:15:12 +0100 | [diff] [blame] | 227 | } |
| 228 | |
Willy Tarreau | 4a59f2f | 2013-10-24 20:10:45 +0200 | [diff] [blame] | 229 | /* call the applet's release function if any. Needs to be called upon close() */ |
| 230 | static inline void si_applet_release(struct stream_interface *si) |
| 231 | { |
Willy Tarreau | 00a37f0 | 2015-04-13 12:05:19 +0200 | [diff] [blame] | 232 | struct appctx *appctx; |
Willy Tarreau | 4a59f2f | 2013-10-24 20:10:45 +0200 | [diff] [blame] | 233 | |
Willy Tarreau | 4ae4923 | 2018-09-20 11:08:47 +0200 | [diff] [blame] | 234 | appctx = objt_appctx(si->end); |
Willy Tarreau | 7ab22adb | 2019-06-05 14:53:22 +0200 | [diff] [blame] | 235 | if (appctx && appctx->applet->release && !si_state_in(si->state, SI_SB_DIS|SI_SB_CLO)) |
Willy Tarreau | 00a37f0 | 2015-04-13 12:05:19 +0200 | [diff] [blame] | 236 | appctx->applet->release(appctx); |
Willy Tarreau | 4a59f2f | 2013-10-24 20:10:45 +0200 | [diff] [blame] | 237 | } |
| 238 | |
Willy Tarreau | 78dcace | 2018-11-14 14:01:40 +0100 | [diff] [blame] | 239 | /* Returns non-zero if the stream interface's Rx path is blocked */ |
| 240 | static inline int si_rx_blocked(const struct stream_interface *si) |
| 241 | { |
| 242 | return !!(si->flags & SI_FL_RXBLK_ANY); |
| 243 | } |
| 244 | |
| 245 | /* Returns non-zero if the stream interface's endpoint is ready to receive */ |
| 246 | static inline int si_rx_endp_ready(const struct stream_interface *si) |
| 247 | { |
| 248 | return !(si->flags & SI_FL_RX_WAIT_EP); |
| 249 | } |
| 250 | |
Willy Tarreau | 8bb2ffb | 2018-11-14 17:54:13 +0100 | [diff] [blame] | 251 | /* The stream interface announces it is ready to try to deliver more data to the input buffer */ |
| 252 | static inline void si_rx_endp_more(struct stream_interface *si) |
Willy Tarreau | 394970c | 2018-11-06 19:17:31 +0100 | [diff] [blame] | 253 | { |
Willy Tarreau | 8bb2ffb | 2018-11-14 17:54:13 +0100 | [diff] [blame] | 254 | si->flags &= ~SI_FL_RX_WAIT_EP; |
| 255 | } |
| 256 | |
| 257 | /* The stream interface announces it doesn't have more data for the input buffer */ |
| 258 | static inline void si_rx_endp_done(struct stream_interface *si) |
| 259 | { |
Willy Tarreau | 05b9b64 | 2018-11-14 13:43:35 +0100 | [diff] [blame] | 260 | si->flags |= SI_FL_RX_WAIT_EP; |
Willy Tarreau | 394970c | 2018-11-06 19:17:31 +0100 | [diff] [blame] | 261 | } |
| 262 | |
Willy Tarreau | b26a6f9 | 2018-11-14 17:10:36 +0100 | [diff] [blame] | 263 | /* Tell a stream interface the input channel is OK with it sending it some data */ |
| 264 | static inline void si_rx_chan_rdy(struct stream_interface *si) |
| 265 | { |
| 266 | si->flags &= ~SI_FL_RXBLK_CHAN; |
| 267 | } |
| 268 | |
| 269 | /* Tell a stream interface the input channel is not OK with it sending it some data */ |
| 270 | static inline void si_rx_chan_blk(struct stream_interface *si) |
| 271 | { |
| 272 | si->flags |= SI_FL_RXBLK_CHAN; |
| 273 | } |
| 274 | |
Willy Tarreau | a3b62d3 | 2018-12-06 15:24:01 +0100 | [diff] [blame] | 275 | /* Tell a stream interface the other side is connected */ |
| 276 | static inline void si_rx_conn_rdy(struct stream_interface *si) |
| 277 | { |
| 278 | si->flags &= ~SI_FL_RXBLK_CONN; |
| 279 | } |
| 280 | |
| 281 | /* Tell a stream interface it must wait for the other side to connect */ |
| 282 | static inline void si_rx_conn_blk(struct stream_interface *si) |
| 283 | { |
| 284 | si->flags |= SI_FL_RXBLK_CONN; |
| 285 | } |
| 286 | |
Willy Tarreau | 8be7cd7 | 2018-11-14 15:12:08 +0100 | [diff] [blame] | 287 | /* The stream interface just got the input buffer it was waiting for */ |
| 288 | static inline void si_rx_buff_rdy(struct stream_interface *si) |
| 289 | { |
| 290 | si->flags &= ~SI_FL_RXBLK_BUFF; |
| 291 | } |
| 292 | |
| 293 | /* The stream interface failed to get an input buffer and is waiting for it. |
| 294 | * Since it indicates a willingness to deliver data to the buffer that will |
| 295 | * have to be retried, we automatically clear RXBLK_ENDP to be called again |
| 296 | * as soon as RXBLK_BUFF is cleared. |
| 297 | */ |
| 298 | static inline void si_rx_buff_blk(struct stream_interface *si) |
| 299 | { |
| 300 | si->flags |= SI_FL_RXBLK_BUFF; |
| 301 | } |
| 302 | |
Willy Tarreau | db39843 | 2018-11-15 11:08:52 +0100 | [diff] [blame] | 303 | /* Tell a stream interface some room was made in the input buffer */ |
| 304 | static inline void si_rx_room_rdy(struct stream_interface *si) |
| 305 | { |
| 306 | si->flags &= ~SI_FL_RXBLK_ROOM; |
| 307 | } |
| 308 | |
| 309 | /* The stream interface announces it failed to put data into the input buffer |
| 310 | * by lack of room. Since it indicates a willingness to deliver data to the |
| 311 | * buffer that will have to be retried, we automatically clear RXBLK_ENDP to |
| 312 | * be called again as soon as RXBLK_ROOM is cleared. |
| 313 | */ |
| 314 | static inline void si_rx_room_blk(struct stream_interface *si) |
| 315 | { |
| 316 | si->flags |= SI_FL_RXBLK_ROOM; |
| 317 | } |
| 318 | |
Willy Tarreau | abb5d42 | 2018-11-14 16:58:52 +0100 | [diff] [blame] | 319 | /* The stream interface announces it will never put new data into the input |
| 320 | * buffer and that it's not waiting for its endpoint to deliver anything else. |
| 321 | * This function obviously doesn't have a _rdy equivalent. |
| 322 | */ |
| 323 | static inline void si_rx_shut_blk(struct stream_interface *si) |
| 324 | { |
| 325 | si->flags |= SI_FL_RXBLK_SHUT; |
| 326 | } |
| 327 | |
Willy Tarreau | 78dcace | 2018-11-14 14:01:40 +0100 | [diff] [blame] | 328 | /* Returns non-zero if the stream interface's Rx path is blocked */ |
| 329 | static inline int si_tx_blocked(const struct stream_interface *si) |
| 330 | { |
| 331 | return !!(si->flags & SI_FL_WAIT_DATA); |
| 332 | } |
| 333 | |
| 334 | /* Returns non-zero if the stream interface's endpoint is ready to transmit */ |
| 335 | static inline int si_tx_endp_ready(const struct stream_interface *si) |
| 336 | { |
| 337 | return (si->flags & SI_FL_WANT_GET); |
| 338 | } |
| 339 | |
Willy Tarreau | 0cd3bd6 | 2018-11-06 18:46:37 +0100 | [diff] [blame] | 340 | /* Report that a stream interface wants to get some data from the output buffer */ |
| 341 | static inline void si_want_get(struct stream_interface *si) |
Willy Tarreau | eb406dc | 2015-04-21 18:44:02 +0200 | [diff] [blame] | 342 | { |
| 343 | si->flags |= SI_FL_WANT_GET; |
| 344 | } |
| 345 | |
Willy Tarreau | 0cd3bd6 | 2018-11-06 18:46:37 +0100 | [diff] [blame] | 346 | /* Report that a stream interface failed to get some data from the output buffer */ |
| 347 | static inline void si_cant_get(struct stream_interface *si) |
Willy Tarreau | eb406dc | 2015-04-21 18:44:02 +0200 | [diff] [blame] | 348 | { |
| 349 | si->flags |= SI_FL_WANT_GET | SI_FL_WAIT_DATA; |
| 350 | } |
| 351 | |
Willy Tarreau | 0cd3bd6 | 2018-11-06 18:46:37 +0100 | [diff] [blame] | 352 | /* Report that a stream interface doesn't want to get data from the output buffer */ |
| 353 | static inline void si_stop_get(struct stream_interface *si) |
Willy Tarreau | eb406dc | 2015-04-21 18:44:02 +0200 | [diff] [blame] | 354 | { |
| 355 | si->flags &= ~SI_FL_WANT_GET; |
| 356 | } |
| 357 | |
Willy Tarreau | 394970c | 2018-11-06 19:17:31 +0100 | [diff] [blame] | 358 | /* Report that a stream interface won't get any more data from the output buffer */ |
| 359 | static inline void si_done_get(struct stream_interface *si) |
| 360 | { |
| 361 | si->flags &= ~(SI_FL_WANT_GET | SI_FL_WAIT_DATA); |
| 362 | } |
| 363 | |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 364 | /* Try to allocate a new conn_stream and assign it to the interface. If |
Willy Tarreau | 973a542 | 2015-08-05 21:47:23 +0200 | [diff] [blame] | 365 | * an endpoint was previously allocated, it is released first. The newly |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 366 | * allocated conn_stream is initialized, assigned to the stream interface, |
Willy Tarreau | 973a542 | 2015-08-05 21:47:23 +0200 | [diff] [blame] | 367 | * and returned. |
Willy Tarreau | 9471b8c | 2013-12-15 13:31:35 +0100 | [diff] [blame] | 368 | */ |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 369 | static inline struct conn_stream *si_alloc_cs(struct stream_interface *si, struct connection *conn) |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 370 | { |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 371 | struct conn_stream *cs; |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 372 | |
Willy Tarreau | 973a542 | 2015-08-05 21:47:23 +0200 | [diff] [blame] | 373 | si_release_endpoint(si); |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 374 | |
Christopher Faulet | 236c93b | 2020-07-02 09:19:54 +0200 | [diff] [blame] | 375 | cs = cs_new(conn, conn->target); |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 376 | if (cs) |
| 377 | si_attach_cs(si, cs); |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 378 | |
Olivier Houchard | 9aaf778 | 2017-09-13 18:30:23 +0200 | [diff] [blame] | 379 | return cs; |
Willy Tarreau | 32e3c6a | 2013-10-11 19:34:20 +0200 | [diff] [blame] | 380 | } |
| 381 | |
Willy Tarreau | 0979916 | 2018-10-25 10:16:07 +0200 | [diff] [blame] | 382 | /* Try to allocate a buffer for the stream-int's input channel. It relies on |
Willy Tarreau | abf531c | 2018-11-07 18:53:29 +0100 | [diff] [blame] | 383 | * channel_alloc_buffer() for this so it abides by its rules. It returns 0 on |
| 384 | * failure, non-zero otherwise. If no buffer is available, the requester, |
Willy Tarreau | 8be7cd7 | 2018-11-14 15:12:08 +0100 | [diff] [blame] | 385 | * represented by the <wait> pointer, will be added in the list of objects |
| 386 | * waiting for an available buffer, and SI_FL_RXBLK_BUFF will be set on the |
| 387 | * stream-int and SI_FL_RX_WAIT_EP cleared. The requester will be responsible |
| 388 | * for calling this function to try again once woken up. |
Willy Tarreau | 0979916 | 2018-10-25 10:16:07 +0200 | [diff] [blame] | 389 | */ |
| 390 | static inline int si_alloc_ibuf(struct stream_interface *si, struct buffer_wait *wait) |
| 391 | { |
| 392 | int ret; |
| 393 | |
Willy Tarreau | 0979916 | 2018-10-25 10:16:07 +0200 | [diff] [blame] | 394 | ret = channel_alloc_buffer(si_ic(si), wait); |
| 395 | if (!ret) |
Willy Tarreau | 8be7cd7 | 2018-11-14 15:12:08 +0100 | [diff] [blame] | 396 | si_rx_buff_blk(si); |
Willy Tarreau | 0979916 | 2018-10-25 10:16:07 +0200 | [diff] [blame] | 397 | return ret; |
| 398 | } |
| 399 | |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 400 | /* Release the interface's existing endpoint (connection or appctx) and |
| 401 | * allocate then initialize a new appctx which is assigned to the interface |
Willy Tarreau | a7513f5 | 2015-04-05 00:15:26 +0200 | [diff] [blame] | 402 | * and returned. NULL may be returned upon memory shortage. Applet <applet> |
| 403 | * is assigned to the appctx, but it may be NULL. |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 404 | */ |
Willy Tarreau | 3057645 | 2015-04-13 13:50:30 +0200 | [diff] [blame] | 405 | static inline struct appctx *si_alloc_appctx(struct stream_interface *si, struct applet *applet) |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 406 | { |
| 407 | struct appctx *appctx; |
| 408 | |
| 409 | si_release_endpoint(si); |
Emeric Brun | 1138fd0 | 2017-06-19 12:38:55 +0200 | [diff] [blame] | 410 | appctx = appctx_new(applet, tid_bit); |
Willy Tarreau | 10d81b8 | 2018-05-31 14:44:25 +0200 | [diff] [blame] | 411 | if (appctx) { |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 412 | si_attach_appctx(si, appctx); |
Willy Tarreau | 10d81b8 | 2018-05-31 14:44:25 +0200 | [diff] [blame] | 413 | appctx->t->nice = si_strm(si)->task->nice; |
| 414 | } |
Willy Tarreau | 0a23bcb | 2013-12-01 11:31:38 +0100 | [diff] [blame] | 415 | |
| 416 | return appctx; |
| 417 | } |
| 418 | |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 419 | /* Sends a shutr to the connection using the data layer */ |
| 420 | static inline void si_shutr(struct stream_interface *si) |
| 421 | { |
Willy Tarreau | 6fe1541 | 2013-09-29 15:16:03 +0200 | [diff] [blame] | 422 | si->ops->shutr(si); |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 423 | } |
| 424 | |
| 425 | /* Sends a shutw to the connection using the data layer */ |
| 426 | static inline void si_shutw(struct stream_interface *si) |
| 427 | { |
Willy Tarreau | 6fe1541 | 2013-09-29 15:16:03 +0200 | [diff] [blame] | 428 | si->ops->shutw(si); |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 429 | } |
| 430 | |
Willy Tarreau | 0f9cd7b | 2019-01-31 19:02:43 +0100 | [diff] [blame] | 431 | /* Marks on the stream-interface that next shutw must kill the whole connection */ |
| 432 | static inline void si_must_kill_conn(struct stream_interface *si) |
| 433 | { |
| 434 | si->flags |= SI_FL_KILL_CONN; |
| 435 | } |
| 436 | |
Willy Tarreau | 96aadd5 | 2018-11-07 11:55:54 +0100 | [diff] [blame] | 437 | /* This is to be used after making some room available in a channel. It will |
Willy Tarreau | 32742fd | 2018-11-14 14:07:59 +0100 | [diff] [blame] | 438 | * return without doing anything if the stream interface's RX path is blocked. |
| 439 | * It will automatically mark the stream interface as busy processing the end |
| 440 | * point in order to avoid useless repeated wakeups. |
Willy Tarreau | 8fe516f | 2018-11-09 16:21:43 +0100 | [diff] [blame] | 441 | * It will then call ->chk_rcv() to enable receipt of new data. |
Willy Tarreau | 96aadd5 | 2018-11-07 11:55:54 +0100 | [diff] [blame] | 442 | */ |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 443 | static inline void si_chk_rcv(struct stream_interface *si) |
| 444 | { |
Willy Tarreau | 4f283fa | 2019-06-05 14:34:03 +0200 | [diff] [blame] | 445 | 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 Tarreau | a3b62d3 | 2018-12-06 15:24:01 +0100 | [diff] [blame] | 446 | si_rx_conn_rdy(si); |
| 447 | |
Willy Tarreau | 32742fd | 2018-11-14 14:07:59 +0100 | [diff] [blame] | 448 | if (si_rx_blocked(si) || !si_rx_endp_ready(si)) |
Willy Tarreau | 96aadd5 | 2018-11-07 11:55:54 +0100 | [diff] [blame] | 449 | return; |
| 450 | |
Willy Tarreau | 4f283fa | 2019-06-05 14:34:03 +0200 | [diff] [blame] | 451 | if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) |
Willy Tarreau | 1bdb598 | 2018-11-07 14:59:45 +0100 | [diff] [blame] | 452 | return; |
| 453 | |
Willy Tarreau | 05b9b64 | 2018-11-14 13:43:35 +0100 | [diff] [blame] | 454 | si->flags |= SI_FL_RX_WAIT_EP; |
Willy Tarreau | 57f08bb | 2018-11-07 11:28:12 +0100 | [diff] [blame] | 455 | si->ops->chk_rcv(si); |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 456 | } |
| 457 | |
Willy Tarreau | ade6478 | 2018-11-17 19:51:07 +0100 | [diff] [blame] | 458 | /* This tries to perform a synchronous receive on the stream interface to |
| 459 | * try to collect last arrived data. In practice it's only implemented on |
| 460 | * conn_streams. Returns 0 if nothing was done, non-zero if new data or a |
| 461 | * shutdown were collected. This may result on some delayed receive calls |
| 462 | * to be programmed and performed later, though it doesn't provide any |
| 463 | * such guarantee. |
| 464 | */ |
| 465 | static inline int si_sync_recv(struct stream_interface *si) |
| 466 | { |
| 467 | struct conn_stream *cs; |
| 468 | |
Willy Tarreau | 4f283fa | 2019-06-05 14:34:03 +0200 | [diff] [blame] | 469 | if (!si_state_in(si->state, SI_SB_RDY|SI_SB_EST)) |
Willy Tarreau | ade6478 | 2018-11-17 19:51:07 +0100 | [diff] [blame] | 470 | return 0; |
| 471 | |
| 472 | cs = objt_cs(si->end); |
Olivier Houchard | 8af03b3 | 2020-01-22 17:34:54 +0100 | [diff] [blame] | 473 | if (!cs || !cs->conn->mux) |
Willy Tarreau | ade6478 | 2018-11-17 19:51:07 +0100 | [diff] [blame] | 474 | return 0; // only conn_streams are supported |
| 475 | |
Willy Tarreau | 4f6516d | 2018-12-19 13:59:17 +0100 | [diff] [blame] | 476 | if (si->wait_event.events & SUB_RETRY_RECV) |
Willy Tarreau | ade6478 | 2018-11-17 19:51:07 +0100 | [diff] [blame] | 477 | return 0; // already subscribed |
| 478 | |
Willy Tarreau | 7f494d0 | 2018-11-16 14:26:11 +0100 | [diff] [blame] | 479 | if (!si_rx_endp_ready(si) || si_rx_blocked(si)) |
Willy Tarreau | ade6478 | 2018-11-17 19:51:07 +0100 | [diff] [blame] | 480 | return 0; // already failed |
| 481 | |
| 482 | return si_cs_recv(cs); |
| 483 | } |
| 484 | |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 485 | /* Calls chk_snd on the connection using the data layer */ |
| 486 | static inline void si_chk_snd(struct stream_interface *si) |
| 487 | { |
Willy Tarreau | 57f08bb | 2018-11-07 11:28:12 +0100 | [diff] [blame] | 488 | si->ops->chk_snd(si); |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | /* Calls chk_snd on the connection using the ctrl layer */ |
Olivier Houchard | 201b9f4 | 2018-11-21 00:16:29 +0100 | [diff] [blame] | 492 | static inline int si_connect(struct stream_interface *si, struct connection *conn) |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 493 | { |
Willy Tarreau | e7dff02 | 2015-04-03 01:14:29 +0200 | [diff] [blame] | 494 | int ret = SF_ERR_NONE; |
Willy Tarreau | 034c88c | 2017-01-23 23:36:45 +0100 | [diff] [blame] | 495 | int conn_flags = 0; |
Willy Tarreau | 14f8e86 | 2012-08-30 22:23:13 +0200 | [diff] [blame] | 496 | |
Willy Tarreau | b363a1f | 2013-10-01 10:45:07 +0200 | [diff] [blame] | 497 | if (unlikely(!conn || !conn->ctrl || !conn->ctrl->connect)) |
Willy Tarreau | e7dff02 | 2015-04-03 01:14:29 +0200 | [diff] [blame] | 498 | return SF_ERR_INTERNAL; |
Willy Tarreau | 14f8e86 | 2012-08-30 22:23:13 +0200 | [diff] [blame] | 499 | |
Willy Tarreau | 034c88c | 2017-01-23 23:36:45 +0100 | [diff] [blame] | 500 | if (!channel_is_empty(si_oc(si))) |
| 501 | conn_flags |= CONNECT_HAS_DATA; |
| 502 | if (si->conn_retries == si_strm(si)->be->conn_retries) |
| 503 | conn_flags |= CONNECT_CAN_USE_TFO; |
Willy Tarreau | b490b4e | 2013-12-15 16:20:50 +0100 | [diff] [blame] | 504 | if (!conn_ctrl_ready(conn) || !conn_xprt_ready(conn)) { |
Willy Tarreau | 034c88c | 2017-01-23 23:36:45 +0100 | [diff] [blame] | 505 | ret = conn->ctrl->connect(conn, conn_flags); |
Willy Tarreau | e7dff02 | 2015-04-03 01:14:29 +0200 | [diff] [blame] | 506 | if (ret != SF_ERR_NONE) |
Willy Tarreau | b490b4e | 2013-12-15 16:20:50 +0100 | [diff] [blame] | 507 | return ret; |
Willy Tarreau | 9e5a3aa | 2013-12-31 23:32:12 +0100 | [diff] [blame] | 508 | |
Willy Tarreau | 9e5a3aa | 2013-12-31 23:32:12 +0100 | [diff] [blame] | 509 | /* we're in the process of establishing a connection */ |
| 510 | si->state = SI_ST_CON; |
Willy Tarreau | b490b4e | 2013-12-15 16:20:50 +0100 | [diff] [blame] | 511 | } |
Christopher Faulet | c34d19f | 2015-12-23 09:33:35 +0100 | [diff] [blame] | 512 | else { |
Willy Tarreau | bf66bd1 | 2019-01-23 15:15:09 +0100 | [diff] [blame] | 513 | /* try to reuse the existing connection, it will be |
| 514 | * confirmed once we can send on it. |
| 515 | */ |
Olivier Houchard | 6e8e2ec | 2019-10-25 16:25:20 +0200 | [diff] [blame] | 516 | /* Is the connection really ready ? */ |
| 517 | if (conn->mux->ctl(conn, MUX_STATUS, NULL) & MUX_STATUS_READY) |
| 518 | si->state = SI_ST_RDY; |
| 519 | else |
| 520 | si->state = SI_ST_CON; |
Willy Tarreau | b490b4e | 2013-12-15 16:20:50 +0100 | [diff] [blame] | 521 | } |
Willy Tarreau | 14f8e86 | 2012-08-30 22:23:13 +0200 | [diff] [blame] | 522 | |
| 523 | /* needs src ip/port for logging */ |
| 524 | if (si->flags & SI_FL_SRC_ADDR) |
Willy Tarreau | 3cc01d8 | 2019-07-17 11:27:38 +0200 | [diff] [blame] | 525 | conn_get_src(conn); |
Willy Tarreau | 14f8e86 | 2012-08-30 22:23:13 +0200 | [diff] [blame] | 526 | |
Willy Tarreau | 14f8e86 | 2012-08-30 22:23:13 +0200 | [diff] [blame] | 527 | return ret; |
Willy Tarreau | 73b013b | 2012-05-21 16:31:45 +0200 | [diff] [blame] | 528 | } |
Willy Tarreau | 59b9479 | 2012-05-11 16:16:40 +0200 | [diff] [blame] | 529 | |
Willy Tarreau | 236c429 | 2019-06-06 08:19:20 +0200 | [diff] [blame] | 530 | /* Combines both si_update_rx() and si_update_tx() at once */ |
| 531 | static inline void si_update(struct stream_interface *si) |
| 532 | { |
| 533 | si_update_rx(si); |
| 534 | si_update_tx(si); |
| 535 | } |
| 536 | |
Willy Tarreau | 55e4ecd | 2012-12-08 17:48:47 +0100 | [diff] [blame] | 537 | /* for debugging, reports the stream interface state name */ |
| 538 | static inline const char *si_state_str(int state) |
| 539 | { |
| 540 | switch (state) { |
| 541 | case SI_ST_INI: return "INI"; |
| 542 | case SI_ST_REQ: return "REQ"; |
| 543 | case SI_ST_QUE: return "QUE"; |
| 544 | case SI_ST_TAR: return "TAR"; |
| 545 | case SI_ST_ASS: return "ASS"; |
| 546 | case SI_ST_CON: return "CON"; |
| 547 | case SI_ST_CER: return "CER"; |
Willy Tarreau | 4f283fa | 2019-06-05 14:34:03 +0200 | [diff] [blame] | 548 | case SI_ST_RDY: return "RDY"; |
Willy Tarreau | 55e4ecd | 2012-12-08 17:48:47 +0100 | [diff] [blame] | 549 | case SI_ST_EST: return "EST"; |
| 550 | case SI_ST_DIS: return "DIS"; |
| 551 | case SI_ST_CLO: return "CLO"; |
| 552 | default: return "???"; |
| 553 | } |
| 554 | } |
| 555 | |
Willy Tarreau | 5e539c9 | 2020-06-04 20:45:39 +0200 | [diff] [blame] | 556 | #endif /* _HAPROXY_STREAM_INTERFACE_H */ |
Willy Tarreau | cff6411 | 2008-11-03 06:26:53 +0100 | [diff] [blame] | 557 | |
| 558 | /* |
| 559 | * Local variables: |
| 560 | * c-indent-level: 8 |
| 561 | * c-basic-offset: 8 |
| 562 | * End: |
| 563 | */ |