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 | |
| 169 | if (unlikely((t = task_new()) == NULL)) |
| 170 | goto out_free_sess; |
| 171 | |
| 172 | t->context = sess; |
| 173 | t->nice = l->nice; |
| 174 | |
| 175 | /* OK, now either we have a pending handshake to execute with and |
| 176 | * then we must return to the I/O layer, or we can proceed with the |
| 177 | * end of the stream initialization. In case of handshake, we also |
| 178 | * set the I/O timeout to the frontend's client timeout. |
| 179 | * |
| 180 | * At this point we set the relation between sess/task/conn this way : |
| 181 | * |
| 182 | * orig -- sess <-- context |
| 183 | * | | |
| 184 | * v | |
| 185 | * conn -- owner ---> task |
| 186 | */ |
| 187 | if (cli_conn->flags & CO_FL_HANDSHAKE) { |
| 188 | conn_attach(cli_conn, t, &sess_conn_cb); |
| 189 | t->process = session_expire_embryonic; |
| 190 | t->expire = tick_add_ifset(now_ms, p->timeout.client); |
| 191 | task_queue(t); |
| 192 | cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA; |
| 193 | return 1; |
| 194 | } |
| 195 | |
Willy Tarreau | 18b95a4 | 2015-04-05 01:04:01 +0200 | [diff] [blame] | 196 | /* OK let's complete stream initialization since there is no handshake */ |
| 197 | cli_conn->flags |= CO_FL_CONNECTED; |
Willy Tarreau | 9903f0e | 2015-04-04 18:50:31 +0200 | [diff] [blame] | 198 | ret = stream_accept_session(sess, t); |
| 199 | if (ret > 0) |
| 200 | return ret; |
| 201 | |
| 202 | task_free(t); |
| 203 | out_free_sess: |
| 204 | p->feconn--; |
| 205 | session_free(sess); |
| 206 | out_free_conn: |
| 207 | cli_conn->flags &= ~CO_FL_XPRT_TRACKED; |
| 208 | conn_xprt_close(cli_conn); |
| 209 | conn_free(cli_conn); |
| 210 | out_close: |
| 211 | if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) { |
| 212 | /* critical error, no more memory, try to emit a 500 response */ |
| 213 | struct chunk *err_msg = &p->errmsg[HTTP_ERR_500]; |
| 214 | if (!err_msg->str) |
| 215 | err_msg = &http_err_chunks[HTTP_ERR_500]; |
| 216 | send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL); |
| 217 | } |
| 218 | |
| 219 | if (fdtab[cfd].owner) |
| 220 | fd_delete(cfd); |
| 221 | else |
| 222 | close(cfd); |
| 223 | return ret; |
| 224 | } |
| 225 | |
| 226 | |
| 227 | /* prepare the trash with a log prefix for session <sess>. It only works with |
| 228 | * embryonic sessions based on a real connection. This function requires that |
| 229 | * at sess->origin points to the incoming connection. |
| 230 | */ |
| 231 | static void session_prepare_log_prefix(struct session *sess) |
| 232 | { |
| 233 | struct tm tm; |
| 234 | char pn[INET6_ADDRSTRLEN]; |
| 235 | int ret; |
| 236 | char *end; |
| 237 | struct connection *cli_conn = __objt_conn(sess->origin); |
| 238 | |
| 239 | ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn)); |
| 240 | if (ret <= 0) |
| 241 | chunk_printf(&trash, "unknown ["); |
| 242 | else if (ret == AF_UNIX) |
| 243 | chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid); |
| 244 | else |
| 245 | chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from)); |
| 246 | |
| 247 | get_localtime(sess->accept_date.tv_sec, &tm); |
| 248 | end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len); |
| 249 | trash.len = end - trash.str; |
| 250 | if (sess->listener->name) |
| 251 | chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name); |
| 252 | else |
| 253 | chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid); |
| 254 | } |
| 255 | |
| 256 | /* This function kills an existing embryonic session. It stops the connection's |
| 257 | * transport layer, releases assigned resources, resumes the listener if it was |
| 258 | * disabled and finally kills the file descriptor. This function requires that |
| 259 | * sess->origin points to the incoming connection. |
| 260 | */ |
| 261 | static void session_kill_embryonic(struct session *sess) |
| 262 | { |
| 263 | int level = LOG_INFO; |
| 264 | struct connection *conn = __objt_conn(sess->origin); |
| 265 | struct task *task = conn->owner; |
| 266 | unsigned int log = sess->fe->to_log; |
| 267 | const char *err_msg; |
| 268 | |
| 269 | if (sess->fe->options2 & PR_O2_LOGERRORS) |
| 270 | level = LOG_ERR; |
| 271 | |
| 272 | if (log && (sess->fe->options & PR_O_NULLNOLOG)) { |
| 273 | /* with "option dontlognull", we don't log connections with no transfer */ |
| 274 | if (!conn->err_code || |
| 275 | conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT || |
| 276 | conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT) |
| 277 | log = 0; |
| 278 | } |
| 279 | |
| 280 | if (log) { |
| 281 | if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) { |
| 282 | if (conn->flags & CO_FL_ACCEPT_PROXY) |
| 283 | conn->err_code = CO_ER_PRX_TIMEOUT; |
| 284 | else if (conn->flags & CO_FL_SSL_WAIT_HS) |
| 285 | conn->err_code = CO_ER_SSL_TIMEOUT; |
| 286 | } |
| 287 | |
| 288 | session_prepare_log_prefix(sess); |
| 289 | err_msg = conn_err_code_str(conn); |
| 290 | if (err_msg) |
| 291 | send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg); |
| 292 | else |
| 293 | send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n", |
| 294 | trash.str, conn->err_code, conn->flags); |
| 295 | } |
| 296 | |
| 297 | /* kill the connection now */ |
| 298 | conn_force_close(conn); |
| 299 | conn_free(conn); |
| 300 | |
| 301 | sess->fe->feconn--; |
| 302 | |
| 303 | if (!(sess->listener->options & LI_O_UNLIMITED)) |
| 304 | actconn--; |
| 305 | jobs--; |
| 306 | sess->listener->nbconn--; |
| 307 | if (sess->listener->state == LI_FULL) |
| 308 | resume_listener(sess->listener); |
| 309 | |
| 310 | /* Dequeues all of the listeners waiting for a resource */ |
| 311 | if (!LIST_ISEMPTY(&global_listener_queue)) |
| 312 | dequeue_all_listeners(&global_listener_queue); |
| 313 | |
| 314 | if (!LIST_ISEMPTY(&sess->fe->listener_queue) && |
| 315 | (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0)) |
| 316 | dequeue_all_listeners(&sess->fe->listener_queue); |
| 317 | |
| 318 | task_delete(task); |
| 319 | task_free(task); |
| 320 | session_free(sess); |
| 321 | } |
| 322 | |
| 323 | /* Manages the embryonic session timeout. It is only called when the timeout |
| 324 | * strikes and performs the required cleanup. |
| 325 | */ |
| 326 | static struct task *session_expire_embryonic(struct task *t) |
| 327 | { |
| 328 | struct session *sess = t->context; |
| 329 | |
| 330 | if (!(t->state & TASK_WOKEN_TIMER)) |
| 331 | return t; |
| 332 | |
| 333 | session_kill_embryonic(sess); |
| 334 | return NULL; |
| 335 | } |
| 336 | |
| 337 | /* Finish initializing a session from a connection, or kills it if the |
| 338 | * connection shows and error. Returns <0 if the connection was killed. |
| 339 | */ |
| 340 | static int conn_complete_session(struct connection *conn) |
| 341 | { |
| 342 | struct task *task = conn->owner; |
| 343 | struct session *sess = task->context; |
| 344 | |
| 345 | if (!(conn->flags & CO_FL_ERROR) && (stream_accept_session(sess, task) > 0)) { |
| 346 | conn->flags &= ~CO_FL_INIT_DATA; |
| 347 | return 0; |
| 348 | } |
| 349 | |
| 350 | session_kill_embryonic(sess); |
| 351 | return -1; |
| 352 | } |
| 353 | |
| 354 | /* Update a session status. The connection is killed in case of |
| 355 | * error, and <0 will be returned. Otherwise it does nothing. |
| 356 | */ |
| 357 | static int conn_update_session(struct connection *conn) |
| 358 | { |
| 359 | struct task *task = conn->owner; |
| 360 | struct session *sess = task->context; |
| 361 | |
| 362 | if (conn->flags & CO_FL_ERROR) { |
| 363 | session_kill_embryonic(sess); |
| 364 | return -1; |
| 365 | } |
| 366 | return 0; |
| 367 | } |
| 368 | |
Willy Tarreau | b1ec8c4 | 2015-04-03 13:53:24 +0200 | [diff] [blame] | 369 | /* |
| 370 | * Local variables: |
| 371 | * c-indent-level: 8 |
| 372 | * c-basic-offset: 8 |
| 373 | * End: |
| 374 | */ |