Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 2 | * Session management functions. |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 3 | * |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 4 | * Copyright 2000-2015 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 5 | * |
| 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * as published by the Free Software Foundation; either version |
| 9 | * 2 of the License, or (at your option) any later version. |
| 10 | * |
| 11 | */ |
| 12 | |
| 13 | #include <common/config.h> |
| 14 | #include <common/buffer.h> |
| 15 | #include <common/debug.h> |
Willy Tarreau | 35b51c6 | 2018-09-10 15:38:55 +0200 | [diff] [blame] | 16 | #include <common/http.h> |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 17 | #include <common/memory.h> |
| 18 | |
| 19 | #include <types/global.h> |
| 20 | #include <types/session.h> |
| 21 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 22 | #include <proto/connection.h> |
| 23 | #include <proto/listener.h> |
| 24 | #include <proto/log.h> |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 25 | #include <proto/proxy.h> |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 26 | #include <proto/session.h> |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 27 | #include <proto/stream.h> |
Willy Tarreau | 3971310 | 2016-11-25 15:49:32 +0100 | [diff] [blame] | 28 | #include <proto/tcp_rules.h> |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 29 | #include <proto/vars.h> |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 30 | |
Willy Tarreau | 8ceae72 | 2018-11-26 11:58:30 +0100 | [diff] [blame] | 31 | DECLARE_POOL(pool_head_session, "session", sizeof(struct session)); |
Olivier Houchard | 351411f | 2018-12-27 17:20:54 +0100 | [diff] [blame] | 32 | DECLARE_POOL(pool_head_sess_srv_list, "session server list", |
| 33 | sizeof(struct sess_srv_list)); |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 34 | |
Olivier Houchard | 477902b | 2020-01-22 18:08:48 +0100 | [diff] [blame] | 35 | int conn_complete_session(struct connection *conn); |
Olivier Houchard | 9f6af33 | 2018-05-25 14:04:04 +0200 | [diff] [blame] | 36 | static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 37 | |
Willy Tarreau | c38f71c | 2015-04-05 00:38:48 +0200 | [diff] [blame] | 38 | /* Create a a new session and assign it to frontend <fe>, listener <li>, |
| 39 | * origin <origin>, set the current date and clear the stick counters pointers. |
| 40 | * Returns the session upon success or NULL. The session may be released using |
Willy Tarreau | 0bf6fa5 | 2017-09-15 10:25:14 +0200 | [diff] [blame] | 41 | * session_free(). Note: <li> may be NULL. |
Willy Tarreau | c38f71c | 2015-04-05 00:38:48 +0200 | [diff] [blame] | 42 | */ |
| 43 | struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin) |
| 44 | { |
| 45 | struct session *sess; |
| 46 | |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 47 | sess = pool_alloc(pool_head_session); |
Willy Tarreau | c38f71c | 2015-04-05 00:38:48 +0200 | [diff] [blame] | 48 | if (sess) { |
| 49 | sess->listener = li; |
| 50 | sess->fe = fe; |
| 51 | sess->origin = origin; |
| 52 | sess->accept_date = date; /* user-visible date for logging */ |
| 53 | sess->tv_accept = now; /* corrected date for internal use */ |
| 54 | memset(sess->stkctr, 0, sizeof(sess->stkctr)); |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 55 | vars_init(&sess->vars, SCOPE_SESS); |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 56 | sess->task = NULL; |
Willy Tarreau | 590a051 | 2018-09-05 11:56:48 +0200 | [diff] [blame] | 57 | sess->t_handshake = -1; /* handshake not done yet */ |
Olivier Houchard | d5b3d30 | 2019-03-08 18:54:34 +0100 | [diff] [blame] | 58 | _HA_ATOMIC_ADD(&totalconn, 1); |
| 59 | _HA_ATOMIC_ADD(&jobs, 1); |
Olivier Houchard | 351411f | 2018-12-27 17:20:54 +0100 | [diff] [blame] | 60 | LIST_INIT(&sess->srv_list); |
Olivier Houchard | a2dbeb2 | 2018-12-28 18:50:57 +0100 | [diff] [blame] | 61 | sess->idle_conns = 0; |
Olivier Houchard | 250031e | 2019-05-29 15:01:50 +0200 | [diff] [blame] | 62 | sess->flags = SESS_FL_NONE; |
Willy Tarreau | c38f71c | 2015-04-05 00:38:48 +0200 | [diff] [blame] | 63 | } |
| 64 | return sess; |
| 65 | } |
| 66 | |
Willy Tarreau | 11c3624 | 2015-04-04 15:54:03 +0200 | [diff] [blame] | 67 | void session_free(struct session *sess) |
| 68 | { |
Olivier Houchard | 00cf70f | 2018-11-30 17:24:55 +0100 | [diff] [blame] | 69 | struct connection *conn, *conn_back; |
Olivier Houchard | 351411f | 2018-12-27 17:20:54 +0100 | [diff] [blame] | 70 | struct sess_srv_list *srv_list, *srv_list_back; |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 71 | |
Willy Tarreau | 4f0c64c | 2017-10-18 15:01:14 +0200 | [diff] [blame] | 72 | if (sess->listener) |
| 73 | listener_release(sess->listener); |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 74 | session_store_counters(sess); |
Willy Tarreau | ebcd484 | 2015-06-19 11:59:02 +0200 | [diff] [blame] | 75 | vars_prune_per_sess(&sess->vars); |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 76 | conn = objt_conn(sess->origin); |
| 77 | if (conn != NULL && conn->mux) |
Christopher Faulet | 73c1207 | 2019-04-08 11:23:22 +0200 | [diff] [blame] | 78 | conn->mux->destroy(conn->ctx); |
Olivier Houchard | 351411f | 2018-12-27 17:20:54 +0100 | [diff] [blame] | 79 | list_for_each_entry_safe(srv_list, srv_list_back, &sess->srv_list, srv_list) { |
| 80 | list_for_each_entry_safe(conn, conn_back, &srv_list->conn_list, session_list) { |
Willy Tarreau | 5de7817 | 2019-11-15 07:04:24 +0100 | [diff] [blame] | 81 | LIST_DEL_INIT(&conn->session_list); |
Olivier Houchard | 00cf70f | 2018-11-30 17:24:55 +0100 | [diff] [blame] | 82 | if (conn->mux) { |
Olivier Houchard | 00cf70f | 2018-11-30 17:24:55 +0100 | [diff] [blame] | 83 | conn->owner = NULL; |
Olivier Houchard | 8788b41 | 2019-01-31 19:31:19 +0100 | [diff] [blame] | 84 | conn->flags &= ~CO_FL_SESS_IDLE; |
Olivier Houchard | a4d4fdf | 2018-12-14 19:27:06 +0100 | [diff] [blame] | 85 | if (!srv_add_to_idle_list(objt_server(conn->target), conn)) |
Christopher Faulet | 73c1207 | 2019-04-08 11:23:22 +0200 | [diff] [blame] | 86 | conn->mux->destroy(conn->ctx); |
Olivier Houchard | 00cf70f | 2018-11-30 17:24:55 +0100 | [diff] [blame] | 87 | } else { |
| 88 | /* We have a connection, but not yet an associated mux. |
| 89 | * So destroy it now. |
| 90 | */ |
| 91 | conn_stop_tracking(conn); |
| 92 | conn_full_close(conn); |
| 93 | conn_free(conn); |
| 94 | } |
| 95 | } |
Olivier Houchard | 351411f | 2018-12-27 17:20:54 +0100 | [diff] [blame] | 96 | pool_free(pool_head_sess_srv_list, srv_list); |
Olivier Houchard | 201b9f4 | 2018-11-21 00:16:29 +0100 | [diff] [blame] | 97 | } |
Willy Tarreau | bafbe01 | 2017-11-24 17:34:44 +0100 | [diff] [blame] | 98 | pool_free(pool_head_session, sess); |
Olivier Houchard | d5b3d30 | 2019-03-08 18:54:34 +0100 | [diff] [blame] | 99 | _HA_ATOMIC_SUB(&jobs, 1); |
Willy Tarreau | 11c3624 | 2015-04-04 15:54:03 +0200 | [diff] [blame] | 100 | } |
| 101 | |
Willy Tarreau | 3e13cba | 2017-10-08 11:26:30 +0200 | [diff] [blame] | 102 | /* callback used from the connection/mux layer to notify that a connection is |
Joseph Herlant | d091bfb | 2018-11-25 11:22:10 -0800 | [diff] [blame] | 103 | * going to be released. |
Willy Tarreau | 3e13cba | 2017-10-08 11:26:30 +0200 | [diff] [blame] | 104 | */ |
| 105 | void conn_session_free(struct connection *conn) |
| 106 | { |
| 107 | session_free(conn->owner); |
| 108 | } |
| 109 | |
Willy Tarreau | 042cd75 | 2015-04-08 18:10:49 +0200 | [diff] [blame] | 110 | /* count a new session to keep frontend, listener and track stats up to date */ |
| 111 | static void session_count_new(struct session *sess) |
| 112 | { |
| 113 | struct stkctr *stkctr; |
| 114 | void *ptr; |
| 115 | int i; |
| 116 | |
| 117 | proxy_inc_fe_sess_ctr(sess->listener, sess->fe); |
| 118 | |
| 119 | for (i = 0; i < MAX_SESS_STKCTR; i++) { |
| 120 | stkctr = &sess->stkctr[i]; |
| 121 | if (!stkctr_entry(stkctr)) |
| 122 | continue; |
| 123 | |
| 124 | ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_CNT); |
| 125 | if (ptr) |
| 126 | stktable_data_cast(ptr, sess_cnt)++; |
| 127 | |
| 128 | ptr = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_SESS_RATE); |
| 129 | if (ptr) |
| 130 | update_freq_ctr_period(&stktable_data_cast(ptr, sess_rate), |
| 131 | stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u, 1); |
| 132 | } |
| 133 | } |
| 134 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 135 | /* This function is called from the protocol layer accept() in order to |
Dave Chiluk | 8618a6a | 2018-06-21 11:03:20 -0500 | [diff] [blame] | 136 | * instantiate a new session on behalf of a given listener and frontend. It |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 137 | * returns a positive value upon success, 0 if the connection can be ignored, |
| 138 | * or a negative value upon critical failure. The accepted file descriptor is |
| 139 | * closed if we return <= 0. If no handshake is needed, it immediately tries |
Dave Chiluk | 8618a6a | 2018-06-21 11:03:20 -0500 | [diff] [blame] | 140 | * to instantiate a new stream. The created connection's owner points to the |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 141 | * new session until the upper layers are created. |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 142 | */ |
| 143 | int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr) |
| 144 | { |
| 145 | struct connection *cli_conn; |
Willy Tarreau | c95bad5 | 2016-12-22 00:13:31 +0100 | [diff] [blame] | 146 | struct proxy *p = l->bind_conf->frontend; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 147 | struct session *sess; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 148 | int ret; |
| 149 | |
| 150 | |
| 151 | ret = -1; /* assume unrecoverable error by default */ |
| 152 | |
| 153 | if (unlikely((cli_conn = conn_new()) == NULL)) |
| 154 | goto out_close; |
| 155 | |
Willy Tarreau | ca79f59 | 2019-07-17 19:04:47 +0200 | [diff] [blame] | 156 | if (!sockaddr_alloc(&cli_conn->src)) |
| 157 | goto out_free_conn; |
| 158 | |
Willy Tarreau | 585744b | 2017-08-24 14:31:19 +0200 | [diff] [blame] | 159 | cli_conn->handle.fd = cfd; |
Willy Tarreau | 4d3c60a | 2019-07-17 15:23:20 +0200 | [diff] [blame] | 160 | *cli_conn->src = *addr; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 161 | cli_conn->flags |= CO_FL_ADDR_FROM_SET; |
| 162 | cli_conn->target = &l->obj_type; |
| 163 | cli_conn->proxy_netns = l->netns; |
| 164 | |
Willy Tarreau | be37315 | 2018-09-06 11:45:30 +0200 | [diff] [blame] | 165 | conn_prepare(cli_conn, l->proto, l->bind_conf->xprt); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 166 | conn_ctrl_init(cli_conn); |
| 167 | |
| 168 | /* wait for a PROXY protocol header */ |
Olivier Houchard | fe50bfb | 2019-05-27 12:09:19 +0200 | [diff] [blame] | 169 | if (l->options & LI_O_ACC_PROXY) |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 170 | cli_conn->flags |= CO_FL_ACCEPT_PROXY; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 171 | |
Bertrand Jacquin | 93b227d | 2016-06-04 15:11:10 +0100 | [diff] [blame] | 172 | /* wait for a NetScaler client IP insertion protocol header */ |
Olivier Houchard | fe50bfb | 2019-05-27 12:09:19 +0200 | [diff] [blame] | 173 | if (l->options & LI_O_ACC_CIP) |
Bertrand Jacquin | 93b227d | 2016-06-04 15:11:10 +0100 | [diff] [blame] | 174 | cli_conn->flags |= CO_FL_ACCEPT_CIP; |
Bertrand Jacquin | 93b227d | 2016-06-04 15:11:10 +0100 | [diff] [blame] | 175 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 176 | if (conn_xprt_init(cli_conn) < 0) |
| 177 | goto out_free_conn; |
| 178 | |
Olivier Houchard | fe50bfb | 2019-05-27 12:09:19 +0200 | [diff] [blame] | 179 | /* Add the handshake pseudo-XPRT */ |
| 180 | if (cli_conn->flags & (CO_FL_ACCEPT_PROXY | CO_FL_ACCEPT_CIP)) { |
| 181 | if (xprt_add_hs(cli_conn) != 0) |
| 182 | goto out_free_conn; |
| 183 | } |
Willy Tarreau | 64beab2 | 2015-04-05 00:39:16 +0200 | [diff] [blame] | 184 | sess = session_new(p, l, &cli_conn->obj_type); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 185 | if (!sess) |
| 186 | goto out_free_conn; |
| 187 | |
Willy Tarreau | 436d333 | 2017-10-08 11:16:46 +0200 | [diff] [blame] | 188 | conn_set_owner(cli_conn, sess, NULL); |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 189 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 190 | /* now evaluate the tcp-request layer4 rules. We only need a session |
| 191 | * and no stream for these rules. |
| 192 | */ |
Willy Tarreau | 7d9736f | 2016-10-21 16:34:21 +0200 | [diff] [blame] | 193 | if ((l->options & LI_O_TCP_L4_RULES) && !tcp_exec_l4_rules(sess)) { |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 194 | /* let's do a no-linger now to close with a single RST. */ |
| 195 | setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger)); |
| 196 | ret = 0; /* successful termination */ |
| 197 | goto out_free_sess; |
| 198 | } |
| 199 | |
| 200 | /* monitor-net and health mode are processed immediately after TCP |
| 201 | * connection rules. This way it's possible to block them, but they |
| 202 | * never use the lower data layers, they send directly over the socket, |
| 203 | * as they were designed for. We first flush the socket receive buffer |
| 204 | * in order to avoid emission of an RST by the system. We ignore any |
| 205 | * error. |
| 206 | */ |
| 207 | if (unlikely((p->mode == PR_MODE_HEALTH) || |
| 208 | ((l->options & LI_O_CHK_MONNET) && |
| 209 | addr->ss_family == AF_INET && |
| 210 | (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) { |
| 211 | /* we have 4 possibilities here : |
| 212 | * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK" |
| 213 | * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK" |
| 214 | * - HEALTH mode without HTTP check => just send "OK" |
| 215 | * - TCP mode from monitoring address => just close |
| 216 | */ |
| 217 | if (l->proto->drain) |
| 218 | l->proto->drain(cfd); |
| 219 | if (p->mode == PR_MODE_HTTP || |
| 220 | (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK)) |
| 221 | send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE); |
| 222 | else if (p->mode == PR_MODE_HEALTH) |
| 223 | send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE); |
| 224 | ret = 0; |
| 225 | goto out_free_sess; |
| 226 | } |
| 227 | |
Willy Tarreau | f9d1bc6 | 2015-04-05 17:56:47 +0200 | [diff] [blame] | 228 | /* Adjust some socket options */ |
| 229 | if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) { |
| 230 | setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)); |
| 231 | |
| 232 | if (p->options & PR_O_TCP_CLI_KA) |
| 233 | setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one)); |
| 234 | |
| 235 | if (p->options & PR_O_TCP_NOLING) |
| 236 | fdtab[cfd].linger_risk = 1; |
| 237 | |
| 238 | #if defined(TCP_MAXSEG) |
| 239 | if (l->maxseg < 0) { |
| 240 | /* we just want to reduce the current MSS by that value */ |
| 241 | int mss; |
| 242 | socklen_t mss_len = sizeof(mss); |
| 243 | if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) { |
| 244 | mss += l->maxseg; /* remember, it's < 0 */ |
| 245 | setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss)); |
| 246 | } |
| 247 | } |
| 248 | #endif |
| 249 | } |
| 250 | |
| 251 | if (global.tune.client_sndbuf) |
| 252 | setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf)); |
| 253 | |
| 254 | if (global.tune.client_rcvbuf) |
| 255 | setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf)); |
| 256 | |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 257 | /* OK, now either we have a pending handshake to execute with and then |
| 258 | * we must return to the I/O layer, or we can proceed with the end of |
| 259 | * the stream initialization. In case of handshake, we also set the I/O |
| 260 | * timeout to the frontend's client timeout and register a task in the |
| 261 | * session for this purpose. The connection's owner is left to the |
| 262 | * session during this period. |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 263 | * |
| 264 | * At this point we set the relation between sess/task/conn this way : |
| 265 | * |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 266 | * +----------------- task |
| 267 | * | | |
| 268 | * orig -- sess <-- context | |
| 269 | * | ^ | | |
| 270 | * v | | | |
| 271 | * conn -- owner ---> task <-----+ |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 272 | */ |
Olivier Houchard | c2aae74 | 2017-09-22 18:26:28 +0200 | [diff] [blame] | 273 | if (cli_conn->flags & (CO_FL_HANDSHAKE | CO_FL_EARLY_SSL_HS)) { |
Emeric Brun | c60def8 | 2017-09-27 14:59:38 +0200 | [diff] [blame] | 274 | if (unlikely((sess->task = task_new(tid_bit)) == NULL)) |
Willy Tarreau | 87787ac | 2017-08-28 16:22:54 +0200 | [diff] [blame] | 275 | goto out_free_sess; |
| 276 | |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 277 | sess->task->context = sess; |
| 278 | sess->task->nice = l->nice; |
| 279 | sess->task->process = session_expire_embryonic; |
| 280 | sess->task->expire = tick_add_ifset(now_ms, p->timeout.client); |
| 281 | task_queue(sess->task); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 282 | return 1; |
| 283 | } |
| 284 | |
Willy Tarreau | 18b95a4 | 2015-04-05 01:04:01 +0200 | [diff] [blame] | 285 | /* OK let's complete stream initialization since there is no handshake */ |
Willy Tarreau | 0c4ed35 | 2017-09-15 10:06:28 +0200 | [diff] [blame] | 286 | if (conn_complete_session(cli_conn) >= 0) |
| 287 | return 1; |
Willy Tarreau | d1769b8 | 2015-04-06 00:25:48 +0200 | [diff] [blame] | 288 | |
Willy Tarreau | e5891ca | 2020-01-07 18:03:09 +0100 | [diff] [blame] | 289 | /* if we reach here we have deliberately decided not to keep this |
| 290 | * session (e.g. tcp-request rule), so that's not an error we should |
| 291 | * try to protect against. |
| 292 | */ |
| 293 | ret = 0; |
| 294 | |
Willy Tarreau | 0c4ed35 | 2017-09-15 10:06:28 +0200 | [diff] [blame] | 295 | /* error unrolling */ |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 296 | out_free_sess: |
Christopher Faulet | fe23428 | 2018-03-23 15:11:55 +0100 | [diff] [blame] | 297 | /* prevent call to listener_release during session_free. It will be |
| 298 | * done below, for all errors. */ |
| 299 | sess->listener = NULL; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 300 | session_free(sess); |
| 301 | out_free_conn: |
Willy Tarreau | 5b78a9d | 2017-10-05 18:12:51 +0200 | [diff] [blame] | 302 | conn_stop_tracking(cli_conn); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 303 | conn_xprt_close(cli_conn); |
| 304 | conn_free(cli_conn); |
| 305 | out_close: |
Christopher Faulet | fe23428 | 2018-03-23 15:11:55 +0100 | [diff] [blame] | 306 | listener_release(l); |
Christopher Faulet | 76f4c37 | 2019-07-17 16:53:19 +0200 | [diff] [blame] | 307 | if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) && |
| 308 | p->mode == PR_MODE_HTTP && l->bind_conf->mux_proto == NULL) { |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 309 | /* critical error, no more memory, try to emit a 500 response */ |
Christopher Faulet | 39566d1 | 2019-07-17 21:36:33 +0200 | [diff] [blame] | 310 | send(cfd, http_err_msgs[HTTP_ERR_500], strlen(http_err_msgs[HTTP_ERR_500]), |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 311 | MSG_DONTWAIT|MSG_NOSIGNAL); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | if (fdtab[cfd].owner) |
| 315 | fd_delete(cfd); |
| 316 | else |
| 317 | close(cfd); |
| 318 | return ret; |
| 319 | } |
| 320 | |
| 321 | |
| 322 | /* prepare the trash with a log prefix for session <sess>. It only works with |
| 323 | * embryonic sessions based on a real connection. This function requires that |
| 324 | * at sess->origin points to the incoming connection. |
| 325 | */ |
| 326 | static void session_prepare_log_prefix(struct session *sess) |
| 327 | { |
| 328 | struct tm tm; |
| 329 | char pn[INET6_ADDRSTRLEN]; |
| 330 | int ret; |
| 331 | char *end; |
| 332 | struct connection *cli_conn = __objt_conn(sess->origin); |
| 333 | |
Willy Tarreau | 4d3c60a | 2019-07-17 15:23:20 +0200 | [diff] [blame] | 334 | ret = conn_get_src(cli_conn) ? addr_to_str(cli_conn->src, pn, sizeof(pn)) : 0; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 335 | if (ret <= 0) |
| 336 | chunk_printf(&trash, "unknown ["); |
| 337 | else if (ret == AF_UNIX) |
| 338 | chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid); |
| 339 | else |
Willy Tarreau | 4d3c60a | 2019-07-17 15:23:20 +0200 | [diff] [blame] | 340 | chunk_printf(&trash, "%s:%d [", pn, get_host_port(cli_conn->src)); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 341 | |
| 342 | get_localtime(sess->accept_date.tv_sec, &tm); |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 343 | end = date2str_log(trash.area + trash.data, &tm, &(sess->accept_date), |
| 344 | trash.size - trash.data); |
| 345 | trash.data = end - trash.area; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 346 | if (sess->listener->name) |
| 347 | chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name); |
| 348 | else |
| 349 | chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid); |
| 350 | } |
| 351 | |
| 352 | /* This function kills an existing embryonic session. It stops the connection's |
| 353 | * transport layer, releases assigned resources, resumes the listener if it was |
| 354 | * disabled and finally kills the file descriptor. This function requires that |
| 355 | * sess->origin points to the incoming connection. |
| 356 | */ |
Willy Tarreau | 086735a | 2018-11-05 15:09:47 +0100 | [diff] [blame] | 357 | static void session_kill_embryonic(struct session *sess, unsigned short state) |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 358 | { |
| 359 | int level = LOG_INFO; |
| 360 | struct connection *conn = __objt_conn(sess->origin); |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 361 | struct task *task = sess->task; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 362 | unsigned int log = sess->fe->to_log; |
| 363 | const char *err_msg; |
| 364 | |
| 365 | if (sess->fe->options2 & PR_O2_LOGERRORS) |
| 366 | level = LOG_ERR; |
| 367 | |
| 368 | if (log && (sess->fe->options & PR_O_NULLNOLOG)) { |
| 369 | /* with "option dontlognull", we don't log connections with no transfer */ |
| 370 | if (!conn->err_code || |
| 371 | conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT || |
Bertrand Jacquin | 93b227d | 2016-06-04 15:11:10 +0100 | [diff] [blame] | 372 | conn->err_code == CO_ER_CIP_EMPTY || conn->err_code == CO_ER_CIP_ABORT || |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 373 | conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT) |
| 374 | log = 0; |
| 375 | } |
| 376 | |
| 377 | if (log) { |
Willy Tarreau | 086735a | 2018-11-05 15:09:47 +0100 | [diff] [blame] | 378 | if (!conn->err_code && (state & TASK_WOKEN_TIMER)) { |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 379 | if (conn->flags & CO_FL_ACCEPT_PROXY) |
| 380 | conn->err_code = CO_ER_PRX_TIMEOUT; |
Bertrand Jacquin | 93b227d | 2016-06-04 15:11:10 +0100 | [diff] [blame] | 381 | else if (conn->flags & CO_FL_ACCEPT_CIP) |
| 382 | conn->err_code = CO_ER_CIP_TIMEOUT; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 383 | else if (conn->flags & CO_FL_SSL_WAIT_HS) |
| 384 | conn->err_code = CO_ER_SSL_TIMEOUT; |
| 385 | } |
| 386 | |
| 387 | session_prepare_log_prefix(sess); |
| 388 | err_msg = conn_err_code_str(conn); |
| 389 | if (err_msg) |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 390 | send_log(sess->fe, level, "%s: %s\n", trash.area, |
| 391 | err_msg); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 392 | else |
| 393 | send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n", |
Willy Tarreau | 843b7cb | 2018-07-13 10:54:26 +0200 | [diff] [blame] | 394 | trash.area, conn->err_code, conn->flags); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 395 | } |
| 396 | |
| 397 | /* kill the connection now */ |
Willy Tarreau | 5b78a9d | 2017-10-05 18:12:51 +0200 | [diff] [blame] | 398 | conn_stop_tracking(conn); |
| 399 | conn_full_close(conn); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 400 | conn_free(conn); |
Olivier Houchard | 7c6f8b1 | 2018-11-13 16:48:36 +0100 | [diff] [blame] | 401 | sess->origin = NULL; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 402 | |
Olivier Houchard | 3f795f7 | 2019-04-17 22:51:06 +0200 | [diff] [blame] | 403 | task_destroy(task); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 404 | session_free(sess); |
| 405 | } |
| 406 | |
| 407 | /* Manages the embryonic session timeout. It is only called when the timeout |
| 408 | * strikes and performs the required cleanup. |
| 409 | */ |
Olivier Houchard | 9f6af33 | 2018-05-25 14:04:04 +0200 | [diff] [blame] | 410 | static struct task *session_expire_embryonic(struct task *t, void *context, unsigned short state) |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 411 | { |
Olivier Houchard | 9f6af33 | 2018-05-25 14:04:04 +0200 | [diff] [blame] | 412 | struct session *sess = context; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 413 | |
Olivier Houchard | fde2a09 | 2018-08-16 19:03:50 +0200 | [diff] [blame] | 414 | if (!(state & TASK_WOKEN_TIMER)) |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 415 | return t; |
| 416 | |
Willy Tarreau | 086735a | 2018-11-05 15:09:47 +0100 | [diff] [blame] | 417 | session_kill_embryonic(sess, state); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 418 | return NULL; |
| 419 | } |
| 420 | |
| 421 | /* Finish initializing a session from a connection, or kills it if the |
Willy Tarreau | 0c4ed35 | 2017-09-15 10:06:28 +0200 | [diff] [blame] | 422 | * connection shows and error. Returns <0 if the connection was killed. It may |
Olivier Houchard | 477902b | 2020-01-22 18:08:48 +0100 | [diff] [blame] | 423 | * be called either asynchronously when ssl handshake is done with an embryonic |
Willy Tarreau | 0c4ed35 | 2017-09-15 10:06:28 +0200 | [diff] [blame] | 424 | * session, or synchronously to finalize the session. The distinction is made |
| 425 | * on sess->task which is only set in the embryonic session case. |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 426 | */ |
Olivier Houchard | 477902b | 2020-01-22 18:08:48 +0100 | [diff] [blame] | 427 | int conn_complete_session(struct connection *conn) |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 428 | { |
Willy Tarreau | 0b74eae | 2017-08-28 19:02:51 +0200 | [diff] [blame] | 429 | struct session *sess = conn->owner; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 430 | |
Willy Tarreau | 590a051 | 2018-09-05 11:56:48 +0200 | [diff] [blame] | 431 | sess->t_handshake = tv_ms_elapsed(&sess->tv_accept, &now); |
| 432 | |
Willy Tarreau | d1769b8 | 2015-04-06 00:25:48 +0200 | [diff] [blame] | 433 | if (conn->flags & CO_FL_ERROR) |
| 434 | goto fail; |
| 435 | |
Willy Tarreau | 678be62 | 2015-04-08 18:18:15 +0200 | [diff] [blame] | 436 | /* if logs require transport layer information, note it on the connection */ |
| 437 | if (sess->fe->to_log & LW_XPRT) |
| 438 | conn->flags |= CO_FL_XPRT_TRACKED; |
| 439 | |
Willy Tarreau | 620408f | 2016-10-21 16:37:51 +0200 | [diff] [blame] | 440 | /* we may have some tcp-request-session rules */ |
| 441 | if ((sess->listener->options & LI_O_TCP_L5_RULES) && !tcp_exec_l5_rules(sess)) |
| 442 | goto fail; |
| 443 | |
Willy Tarreau | 042cd75 | 2015-04-08 18:10:49 +0200 | [diff] [blame] | 444 | session_count_new(sess); |
Christopher Faulet | 7ce0c89 | 2018-04-10 15:01:45 +0200 | [diff] [blame] | 445 | if (conn_install_mux_fe(conn, NULL) < 0) |
Willy Tarreau | d1769b8 | 2015-04-06 00:25:48 +0200 | [diff] [blame] | 446 | goto fail; |
| 447 | |
Willy Tarreau | 87787ac | 2017-08-28 16:22:54 +0200 | [diff] [blame] | 448 | /* the embryonic session's task is not needed anymore */ |
Willy Tarreau | f656279 | 2019-05-07 19:05:35 +0200 | [diff] [blame] | 449 | task_destroy(sess->task); |
| 450 | sess->task = NULL; |
Willy Tarreau | 3e13cba | 2017-10-08 11:26:30 +0200 | [diff] [blame] | 451 | conn_set_owner(conn, sess, conn_session_free); |
| 452 | |
Willy Tarreau | d1769b8 | 2015-04-06 00:25:48 +0200 | [diff] [blame] | 453 | return 0; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 454 | |
Willy Tarreau | d1769b8 | 2015-04-06 00:25:48 +0200 | [diff] [blame] | 455 | fail: |
Willy Tarreau | 0c4ed35 | 2017-09-15 10:06:28 +0200 | [diff] [blame] | 456 | if (sess->task) |
Willy Tarreau | 086735a | 2018-11-05 15:09:47 +0100 | [diff] [blame] | 457 | session_kill_embryonic(sess, 0); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 458 | return -1; |
| 459 | } |
| 460 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 461 | /* |
| 462 | * Local variables: |
| 463 | * c-indent-level: 8 |
| 464 | * c-basic-offset: 8 |
| 465 | * End: |
| 466 | */ |