Merge tag 'char-misc-5.6-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[linux-2.6-microblaze.git] / net / mptcp / token.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Multipath TCP token management
3  * Copyright (c) 2017 - 2019, Intel Corporation.
4  *
5  * Note: This code is based on mptcp_ctrl.c from multipath-tcp.org,
6  *       authored by:
7  *
8  *       Sébastien Barré <sebastien.barre@uclouvain.be>
9  *       Christoph Paasch <christoph.paasch@uclouvain.be>
10  *       Jaakko Korkeaniemi <jaakko.korkeaniemi@aalto.fi>
11  *       Gregory Detal <gregory.detal@uclouvain.be>
12  *       Fabien Duchêne <fabien.duchene@uclouvain.be>
13  *       Andreas Seelinger <Andreas.Seelinger@rwth-aachen.de>
14  *       Lavkesh Lahngir <lavkesh51@gmail.com>
15  *       Andreas Ripke <ripke@neclab.eu>
16  *       Vlad Dogaru <vlad.dogaru@intel.com>
17  *       Octavian Purdila <octavian.purdila@intel.com>
18  *       John Ronan <jronan@tssg.org>
19  *       Catalin Nicutar <catalin.nicutar@gmail.com>
20  *       Brandon Heller <brandonh@stanford.edu>
21  */
22
23 #define pr_fmt(fmt) "MPTCP: " fmt
24
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/radix-tree.h>
28 #include <linux/ip.h>
29 #include <linux/tcp.h>
30 #include <net/sock.h>
31 #include <net/inet_common.h>
32 #include <net/protocol.h>
33 #include <net/mptcp.h>
34 #include "protocol.h"
35
36 static RADIX_TREE(token_tree, GFP_ATOMIC);
37 static RADIX_TREE(token_req_tree, GFP_ATOMIC);
38 static DEFINE_SPINLOCK(token_tree_lock);
39 static int token_used __read_mostly;
40
41 /**
42  * mptcp_token_new_request - create new key/idsn/token for subflow_request
43  * @req - the request socket
44  *
45  * This function is called when a new mptcp connection is coming in.
46  *
47  * It creates a unique token to identify the new mptcp connection,
48  * a secret local key and the initial data sequence number (idsn).
49  *
50  * Returns 0 on success.
51  */
52 int mptcp_token_new_request(struct request_sock *req)
53 {
54         struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
55         int err;
56
57         while (1) {
58                 u32 token;
59
60                 mptcp_crypto_key_gen_sha(&subflow_req->local_key,
61                                          &subflow_req->token,
62                                          &subflow_req->idsn);
63                 pr_debug("req=%p local_key=%llu, token=%u, idsn=%llu\n",
64                          req, subflow_req->local_key, subflow_req->token,
65                          subflow_req->idsn);
66
67                 token = subflow_req->token;
68                 spin_lock_bh(&token_tree_lock);
69                 if (!radix_tree_lookup(&token_req_tree, token) &&
70                     !radix_tree_lookup(&token_tree, token))
71                         break;
72                 spin_unlock_bh(&token_tree_lock);
73         }
74
75         err = radix_tree_insert(&token_req_tree,
76                                 subflow_req->token, &token_used);
77         spin_unlock_bh(&token_tree_lock);
78         return err;
79 }
80
81 /**
82  * mptcp_token_new_connect - create new key/idsn/token for subflow
83  * @sk - the socket that will initiate a connection
84  *
85  * This function is called when a new outgoing mptcp connection is
86  * initiated.
87  *
88  * It creates a unique token to identify the new mptcp connection,
89  * a secret local key and the initial data sequence number (idsn).
90  *
91  * On success, the mptcp connection can be found again using
92  * the computed token at a later time, this is needed to process
93  * join requests.
94  *
95  * returns 0 on success.
96  */
97 int mptcp_token_new_connect(struct sock *sk)
98 {
99         struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
100         struct sock *mptcp_sock = subflow->conn;
101         int err;
102
103         while (1) {
104                 u32 token;
105
106                 mptcp_crypto_key_gen_sha(&subflow->local_key, &subflow->token,
107                                          &subflow->idsn);
108
109                 pr_debug("ssk=%p, local_key=%llu, token=%u, idsn=%llu\n",
110                          sk, subflow->local_key, subflow->token, subflow->idsn);
111
112                 token = subflow->token;
113                 spin_lock_bh(&token_tree_lock);
114                 if (!radix_tree_lookup(&token_req_tree, token) &&
115                     !radix_tree_lookup(&token_tree, token))
116                         break;
117                 spin_unlock_bh(&token_tree_lock);
118         }
119         err = radix_tree_insert(&token_tree, subflow->token, mptcp_sock);
120         spin_unlock_bh(&token_tree_lock);
121
122         return err;
123 }
124
125 /**
126  * mptcp_token_new_accept - insert token for later processing
127  * @token: the token to insert to the tree
128  *
129  * Called when a SYN packet creates a new logical connection, i.e.
130  * is not a join request.
131  *
132  * We don't have an mptcp socket yet at that point.
133  * This is paired with mptcp_token_update_accept, called on accept().
134  */
135 int mptcp_token_new_accept(u32 token)
136 {
137         int err;
138
139         spin_lock_bh(&token_tree_lock);
140         err = radix_tree_insert(&token_tree, token, &token_used);
141         spin_unlock_bh(&token_tree_lock);
142
143         return err;
144 }
145
146 /**
147  * mptcp_token_update_accept - update token to map to mptcp socket
148  * @conn: the new struct mptcp_sock
149  * @sk: the initial subflow for this mptcp socket
150  *
151  * Called when the first mptcp socket is created on accept to
152  * refresh the dummy mapping (done to reserve the token) with
153  * the mptcp_socket structure that wasn't allocated before.
154  */
155 void mptcp_token_update_accept(struct sock *sk, struct sock *conn)
156 {
157         struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
158         void __rcu **slot;
159
160         spin_lock_bh(&token_tree_lock);
161         slot = radix_tree_lookup_slot(&token_tree, subflow->token);
162         WARN_ON_ONCE(!slot);
163         if (slot) {
164                 WARN_ON_ONCE(rcu_access_pointer(*slot) != &token_used);
165                 radix_tree_replace_slot(&token_tree, slot, conn);
166         }
167         spin_unlock_bh(&token_tree_lock);
168 }
169
170 /**
171  * mptcp_token_destroy_request - remove mptcp connection/token
172  * @token - token of mptcp connection to remove
173  *
174  * Remove not-yet-fully-established incoming connection identified
175  * by @token.
176  */
177 void mptcp_token_destroy_request(u32 token)
178 {
179         spin_lock_bh(&token_tree_lock);
180         radix_tree_delete(&token_req_tree, token);
181         spin_unlock_bh(&token_tree_lock);
182 }
183
184 /**
185  * mptcp_token_destroy - remove mptcp connection/token
186  * @token - token of mptcp connection to remove
187  *
188  * Remove the connection identified by @token.
189  */
190 void mptcp_token_destroy(u32 token)
191 {
192         spin_lock_bh(&token_tree_lock);
193         radix_tree_delete(&token_tree, token);
194         spin_unlock_bh(&token_tree_lock);
195 }