rxrpc: Permit multiple service binding

Permit bind() to be called on an AF_RXRPC socket more than once (currently
maximum twice) to bind multiple listening services to it.  There are some
restrictions:

 (1) All bind() calls involved must have a non-zero service ID.

 (2) The service IDs must all be different.

 (3) The rest of the address (notably the transport part) must be the same
     in all (a single UDP socket is shared).

 (4) This must be done before listen() or sendmsg() is called.

This allows someone to connect to the service socket with different service
IDs and lays the foundation for service upgrading.

The service ID used by an incoming call can be extracted from the msg_name
returned by recvmsg().

Signed-off-by: David Howells <[email protected]>

diff --git a/Documentation/networking/rxrpc.txt b/Documentation/networking/rxrpc.txt
index 1b63bbc6b94f4fb748aec6752a026319b59f8882..b7115ec55e04ed9d1ee868d9514212997b8fa03c 100644 (file)
--- a/Documentation/networking/rxrpc.txt
+++ b/Documentation/networking/rxrpc.txt
@@ -600,6 +600,10 @@ A server would be set up to accept operations in the following manner:
        };
        bind(server, &srx, sizeof(srx));
 
+     More than one service ID may be bound to a socket, provided the transport
+     parameters are the same.  The limit is currently two.  To do this, bind()
+     should be called twice.
+
  (3) The server is then set to listen out for incoming calls:
 
        listen(server, 100);

diff --git a/net/rxrpc/af_rxrpc.c b/net/rxrpc/af_rxrpc.c
index 1e4ac889ec00d35cc94aae1165c518554f75565f..3b982bca7d22d029fc134042aeb4376a6dd6d4f4 100644 (file)
--- a/net/rxrpc/af_rxrpc.c
+++ b/net/rxrpc/af_rxrpc.c
@@ -144,31 +144,48 @@ static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
 
        lock_sock(&rx->sk);
 
