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 }