MEDIUM: stream: return the stream upon accept()

The function was called stream_accept_session(), let's rename it
stream_new() and make it return the newly allocated pointer. It's
more convenient for some callers who need it.

diff --git a/include/proto/stream.h b/include/proto/stream.h
index 02992fd51e9ffaaef9d466b2aa0fde3696485d44..820cf47472206c8a287104961c24654435f23bbf 100644 (file)
--- a/include/proto/stream.h
+++ b/include/proto/stream.h
@@ -36,7 +36,7 @@ extern struct list buffer_wq;
 
 extern struct data_cb sess_conn_cb;
 
-int stream_accept_session(struct session *sess, struct task *t);
+struct stream *stream_new(struct session *sess, struct task *t);
 
 /* perform minimal intializations, report 0 in case of error, 1 if OK. */
 int init_stream();

diff --git a/src/peers.c b/src/peers.c
index 1b0fa10473e4579c2d33df501d0ffff253c2ac96..4899ee7a0a5dfaf4e38792f92e612e02ff3cbf0b 100644 (file)
--- a/src/peers.c
+++ b/src/peers.c
@@ -1140,7 +1140,7 @@ static struct stream *peer_session_create(struct peer *peer, struct peer_session
        }
        t->nice = l->nice;
 
-       if (stream_accept_session(sess, t) <= 0) {
+       if ((s = stream_new(sess, t)) == NULL) {
                Alert("Failed to initialize stream in peer_session_create().\n");
                goto out_free_task;
        }
@@ -1148,7 +1148,6 @@ static struct stream *peer_session_create(struct peer *peer, struct peer_session
        /* The tasks below are normally what is supposed to be done by
         * fe->accept().
         */
-       s = t->context;   // For now the session is not stored anywhere else :-/
        s->flags = SF_ASSIGNED|SF_ADDR_SET;
 
        /* initiate an outgoing connection */

diff --git a/src/session.c b/src/session.c
index 790f89aedf130d15d9ae0493b4bfe0c7d0929220..6dcbadb4c8381a10f612e953d0eacb31ac693b03 100644 (file)
--- a/src/session.c
+++ b/src/session.c
@@ -195,9 +195,8 @@ int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr
 
        /* OK let's complete stream initialization since there is no handshake */
        cli_conn->flags |= CO_FL_CONNECTED;
-       ret = stream_accept_session(sess, t);
-       if (ret > 0)
-               return ret;
+       if (stream_new(sess, t))
+               return 1;
 
        task_free(t);
  out_free_sess:
@@ -342,7 +341,7 @@ static int conn_complete_session(struct connection *conn)
        struct task *task = conn->owner;
        struct session *sess = task->context;
 
-       if (!(conn->flags & CO_FL_ERROR) && (stream_accept_session(sess, task) > 0)) {
+       if (!(conn->flags & CO_FL_ERROR) && (stream_new(sess, task) != NULL)) {
                conn->flags &= ~CO_FL_INIT_DATA;
                return 0;
        }

diff --git a/src/stream.c b/src/stream.c
index 1bcd2eb90b10f54669cc53e7bdcf8f6e7aaaa28c..3e2b5b663aa27a16b4d444104514d3ea038c913f 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -58,26 +58,21 @@ struct list buffer_wq = LIST_HEAD_INIT(buffer_wq);
 
 /* 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 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.
+ * be called with an embryonic session. It returns the pointer to the newly
+ * created stream, or NULL in case of fatal error. For now the client-side
+ * end point is taken from the session's origin, which must be valid.
  */
-int stream_accept_session(struct session *sess, struct task *t)
+struct stream *stream_new(struct session *sess, struct task *t)
 {
        struct stream *s;
        struct listener *l = sess->listener;
        struct proxy *p = sess->fe;
        struct connection *conn = objt_conn(sess->origin);
        struct appctx *appctx   = objt_appctx(sess->origin);
-       int ret;
        int i;
 
-       ret = -1; /* assume unrecoverable error by default */
-
        if (unlikely((s = pool_alloc2(pool2_stream)) == NULL))
-               goto out_return;
+               return s;
 
        /* minimum stream initialization required for an embryonic stream is
         * fairly low. We need very little to execute L4 ACLs, then we need a
@@ -230,14 +225,13 @@ int stream_accept_session(struct session *sess, struct task *t)
         * priorities to tasks.
         */
        task_wakeup(t, TASK_WOKEN_INIT);
-       return 1;
+       return s;
 
        /* Error unrolling */
  out_fail_accept:
        LIST_DEL(&s->list);
        pool_free2(pool2_stream, s);
- out_return:
-       return ret;
+       return NULL;
 }
 
 /*