-       if (rx->sk.sk_state != RXRPC_UNBOUND) {
-               ret = -EINVAL;
-               goto error_unlock;
-       }
-
-       memcpy(&rx->srx, srx, sizeof(rx->srx));
+       switch (rx->sk.sk_state) {
+       case RXRPC_UNBOUND:
+               rx->srx = *srx;
+               local = rxrpc_lookup_local(sock_net(&rx->sk), &rx->srx);
+               if (IS_ERR(local)) {
+                       ret = PTR_ERR(local);
+                       goto error_unlock;
+               }
 
-       local = rxrpc_lookup_local(sock_net(&rx->sk), &rx->srx);
-       if (IS_ERR(local)) {
-               ret = PTR_ERR(local);
-               goto error_unlock;
-       }
+               if (service_id) {
+                       write_lock(&local->services_lock);
+                       if (rcu_access_pointer(local->service))
+                               goto service_in_use;
+                       rx->local = local;
+                       rcu_assign_pointer(local->service, rx);
+                       write_unlock(&local->services_lock);
+
+                       rx->sk.sk_state = RXRPC_SERVER_BOUND;
+               } else {
+                       rx->local = local;
+                       rx->sk.sk_state = RXRPC_CLIENT_BOUND;
+               }
+               break;
 
-       if (service_id) {
-               write_lock(&local->services_lock);
-               if (rcu_access_pointer(local->service))
-                       goto service_in_use;
-               rx->local = local;
-               rcu_assign_pointer(local->service, rx);
-               write_unlock(&local->services_lock);
+       case RXRPC_SERVER_BOUND:
+               ret = -EINVAL;
+               if (service_id == 0)
+                       goto error_unlock;
+               ret = -EADDRINUSE;
+               if (service_id == rx->srx.srx_service)
+                       goto error_unlock;
+               ret = -EINVAL;
+               srx->srx_service = rx->srx.srx_service;
+               if (memcmp(srx, &rx->srx, sizeof(*srx)) != 0)
+                       goto error_unlock;
+               rx->second_service = service_id;
+               rx->sk.sk_state = RXRPC_SERVER_BOUND2;
+               break;
 
-               rx->sk.sk_state = RXRPC_SERVER_BOUND;
-       } else {
-               rx->local = local;
-               rx->sk.sk_state = RXRPC_CLIENT_BOUND;
+       default:
+               ret = -EINVAL;
+               goto error_unlock;
        }
 
        release_sock(&rx->sk);
@@ -205,6 +222,7 @@ static int rxrpc_listen(struct socket *sock, int backlog)
                ret = -EADDRNOTAVAIL;
                break;
        case RXRPC_SERVER_BOUND:
+       case RXRPC_SERVER_BOUND2:
                ASSERT(rx->local != NULL);
                max = READ_ONCE(rxrpc_max_backlog);
                ret = -EINVAL;

diff --git a/net/rxrpc/ar-internal.h b/net/rxrpc/ar-internal.h
index de98a49adb359470dd926607f707117972f5186f..781fbc253b5a22c03aff487d5e9d0f7693936cb9 100644 (file)
--- a/net/rxrpc/ar-internal.h
+++ b/net/rxrpc/ar-internal.h
@@ -61,6 +61,7 @@ enum {
        RXRPC_CLIENT_UNBOUND,           /* Unbound socket used as client */
        RXRPC_CLIENT_BOUND,             /* client local address bound */
        RXRPC_SERVER_BOUND,             /* server local address bound */
+       RXRPC_SERVER_BOUND2,            /* second server local address bound */
        RXRPC_SERVER_LISTENING,         /* server listening for connections */
        RXRPC_SERVER_LISTEN_DISABLED,   /* server listening disabled */
        RXRPC_CLOSE,                    /* socket is being closed */
@@ -142,6 +143,7 @@ struct rxrpc_sock {
        u32                     min_sec_level;  /* minimum security level */
 #define RXRPC_SECURITY_MAX     RXRPC_SECURITY_ENCRYPT
        bool                    exclusive;      /* Exclusive connection for a client socket */
+       u16                     second_service; /* Additional service bound to the endpoint */
        sa_family_t             family;         /* Protocol family created with */
        struct sockaddr_rxrpc   srx;            /* local address */
        struct sockaddr_rxrpc   connect_srx;    /* Default client address from connect() */

diff --git a/net/rxrpc/call_accept.c b/net/rxrpc/call_accept.c
index a8515b0d4717e7f53afdfc990eb0dcbe6387ae7d..544df53ccf790fe3bd9695d22629c372bf678551 100644 (file)
--- a/net/rxrpc/call_accept.c
+++ b/net/rxrpc/call_accept.c
@@ -341,7 +341,8 @@ struct rxrpc_call *rxrpc_new_incoming_call(struct rxrpc_local *local,
 
        /* Get the socket providing the service */
        rx = rcu_dereference(local->service);
-       if (rx && service_id == rx->srx.srx_service)
+       if (rx && (service_id == rx->srx.srx_service ||
+                  service_id == rx->second_service))
                goto found_service;
 
        trace_rxrpc_abort("INV", sp->hdr.cid, sp->hdr.callNumber, sp->hdr.seq,

diff --git a/net/rxrpc/local_object.c b/net/rxrpc/local_object.c
index 17d79fd73ade47647ec7c68e0ca88f34931b1597..38b99db30e541e789b838e10600944f11b4124e0 100644 (file)
--- a/net/rxrpc/local_object.c
+++ b/net/rxrpc/local_object.c
@@ -94,6 +94,7 @@ static struct rxrpc_local *rxrpc_alloc_local(struct rxrpc_net *rxnet,
                rwlock_init(&local->services_lock);
                local->debug_id = atomic_inc_return(&rxrpc_debug_id);
                memcpy(&local->srx, srx, sizeof(*srx));
+               local->srx.srx_service = 0;
        }
 
        _leave(" = %p", local);

diff --git a/net/rxrpc/security.c b/net/rxrpc/security.c
index b9f5dbbe0b8b761284e96df9e8a45f80ede30c85..e9f4283512938e4821e11e844c3e140defab6034 100644 (file)
--- a/net/rxrpc/security.c
+++ b/net/rxrpc/security.c
@@ -133,7 +133,8 @@ int rxrpc_init_server_conn_security(struct rxrpc_connection *conn)
        read_lock(&local->services_lock);
        rx = rcu_dereference_protected(local->service,
                                       lockdep_is_held(&local->services_lock));
-       if (rx && rx->srx.srx_service == conn->service_id)
+       if (rx && (rx->srx.srx_service == conn->service_id ||
+                  rx->second_service == conn->service_id))
                goto found_service;
 
        /* the service appears to have died */