REORG: session: move the session parts out of stream.c
This concerns everythins related to accepting a new session and
expiring the embryonic session. There's still a hard-coded call
to stream_accept_session() which could be set somewhere in the
frontend, but for now it's not a problem.
diff --git a/src/stream.c b/src/stream.c
index d55b0ba..e0dc824 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -56,328 +56,15 @@
/* list of streams waiting for at least one buffer */
struct list buffer_wq = LIST_HEAD_INIT(buffer_wq);
-static int conn_stream_complete(struct connection *conn);
-static int conn_stream_update(struct connection *conn);
-static struct task *expire_mini_session(struct task *t);
-int stream_complete(struct session *s, struct task *t);
-
-/* data layer callbacks for an embryonic stream */
-struct data_cb sess_conn_cb = {
- .recv = NULL,
- .send = NULL,
- .wake = conn_stream_update,
- .init = conn_stream_complete,
-};
-
-/* This function is called from the protocol layer accept() in order to
- * instanciate a new embryonic stream on behalf of a given listener and
- * frontend. It returns a positive value upon success, 0 if the connection
- * can be ignored, or a negative value upon critical failure. The accepted
- * file descriptor is closed if we return <= 0.
- */
-int stream_accept(struct listener *l, int cfd, struct sockaddr_storage *addr)
-{
- struct connection *cli_conn;
- struct proxy *p = l->frontend;
- struct session *sess;
- struct task *t;
- int ret;
-
-
- ret = -1; /* assume unrecoverable error by default */
-
- if (unlikely((cli_conn = conn_new()) == NULL))
- goto out_close;
-
- conn_prepare(cli_conn, l->proto, l->xprt);
-
- cli_conn->t.sock.fd = cfd;
- cli_conn->addr.from = *addr;
- cli_conn->flags |= CO_FL_ADDR_FROM_SET;
- cli_conn->target = &l->obj_type;
- cli_conn->proxy_netns = l->netns;
-
- conn_ctrl_init(cli_conn);
-
- /* wait for a PROXY protocol header */
- if (l->options & LI_O_ACC_PROXY) {
- cli_conn->flags |= CO_FL_ACCEPT_PROXY;
- conn_sock_want_recv(cli_conn);
- }
-
- /* Finish setting the callbacks. Right now the transport layer is present
- * but not initialized. Also note we need to be careful as the stream
- * int is not initialized yet.
- */
- conn_data_want_recv(cli_conn);
- if (conn_xprt_init(cli_conn) < 0)
- goto out_free_conn;
-
- sess = pool_alloc2(pool2_session);
- if (!sess)
- goto out_free_conn;
-
- p->feconn++;
- /* This session was accepted, count it now */
- if (p->feconn > p->fe_counters.conn_max)
- p->fe_counters.conn_max = p->feconn;
-
- proxy_inc_fe_conn_ctr(l, p);
-
- sess->listener = l;
- sess->fe = p;
- sess->origin = &cli_conn->obj_type;
- sess->accept_date = date; /* user-visible date for logging */
- sess->tv_accept = now; /* corrected date for internal use */
- memset(sess->stkctr, 0, sizeof(sess->stkctr));
-
- /* now evaluate the tcp-request layer4 rules. Since we expect to be able
- * to abort right here as soon as possible, we check the rules before
- * even initializing the stream interfaces.
- */
- if ((l->options & LI_O_TCP_RULES) && !tcp_exec_req_rules(sess)) {
- /* let's do a no-linger now to close with a single RST. */
- setsockopt(cfd, SOL_SOCKET, SO_LINGER, (struct linger *) &nolinger, sizeof(struct linger));
- ret = 0; /* successful termination */
- goto out_free_sess;
- }
-
- /* monitor-net and health mode are processed immediately after TCP
- * connection rules. This way it's possible to block them, but they
- * never use the lower data layers, they send directly over the socket,
- * as they were designed for. We first flush the socket receive buffer
- * in order to avoid emission of an RST by the system. We ignore any
- * error.
- */
- if (unlikely((p->mode == PR_MODE_HEALTH) ||
- ((l->options & LI_O_CHK_MONNET) &&
- addr->ss_family == AF_INET &&
- (((struct sockaddr_in *)addr)->sin_addr.s_addr & p->mon_mask.s_addr) == p->mon_net.s_addr))) {
- /* we have 4 possibilities here :
- * - HTTP mode, from monitoring address => send "HTTP/1.0 200 OK"
- * - HEALTH mode with HTTP check => send "HTTP/1.0 200 OK"
- * - HEALTH mode without HTTP check => just send "OK"
- * - TCP mode from monitoring address => just close
- */
- if (l->proto->drain)
- l->proto->drain(cfd);
- if (p->mode == PR_MODE_HTTP ||
- (p->mode == PR_MODE_HEALTH && (p->options2 & PR_O2_CHK_ANY) == PR_O2_HTTP_CHK))
- send(cfd, "HTTP/1.0 200 OK\r\n\r\n", 19, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
- else if (p->mode == PR_MODE_HEALTH)
- send(cfd, "OK\n", 3, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_MORE);
- ret = 0;
- goto out_free_sess;
- }
-
- if (unlikely((t = task_new()) == NULL))
- goto out_free_sess;
-
- t->context = sess;
- t->nice = l->nice;
-
- /* OK, now either we have a pending handshake to execute with and
- * then we must return to the I/O layer, or we can proceed with the
- * end of the stream initialization. In case of handshake, we also
- * set the I/O timeout to the frontend's client timeout.
- *
- * At this point we set the relation between sess/task/conn this way :
- *
- * orig -- sess <-- context
- * | |
- * v |
- * conn -- owner ---> task
- */
- if (cli_conn->flags & CO_FL_HANDSHAKE) {
- conn_attach(cli_conn, t, &sess_conn_cb);
- t->process = expire_mini_session;
- t->expire = tick_add_ifset(now_ms, p->timeout.client);
- task_queue(t);
- cli_conn->flags |= CO_FL_INIT_DATA | CO_FL_WAKE_DATA;
- return 1;
- }
-
- ret = stream_complete(sess, t);
- if (ret > 0)
- return ret;
-
- task_free(t);
- out_free_sess:
- p->feconn--;
- session_free(sess);
- out_free_conn:
- cli_conn->flags &= ~CO_FL_XPRT_TRACKED;
- conn_xprt_close(cli_conn);
- conn_free(cli_conn);
- out_close:
- if (ret < 0 && l->xprt == &raw_sock && p->mode == PR_MODE_HTTP) {
- /* critical error, no more memory, try to emit a 500 response */
- struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
- if (!err_msg->str)
- err_msg = &http_err_chunks[HTTP_ERR_500];
- send(cfd, err_msg->str, err_msg->len, MSG_DONTWAIT|MSG_NOSIGNAL);
- }
-
- if (fdtab[cfd].owner)
- fd_delete(cfd);
- else
- close(cfd);
- return ret;
-}
-
-
-/* prepare the trash with a log prefix for session <sess>. It only works with
- * embryonic streams based on a real connection. This function requires that
- * at sess->origin points to the incoming connection.
- */
-static void prepare_mini_sess_log_prefix(struct session *sess)
-{
- struct tm tm;
- char pn[INET6_ADDRSTRLEN];
- int ret;
- char *end;
- struct connection *cli_conn = __objt_conn(sess->origin);
-
- ret = addr_to_str(&cli_conn->addr.from, pn, sizeof(pn));
- if (ret <= 0)
- chunk_printf(&trash, "unknown [");
- else if (ret == AF_UNIX)
- chunk_printf(&trash, "%s:%d [", pn, sess->listener->luid);
- else
- chunk_printf(&trash, "%s:%d [", pn, get_host_port(&cli_conn->addr.from));
-
- get_localtime(sess->accept_date.tv_sec, &tm);
- end = date2str_log(trash.str + trash.len, &tm, &(sess->accept_date), trash.size - trash.len);
- trash.len = end - trash.str;
- if (sess->listener->name)
- chunk_appendf(&trash, "] %s/%s", sess->fe->id, sess->listener->name);
- else
- chunk_appendf(&trash, "] %s/%d", sess->fe->id, sess->listener->luid);
-}
-
-/* This function kills an existing embryonic stream. It stops the connection's
- * transport layer, releases assigned resources, resumes the listener if it was
- * disabled and finally kills the file descriptor. This function requires that
- * at sess->origin points to the incoming connection.
- */
-static void kill_mini_session(struct session *sess)
-{
- int level = LOG_INFO;
- struct connection *conn = __objt_conn(sess->origin);
- struct task *task = conn->owner;
- unsigned int log = sess->fe->to_log;
- const char *err_msg;
-
- if (sess->fe->options2 & PR_O2_LOGERRORS)
- level = LOG_ERR;
-
- if (log && (sess->fe->options & PR_O_NULLNOLOG)) {
- /* with "option dontlognull", we don't log connections with no transfer */
- if (!conn->err_code ||
- conn->err_code == CO_ER_PRX_EMPTY || conn->err_code == CO_ER_PRX_ABORT ||
- conn->err_code == CO_ER_SSL_EMPTY || conn->err_code == CO_ER_SSL_ABORT)
- log = 0;
- }
-
- if (log) {
- if (!conn->err_code && (task->state & TASK_WOKEN_TIMER)) {
- if (conn->flags & CO_FL_ACCEPT_PROXY)
- conn->err_code = CO_ER_PRX_TIMEOUT;
- else if (conn->flags & CO_FL_SSL_WAIT_HS)
- conn->err_code = CO_ER_SSL_TIMEOUT;
- }
-
- prepare_mini_sess_log_prefix(sess);
- err_msg = conn_err_code_str(conn);
- if (err_msg)
- send_log(sess->fe, level, "%s: %s\n", trash.str, err_msg);
- else
- send_log(sess->fe, level, "%s: unknown connection error (code=%d flags=%08x)\n",
- trash.str, conn->err_code, conn->flags);
- }
-
- /* kill the connection now */
- conn_force_close(conn);
- conn_free(conn);
-
- sess->fe->feconn--;
-
- if (!(sess->listener->options & LI_O_UNLIMITED))
- actconn--;
- jobs--;
- sess->listener->nbconn--;
- if (sess->listener->state == LI_FULL)
- resume_listener(sess->listener);
-
- /* Dequeues all of the listeners waiting for a resource */
- if (!LIST_ISEMPTY(&global_listener_queue))
- dequeue_all_listeners(&global_listener_queue);
-
- if (!LIST_ISEMPTY(&sess->fe->listener_queue) &&
- (!sess->fe->fe_sps_lim || freq_ctr_remain(&sess->fe->fe_sess_per_sec, sess->fe->fe_sps_lim, 0) > 0))
- dequeue_all_listeners(&sess->fe->listener_queue);
-
- task_delete(task);
- task_free(task);
- session_free(sess);
-}
-
-/* Finish initializing a stream from a connection, or kills it if the
- * connection shows and error. Returns <0 if the connection was killed.
- */
-static int conn_stream_complete(struct connection *conn)
-{
- struct task *task = conn->owner;
- struct session *sess = task->context;
-
- if (!(conn->flags & CO_FL_ERROR) && (stream_complete(sess, task) > 0)) {
- conn->flags &= ~CO_FL_INIT_DATA;
- return 0;
- }
-
- /* kill the connection now */
- kill_mini_session(sess);
- return -1;
-}
-
-/* Update an embryonic stream status. The connection is killed in case of
- * error, and <0 will be returned. Otherwise it does nothing.
- */
-static int conn_stream_update(struct connection *conn)
-{
- struct task *task = conn->owner;
- struct session *sess = task->context;
-
- if (conn->flags & CO_FL_ERROR) {
- kill_mini_session(sess);
- return -1;
- }
- return 0;
-}
-
-/* Manages embryonic streams timeout. It is only called when the timeout
- * strikes and performs the required cleanup.
- */
-static struct task *expire_mini_session(struct task *t)
-{
- struct session *sess = t->context;
-
- if (!(t->state & TASK_WOKEN_TIMER))
- return t;
-
- kill_mini_session(sess);
- return NULL;
-}
-
-/* This function is called from the I/O handler which detects the end of
+/* This function is called from the session handler which detects the end of
* handshake, in order to complete initialization of a valid stream. It must
- * be called with an embryonic stream. It returns a positive value upon
+ * be called with an embryonic session. It returns a positive value upon
* success, 0 if the connection can be ignored, or a negative value upon
* critical failure. The accepted file descriptor is closed if we return <= 0.
* The client-side end point is assumed to be a connection, whose pointer is
* taken from sess->origin which is assumed to be valid.
*/
-int stream_complete(struct session *sess, struct task *t)
+int stream_accept_session(struct session *sess, struct task *t)
{
struct stream *s;
struct listener *l = sess->listener;