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> |
| 16 | #include <common/memory.h> |
| 17 | |
| 18 | #include <types/global.h> |
| 19 | #include <types/session.h> |
| 20 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 21 | #include <proto/connection.h> |
| 22 | #include <proto/listener.h> |
| 23 | #include <proto/log.h> |
| 24 | #include <proto/proto_http.h> |
| 25 | #include <proto/proto_tcp.h> |
| 26 | #include <proto/proxy.h> |
| 27 | #include <proto/raw_sock.h> |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 28 | #include <proto/session.h> |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 29 | #include <proto/stream.h> |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 30 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 31 | struct pool_head *pool2_session; |
| 32 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 33 | static int conn_complete_session(struct connection *conn); |
| 34 | static int conn_update_session(struct connection *conn); |
| 35 | static struct task *session_expire_embryonic(struct task *t); |
| 36 | |
| 37 | /* data layer callbacks for an embryonic stream */ |
| 38 | struct data_cb sess_conn_cb = { |
| 39 | .recv = NULL, |
| 40 | .send = NULL, |
| 41 | .wake = conn_update_session, |
| 42 | .init = conn_complete_session, |
| 43 | }; |
| 44 | |
Willy Tarreau | c38f71c | 2015-04-05 00:38:48 +0200 | [diff] [blame] | 45 | /* Create a a new session and assign it to frontend <fe>, listener <li>, |
| 46 | * origin <origin>, set the current date and clear the stick counters pointers. |
| 47 | * Returns the session upon success or NULL. The session may be released using |
| 48 | * session_free(). |
| 49 | */ |
| 50 | struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin) |
| 51 | { |
| 52 | struct session *sess; |
| 53 | |
| 54 | sess = pool_alloc2(pool2_session); |
| 55 | if (sess) { |
| 56 | sess->listener = li; |
| 57 | sess->fe = fe; |
| 58 | sess->origin = origin; |
| 59 | sess->accept_date = date; /* user-visible date for logging */ |
| 60 | sess->tv_accept = now; /* corrected date for internal use */ |
| 61 | memset(sess->stkctr, 0, sizeof(sess->stkctr)); |
| 62 | } |
| 63 | return sess; |
| 64 | } |
| 65 | |
Willy Tarreau | 11c3624 | 2015-04-04 15:54:03 +0200 | [diff] [blame] | 66 | void session_free(struct session *sess) |
| 67 | { |
Willy Tarreau | bb2ef12 | 2015-04-04 16:31:16 +0200 | [diff] [blame] | 68 | session_store_counters(sess); |
Willy Tarreau | 11c3624 | 2015-04-04 15:54:03 +0200 | [diff] [blame] | 69 | pool_free2(pool2_session, sess); |
| 70 | } |
| 71 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 72 | /* perform minimal intializations, report 0 in case of error, 1 if OK. */ |
| 73 | int init_session() |
| 74 | { |
| 75 | pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED); |
| 76 | return pool2_session != NULL; |
| 77 | } |
| 78 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 79 | /* This function is called from the protocol layer accept() in order to |
| 80 | * instanciate a new session on behalf of a given listener and frontend. It |
| 81 | * returns a positive value upon success, 0 if the connection can be ignored, |
| 82 | * or a negative value upon critical failure. The accepted file descriptor is |
| 83 | * closed if we return <= 0. If no handshake is needed, it immediately tries |
| 84 | * to instanciate a new stream. |
| 85 | */ |
| 86 | int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr) |
| 87 | { |
| 88 | struct connection *cli_conn; |
| 89 | struct proxy *p = l->frontend; |
| 90 | struct session *sess; |
| 91 | struct task *t; |
| 92 | int ret; |
| 93 | |
| 94 | |
| 95 | ret = -1; /* assume unrecoverable error by default */ |
| 96 | |
| 97 | if (unlikely((cli_conn = conn_new()) == NULL)) |
| 98 | goto out_close; |
| 99 | |
| 100 | conn_prepare(cli_conn, l->proto, l->xprt); |
| 101 | |
| 102 | cli_conn->t.sock.fd = cfd; |
| 103 | cli_conn->addr.from = *addr; |
| 104 | cli_conn->flags |= CO_FL_ADDR_FROM_SET; |
| 105 | cli_conn->target = &l->obj_type; |
| 106 | cli_conn->proxy_netns = l->netns; |
| 107 | |
| 108 | conn_ctrl_init(cli_conn); |
| 109 | |
| 110 | /* wait for a PROXY protocol header */ |
| 111 | if (l->options & LI_O_ACC_PROXY) { |
| 112 | cli_conn->flags |= CO_FL_ACCEPT_PROXY; |
| 113 | conn_sock_want_recv(cli_conn); |
| 114 | } |
| 115 | |
| 116 | conn_data_want_recv(cli_conn); |
| 117 | if (conn_xprt_init(cli_conn) < 0) |
| 118 | goto out_free_conn; |
| 119 | |
Willy Tarreau | 64beab2 | 2015-04-05 00:39:16 +0200 | [diff] [blame] | 120 | sess = session_new(p, l, &cli_conn->obj_type); |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 121 | if (!sess) |
| 122 | goto out_free_conn; |
| 123 | |
| 124 | p->feconn++; |
| 125 | /* This session was accepted, count it now */ |
| 126 | if (p->feconn > p->fe_counters.conn_max) |
| 127 | p->fe_counters.conn_max = p->feconn; |
| 128 | |
| 129 | proxy_inc_fe_conn_ctr(l, p); |
| 130 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 131 | /* now evaluate the tcp-request layer4 rules. We only need a session |
| 132 | * and no stream for these rules. |
| 133 | */ |
| 134 | if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(sess)) { |
| 135 | /* let's do a no-linger now to close with a single RST. */ |
| 136 | setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger)); |
| 137 | ret = 0; /* successful termination */ |
| 138 | goto out_free_sess; |
| 139 | } |
| 140 | |
| 141 | /* monitor-net and health mode are processed immediately after TCP |
| 142 | * connection rules. This way it's possible to block them, but they |
| 143 | * never use the lower data layers, they send directly over the socket, |
| 144 | * as they were designed for. We first flush the socket receive buffer |
| 145 | * in order to avoid emission of an RST by the system. We ignore any |
| 146 | * error. |
| 147 | */ |
| 148 | if (unlikely((p->mode == PR_MODE_HEALTH) || |
| 149 | ((l->options & LI_O_CHK_MONNET) && |
| 150 | addr->ss_family == AF_INET && |
| 151 | (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) { |
| 152 | /* we have 4 possibilities here : |
| 153 | * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK" |
| 154 | * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK" |
| 155 | * - HEALTH mode without HTTP check => just send "OK" |
| 156 | * - TCP mode from monitoring address => just close |
| 157 | */ |
| 158 | if (l->proto->drain) |
| 159 | l->proto->drain(cfd); |
| 160 | if (p->mode == PR_MODE_HTTP || |
| 161 | (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK)) |
| 162 | send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE); |
| 163 | else if (p->mode == PR_MODE_HEALTH) |
| 164 | send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE); |
| 165 | ret = 0; |
| 166 | goto out_free_sess; |
| 167 | } |
| 168 | |
Willy Tarreau | f9d1bc6 | 2015-04-05 17:56:47 +0200 | [diff] [blame] | 169 | /* Adjust some socket options */ |
| 170 | if (l->addr.ss_family == AF_INET || l->addr.ss_family == AF_INET6) { |
| 171 | setsockopt(cfd, IPPROTO_TCP, TCP_NODELAY, (char *) &one, sizeof(one)); |
| 172 | |
| 173 | if (p->options & PR_O_TCP_CLI_KA) |
| 174 | setsockopt(cfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &one, sizeof(one)); |
| 175 | |
| 176 | if (p->options & PR_O_TCP_NOLING) |
| 177 | fdtab[cfd].linger_risk = 1; |
| 178 | |
| 179 | #if defined(TCP_MAXSEG) |
| 180 | if (l->maxseg < 0) { |
| 181 | /* we just want to reduce the current MSS by that value */ |
| 182 | int mss; |
| 183 | socklen_t mss_len = sizeof(mss); |
| 184 | if (getsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &mss_len) == 0) { |
| 185 | mss += l->maxseg; /* remember, it's < 0 */ |
| 186 | setsockopt(cfd, IPPROTO_TCP, TCP_MAXSEG, &mss, sizeof(mss)); |
| 187 | } |
| 188 | } |
| 189 | #endif |
| 190 | } |
| 191 | |
| 192 | if (global.tune.client_sndbuf) |
| 193 | setsockopt(cfd, SOL_SOCKET, SO_SNDBUF, &global.tune.client_sndbuf, sizeof(global.tune.client_sndbuf)); |
| 194 | |
| 195 | if (global.tune.client_rcvbuf) |
| 196 | setsockopt(cfd, SOL_SOCKET, SO_RCVBUF, &global.tune.client_rcvbuf, sizeof(global.tune.client_rcvbuf)); |
| 197 | |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 198 | if (unlikely((t = task_new()) == NULL)) |
| 199 | goto out_free_sess; |
| 200 | |
| 201 | t->context = sess; |
| 202 | t->nice = l->nice; |
| 203 | |
| 204 | /* OK, now either we have a pending handshake to execute with and |
| 205 | * then we must return to the I/O layer, or we can proceed with the |
| 206 | * end of the stream initialization. In case of handshake, we also |
| 207 | * set the I/O timeout to the frontend's client timeout. |
| 208 | * |
| 209 | * At this point we set the relation between sess/task/conn this way : |
| 210 | * |
| 211 | * orig -- sess <-- context |
| 212 | * | | |
| 213 | * v | |
| 214 | * conn -- owner ---> task |
| 215 | */ |
| 216 | if (cli_conn->flags & CO_FL_HANDSHAKE) { |
| 217 | conn_attach(cli_conn, t, &sess_conn_cb); |
| 218 | t->process = session_expire_embryonic; |
| 219 | t->expire = tick_add_ifset(now_ms, p->timeout.client); |
| 220 | task_queue(t); |
| 221 | cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA; |
| 222 | return 1; |
| 223 | } |
| 224 | |
Willy Tarreau | 18b95a4 | 2015-04-05 01:04:01 +0200 | [diff] [blame] | 225 | /* OK let's complete stream initialization since there is no handshake */ |
| 226 | cli_conn->flags |= CO_FL_CONNECTED; |
Willy Tarreau | 02d8638 | 2015-04-05 12:00:52 +0200 | [diff] [blame] | 227 | if (stream_new(sess, t)) |
| 228 | return 1; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 229 | |
| 230 | task_free(t); |
| 231 | out_free_sess: |
| 232 | p->feconn--; |
| 233 | session_free(sess); |
| 234 | out_free_conn: |
| 235 | cli_conn->flags &= ~CO_FL_XPRT_TRACKED; |
| 236 | conn_xprt_close(cli_conn); |
| 237 | conn_free(cli_conn); |
| 238 | out_close: |
| 239 | if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) { |
| 240 | /* critical error, no more memory, try to emit a 500 response */ |
| 241 | struct chunk *err_msg = &p->errmsg[HTTP_ERR_500]; |
| 242 | if (!err_msg->str) |
| 243 | err_msg = &http_err_chunks[HTTP_ERR_500]; |
| 244 | send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL); |
| 245 | } |
| 246 | |
| 247 | if (fdtab[cfd].owner) |
| 248 | fd_delete(cfd); |
| 249 | else |
| 250 | close(cfd); |
| 251 | return ret; |
| 252 | } |
| 253 | |
| 254 | |
| 255 | /* prepare the trash with a log prefix for session <sess>. It only works with |
| 256 | * embryonic sessions based on a real connection. This function requires that |
| 257 | * at sess->origin points to the incoming connection. |
| 258 | */ |
| 259 | static void session_prepare_log_prefix(struct session *sess) |
| 260 | { |
| 261 | struct tm tm; |
| 262 | char pn[INET6_ADDRSTRLEN]; |
| 263 | int ret; |
| 264 | char *end; |
| 265 | struct connection *cli_conn = __objt_conn(sess->origin); |
| 266 | |
| 267 | ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn)); |
| 268 | if (ret <= 0) |
| 269 | chunk_printf(&trash, "unknown ["); |
| 270 | else if (ret == AF_UNIX) |
| 271 | chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid); |
| 272 | else |
| 273 | chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from)); |
| 274 | |
| 275 | get_localtime(sess->accept_date.tv_sec, &tm); |
| 276 | end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len); |
| 277 | trash.len = end - trash.str; |
| 278 | if (sess->listener->name) |
| 279 | chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name); |
| 280 | else |
| 281 | chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid); |
| 282 | } |
| 283 | |
| 284 | /* This function kills an existing embryonic session. It stops the connection's |
| 285 | * transport layer, releases assigned resources, resumes the listener if it was |
| 286 | * disabled and finally kills the file descriptor. This function requires that |
| 287 | * sess->origin points to the incoming connection. |
| 288 | */ |
| 289 | static void session_kill_embryonic(struct session *sess) |
| 290 | { |
| 291 | int level = LOG_INFO; |
| 292 | struct connection *conn = __objt_conn(sess->origin); |
| 293 | struct task *task = conn->owner; |
| 294 | unsigned int log = sess->fe->to_log; |
| 295 | const char *err_msg; |
| 296 | |
| 297 | if (sess->fe->options2 & PR_O2_LOGERRORS) |
| 298 | level = LOG_ERR; |
| 299 | |
| 300 | if (log && (sess->fe->options & PR_O_NULLNOLOG)) { |
| 301 | /* with "option dontlognull", we don't log connections with no transfer */ |
| 302 | if (!conn->err_code || |
| 303 | conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT || |
| 304 | conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT) |
| 305 | log = 0; |
| 306 | } |
| 307 | |
| 308 | if (log) { |
| 309 | if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) { |
| 310 | if (conn->flags & CO_FL_ACCEPT_PROXY) |
| 311 | conn->err_code = CO_ER_PRX_TIMEOUT; |
| 312 | else if (conn->flags & CO_FL_SSL_WAIT_HS) |
| 313 | conn->err_code = CO_ER_SSL_TIMEOUT; |
| 314 | } |
| 315 | |
| 316 | session_prepare_log_prefix(sess); |
| 317 | err_msg = conn_err_code_str(conn); |
| 318 | if (err_msg) |
| 319 | send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg); |
| 320 | else |
| 321 | send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n", |
| 322 | trash.str, conn->err_code, conn->flags); |
| 323 | } |
| 324 | |
| 325 | /* kill the connection now */ |
| 326 | conn_force_close(conn); |
| 327 | conn_free(conn); |
| 328 | |
| 329 | sess->fe->feconn--; |
| 330 | |
| 331 | if (!(sess->listener->options & LI_O_UNLIMITED)) |
| 332 | actconn--; |
| 333 | jobs--; |
| 334 | sess->listener->nbconn--; |
| 335 | if (sess->listener->state == LI_FULL) |
| 336 | resume_listener(sess->listener); |
| 337 | |
| 338 | /* Dequeues all of the listeners waiting for a resource */ |
| 339 | if (!LIST_ISEMPTY(&global_listener_queue)) |
| 340 | dequeue_all_listeners(&global_listener_queue); |
| 341 | |
| 342 | if (!LIST_ISEMPTY(&sess->fe->listener_queue) && |
| 343 | (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0)) |
| 344 | dequeue_all_listeners(&sess->fe->listener_queue); |
| 345 | |
| 346 | task_delete(task); |
| 347 | task_free(task); |
| 348 | session_free(sess); |
| 349 | } |
| 350 | |
| 351 | /* Manages the embryonic session timeout. It is only called when the timeout |
| 352 | * strikes and performs the required cleanup. |
| 353 | */ |
| 354 | static struct task *session_expire_embryonic(struct task *t) |
| 355 | { |
| 356 | struct session *sess = t->context; |
| 357 | |
| 358 | if (!(t->state & TASK_WOKEN_TIMER)) |
| 359 | return t; |
| 360 | |
| 361 | session_kill_embryonic(sess); |
| 362 | return NULL; |
| 363 | } |
| 364 | |
| 365 | /* Finish initializing a session from a connection, or kills it if the |
| 366 | * connection shows and error. Returns <0 if the connection was killed. |
| 367 | */ |
| 368 | static int conn_complete_session(struct connection *conn) |
| 369 | { |
| 370 | struct task *task = conn->owner; |
| 371 | struct session *sess = task->context; |
| 372 | |
Willy Tarreau | 02d8638 | 2015-04-05 12:00:52 +0200 | [diff] [blame] | 373 | if (!(conn->flags & CO_FL_ERROR) && (stream_new(sess, task) != NULL)) { |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 374 | conn->flags &= ~CO_FL_INIT_DATA; |
| 375 | return 0; |
| 376 | } |
| 377 | |
| 378 | session_kill_embryonic(sess); |
| 379 | return -1; |
| 380 | } |
| 381 | |
| 382 | /* Update a session status. The connection is killed in case of |
| 383 | * error, and <0 will be returned. Otherwise it does nothing. |
| 384 | */ |
| 385 | static int conn_update_session(struct connection *conn) |
| 386 | { |
| 387 | struct task *task = conn->owner; |
| 388 | struct session *sess = task->context; |
| 389 | |
| 390 | if (conn->flags & CO_FL_ERROR) { |
| 391 | session_kill_embryonic(sess); |
| 392 | return -1; |
| 393 | } |
| 394 | return 0; |
| 395 | } |
| 396 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 397 | /* |
| 398 | * Local variables: |
| 399 | * c-indent-level: 8 |
| 400 | * c-basic-offset: 8 |
| 401 | * End: |
| 402 | */ |