net/mptcp/pm_userspace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Multipath TCP
   3  *
   4  * Copyright (c) 2022, Intel Corporation.
   5  */
   6
   7 #include "protocol.h"
   8 #include "mib.h"
   9
  10 void mptcp_free_local_addr_list(struct mptcp_sock *msk)
  11 {
  12         struct mptcp_pm_addr_entry *entry, *tmp;
  13         struct sock *sk = (struct sock *)msk;
  14         LIST_HEAD(free_list);
  15
  16         if (!mptcp_pm_is_userspace(msk))
  17                 return;
  18
  19         spin_lock_bh(&msk->pm.lock);
  20         list_splice_init(&msk->pm.userspace_pm_local_addr_list, &free_list);
  21         spin_unlock_bh(&msk->pm.lock);
  22
  23         list_for_each_entry_safe(entry, tmp, &free_list, list) {
  24                 sock_kfree_s(sk, entry, sizeof(*entry));
  25         }
  26 }
  27
  28 static int mptcp_userspace_pm_append_new_local_addr(struct mptcp_sock *msk,
  29                                                     struct mptcp_pm_addr_entry *entry,
  30                                                     bool needs_id)
  31 {
  32         DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
  33         struct mptcp_pm_addr_entry *match = NULL;
  34         struct sock *sk = (struct sock *)msk;
  35         struct mptcp_pm_addr_entry *e;
  36         bool addr_match = false;
  37         bool id_match = false;
  38         int ret = -EINVAL;
  39
  40         bitmap_zero(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
  41
  42         spin_lock_bh(&msk->pm.lock);
  43         list_for_each_entry(e, &msk->pm.userspace_pm_local_addr_list, list) {
  44                 addr_match = mptcp_addresses_equal(&e->addr, &entry->addr, true);
  45                 if (addr_match && entry->addr.id == 0 && needs_id)
  46                         entry->addr.id = e->addr.id;
  47                 id_match = (e->addr.id == entry->addr.id);
  48                 if (addr_match && id_match) {
  49                         match = e;
  50                         break;
  51                 } else if (addr_match || id_match) {
  52                         break;
  53                 }
  54                 __set_bit(e->addr.id, id_bitmap);
  55         }
  56
  57         if (!match && !addr_match && !id_match) {
  58                 /* Memory for the entry is allocated from the
  59                  * sock option buffer.
  60                  */
  61                 e = sock_kmalloc(sk, sizeof(*e), GFP_ATOMIC);
  62                 if (!e) {
  63                         ret = -ENOMEM;
  64                         goto append_err;
  65                 }
  66
  67                 *e = *entry;
  68                 if (!e->addr.id && needs_id)
  69                         e->addr.id = find_next_zero_bit(id_bitmap,
  70                                                         MPTCP_PM_MAX_ADDR_ID + 1,
  71                                                         1);
  72                 list_add_tail_rcu(&e->list, &msk->pm.userspace_pm_local_addr_list);
  73                 msk->pm.local_addr_used++;
  74                 ret = e->addr.id;
  75         } else if (match) {
  76                 ret = entry->addr.id;
  77         }
  78
  79 append_err:
  80         spin_unlock_bh(&msk->pm.lock);
  81         return ret;
  82 }
  83
  84 /* If the subflow is closed from the other peer (not via a
  85  * subflow destroy command then), we want to keep the entry
  86  * not to assign the same ID to another address and to be
  87  * able to send RM_ADDR after the removal of the subflow.
  88  */
  89 static int mptcp_userspace_pm_delete_local_addr(struct mptcp_sock *msk,
  90                                                 struct mptcp_pm_addr_entry *addr)
  91 {
  92         struct mptcp_pm_addr_entry *entry, *tmp;
  93
  94         list_for_each_entry_safe(entry, tmp, &msk->pm.userspace_pm_local_addr_list, list) {
  95                 if (mptcp_addresses_equal(&entry->addr, &addr->addr, false)) {
  96                         /* TODO: a refcount is needed because the entry can
  97                          * be used multiple times (e.g. fullmesh mode).
  98                          */
  99                         list_del_rcu(&entry->list);
 100                         kfree(entry);
 101                         msk->pm.local_addr_used--;
 102                         return 0;
 103                 }
 104         }
 105
 106         return -EINVAL;
 107 }
 108
 109 int mptcp_userspace_pm_get_flags_and_ifindex_by_id(struct mptcp_sock *msk,
 110                                                    unsigned int id,
 111                                                    u8 *flags, int *ifindex)
 112 {
 113         struct mptcp_pm_addr_entry *entry, *match = NULL;
 114
 115         spin_lock_bh(&msk->pm.lock);
 116         list_for_each_entry(entry, &msk->pm.userspace_pm_local_addr_list, list) {
 117                 if (id == entry->addr.id) {
 118                         match = entry;
 119                         break;
 120                 }
 121         }
 122         spin_unlock_bh(&msk->pm.lock);
 123         if (match) {
 124                 *flags = match->flags;
 125                 *ifindex = match->ifindex;
 126         }
 127
 128         return 0;
 129 }
 130
 131 int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,
 132                                     struct mptcp_addr_info *skc)
 133 {
 134         struct mptcp_pm_addr_entry *entry = NULL, *e, new_entry;
 135         __be16 msk_sport =  ((struct inet_sock *)
 136                              inet_sk((struct sock *)msk))->inet_sport;
 137
 138         spin_lock_bh(&msk->pm.lock);
 139         list_for_each_entry(e, &msk->pm.userspace_pm_local_addr_list, list) {
 140                 if (mptcp_addresses_equal(&e->addr, skc, false)) {
 141                         entry = e;
 142                         break;
 143                 }
 144         }
 145         spin_unlock_bh(&msk->pm.lock);
 146         if (entry)
 147                 return entry->addr.id;
 148
 149         memset(&new_entry, 0, sizeof(struct mptcp_pm_addr_entry));
 150         new_entry.addr = *skc;
 151         new_entry.addr.id = 0;
 152         new_entry.flags = MPTCP_PM_ADDR_FLAG_IMPLICIT;
 153
 154         if (new_entry.addr.port == msk_sport)
 155                 new_entry.addr.port = 0;
 156
 157         return mptcp_userspace_pm_append_new_local_addr(msk, &new_entry, true);
 158 }
 159
 160 int mptcp_pm_nl_announce_doit(struct sk_buff *skb, struct genl_info *info)
 161 {
 162         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 163         struct nlattr *addr = info->attrs[MPTCP_PM_ATTR_ADDR];
 164         struct mptcp_pm_addr_entry addr_val;
 165         struct mptcp_sock *msk;
 166         int err = -EINVAL;
 167         struct sock *sk;
 168         u32 token_val;
 169
 170         if (!addr || !token) {
 171                 GENL_SET_ERR_MSG(info, "missing required inputs");
 172                 return err;
 173         }
 174
 175         token_val = nla_get_u32(token);
 176
 177         msk = mptcp_token_get_sock(sock_net(skb->sk), token_val);
 178         if (!msk) {
 179                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 180                 return err;
 181         }
 182
 183         sk = (struct sock *)msk;
 184
 185         if (!mptcp_pm_is_userspace(msk)) {
 186                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 187                 goto announce_err;
 188         }
 189
 190         err = mptcp_pm_parse_entry(addr, info, true, &addr_val);
 191         if (err < 0) {
 192                 GENL_SET_ERR_MSG(info, "error parsing local address");
 193                 goto announce_err;
 194         }
 195
 196         if (addr_val.addr.id == 0 || !(addr_val.flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) {
 197                 GENL_SET_ERR_MSG(info, "invalid addr id or flags");
 198                 err = -EINVAL;
 199                 goto announce_err;
 200         }
 201
 202         err = mptcp_userspace_pm_append_new_local_addr(msk, &addr_val, false);
 203         if (err < 0) {
 204                 GENL_SET_ERR_MSG(info, "did not match address and id");
 205                 goto announce_err;
 206         }
 207
 208         lock_sock(sk);
 209         spin_lock_bh(&msk->pm.lock);
 210
 211         if (mptcp_pm_alloc_anno_list(msk, &addr_val.addr)) {
 212                 msk->pm.add_addr_signaled++;
 213                 mptcp_pm_announce_addr(msk, &addr_val.addr, false);
 214                 mptcp_pm_nl_addr_send_ack(msk);
 215         }
 216
 217         spin_unlock_bh(&msk->pm.lock);
 218         release_sock(sk);
 219
 220         err = 0;
 221  announce_err:
 222         sock_put(sk);
 223         return err;
 224 }
 225
 226 static int mptcp_userspace_pm_remove_id_zero_address(struct mptcp_sock *msk,
 227                                                      struct genl_info *info)
 228 {
 229         struct mptcp_rm_list list = { .nr = 0 };
 230         struct mptcp_subflow_context *subflow;
 231         struct sock *sk = (struct sock *)msk;
 232         bool has_id_0 = false;
 233         int err = -EINVAL;
 234
 235         lock_sock(sk);
 236         mptcp_for_each_subflow(msk, subflow) {
 237                 if (READ_ONCE(subflow->local_id) == 0) {
 238                         has_id_0 = true;
 239                         break;
 240                 }
 241         }
 242         if (!has_id_0) {
 243                 GENL_SET_ERR_MSG(info, "address with id 0 not found");
 244                 goto remove_err;
 245         }
 246
 247         list.ids[list.nr++] = 0;
 248
 249         spin_lock_bh(&msk->pm.lock);
 250         mptcp_pm_remove_addr(msk, &list);
 251         spin_unlock_bh(&msk->pm.lock);
 252
 253         err = 0;
 254
 255 remove_err:
 256         release_sock(sk);
 257         return err;
 258 }
 259
 260 int mptcp_pm_nl_remove_doit(struct sk_buff *skb, struct genl_info *info)
 261 {
 262         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 263         struct nlattr *id = info->attrs[MPTCP_PM_ATTR_LOC_ID];
 264         struct mptcp_pm_addr_entry *match = NULL;
 265         struct mptcp_pm_addr_entry *entry;
 266         struct mptcp_sock *msk;
 267         LIST_HEAD(free_list);
 268         int err = -EINVAL;
 269         struct sock *sk;
 270         u32 token_val;
 271         u8 id_val;
 272
 273         if (!id || !token) {
 274                 GENL_SET_ERR_MSG(info, "missing required inputs");
 275                 return err;
 276         }
 277
 278         id_val = nla_get_u8(id);
 279         token_val = nla_get_u32(token);
 280
 281         msk = mptcp_token_get_sock(sock_net(skb->sk), token_val);
 282         if (!msk) {
 283                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 284                 return err;
 285         }
 286
 287         sk = (struct sock *)msk;
 288
 289         if (!mptcp_pm_is_userspace(msk)) {
 290                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 291                 goto out;
 292         }
 293
 294         if (id_val == 0) {
 295                 err = mptcp_userspace_pm_remove_id_zero_address(msk, info);
 296                 goto out;
 297         }
 298
 299         lock_sock(sk);
 300
 301         list_for_each_entry(entry, &msk->pm.userspace_pm_local_addr_list, list) {
 302                 if (entry->addr.id == id_val) {
 303                         match = entry;
 304                         break;
 305                 }
 306         }
 307
 308         if (!match) {
 309                 GENL_SET_ERR_MSG(info, "address with specified id not found");
 310                 release_sock(sk);
 311                 goto out;
 312         }
 313
 314         list_move(&match->list, &free_list);
 315
 316         mptcp_pm_remove_addrs(msk, &free_list);
 317
 318         release_sock(sk);
 319
 320         list_for_each_entry_safe(match, entry, &free_list, list) {
 321                 sock_kfree_s(sk, match, sizeof(*match));
 322         }
 323
 324         err = 0;
 325 out:
 326         sock_put(sk);
 327         return err;
 328 }
 329
 330 int mptcp_pm_nl_subflow_create_doit(struct sk_buff *skb, struct genl_info *info)
 331 {
 332         struct nlattr *raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
 333         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 334         struct nlattr *laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
 335         struct mptcp_pm_addr_entry local = { 0 };
 336         struct mptcp_addr_info addr_r;
 337         struct mptcp_addr_info addr_l;
 338         struct mptcp_sock *msk;
 339         int err = -EINVAL;
 340         struct sock *sk;
 341         u32 token_val;
 342
 343         if (!laddr || !raddr || !token) {
 344                 GENL_SET_ERR_MSG(info, "missing required inputs");
 345                 return err;
 346         }
 347
 348         token_val = nla_get_u32(token);
 349
 350         msk = mptcp_token_get_sock(genl_info_net(info), token_val);
 351         if (!msk) {
 352                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 353                 return err;
 354         }
 355
 356         sk = (struct sock *)msk;
 357
 358         if (!mptcp_pm_is_userspace(msk)) {
 359                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 360                 goto create_err;
 361         }
 362
 363         err = mptcp_pm_parse_addr(laddr, info, &addr_l);
 364         if (err < 0) {
 365                 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "error parsing local addr");
 366                 goto create_err;
 367         }
 368
 369         err = mptcp_pm_parse_addr(raddr, info, &addr_r);
 370         if (err < 0) {
 371                 NL_SET_ERR_MSG_ATTR(info->extack, raddr, "error parsing remote addr");
 372                 goto create_err;
 373         }
 374
 375         if (!mptcp_pm_addr_families_match(sk, &addr_l, &addr_r)) {
 376                 GENL_SET_ERR_MSG(info, "families mismatch");
 377                 err = -EINVAL;
 378                 goto create_err;
 379         }
 380
 381         local.addr = addr_l;
 382         err = mptcp_userspace_pm_append_new_local_addr(msk, &local, false);
 383         if (err < 0) {
 384                 GENL_SET_ERR_MSG(info, "did not match address and id");
 385                 goto create_err;
 386         }
 387
 388         lock_sock(sk);
 389
 390         err = __mptcp_subflow_connect(sk, &addr_l, &addr_r);
 391
 392         release_sock(sk);
 393
 394         spin_lock_bh(&msk->pm.lock);
 395         if (err)
 396                 mptcp_userspace_pm_delete_local_addr(msk, &local);
 397         else
 398                 msk->pm.subflows++;
 399         spin_unlock_bh(&msk->pm.lock);
 400
 401  create_err:
 402         sock_put(sk);
 403         return err;
 404 }
 405
 406 static struct sock *mptcp_nl_find_ssk(struct mptcp_sock *msk,
 407                                       const struct mptcp_addr_info *local,
 408                                       const struct mptcp_addr_info *remote)
 409 {
 410         struct mptcp_subflow_context *subflow;
 411
 412         if (local->family != remote->family)
 413                 return NULL;
 414
 415         mptcp_for_each_subflow(msk, subflow) {
 416                 const struct inet_sock *issk;
 417                 struct sock *ssk;
 418
 419                 ssk = mptcp_subflow_tcp_sock(subflow);
 420
 421                 if (local->family != ssk->sk_family)
 422                         continue;
 423
 424                 issk = inet_sk(ssk);
 425
 426                 switch (ssk->sk_family) {
 427                 case AF_INET:
 428                         if (issk->inet_saddr != local->addr.s_addr ||
 429                             issk->inet_daddr != remote->addr.s_addr)
 430                                 continue;
 431                         break;
 432 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 433                 case AF_INET6: {
 434                         const struct ipv6_pinfo *pinfo = inet6_sk(ssk);
 435
 436                         if (!ipv6_addr_equal(&local->addr6, &pinfo->saddr) ||
 437                             !ipv6_addr_equal(&remote->addr6, &ssk->sk_v6_daddr))
 438                                 continue;
 439                         break;
 440                 }
 441 #endif
 442                 default:
 443                         continue;
 444                 }
 445
 446                 if (issk->inet_sport == local->port &&
 447                     issk->inet_dport == remote->port)
 448                         return ssk;
 449         }
 450
 451         return NULL;
 452 }
 453
 454 int mptcp_pm_nl_subflow_destroy_doit(struct sk_buff *skb, struct genl_info *info)
 455 {
 456         struct nlattr *raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
 457         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 458         struct nlattr *laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
 459         struct mptcp_addr_info addr_l;
 460         struct mptcp_addr_info addr_r;
 461         struct mptcp_sock *msk;
 462         struct sock *sk, *ssk;
 463         int err = -EINVAL;
 464         u32 token_val;
 465
 466         if (!laddr || !raddr || !token) {
 467                 GENL_SET_ERR_MSG(info, "missing required inputs");
 468                 return err;
 469         }
 470
 471         token_val = nla_get_u32(token);
 472
 473         msk = mptcp_token_get_sock(genl_info_net(info), token_val);
 474         if (!msk) {
 475                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 476                 return err;
 477         }
 478
 479         sk = (struct sock *)msk;
 480
 481         if (!mptcp_pm_is_userspace(msk)) {
 482                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 483                 goto destroy_err;
 484         }
 485
 486         err = mptcp_pm_parse_addr(laddr, info, &addr_l);
 487         if (err < 0) {
 488                 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "error parsing local addr");
 489                 goto destroy_err;
 490         }
 491
 492         err = mptcp_pm_parse_addr(raddr, info, &addr_r);
 493         if (err < 0) {
 494                 NL_SET_ERR_MSG_ATTR(info->extack, raddr, "error parsing remote addr");
 495                 goto destroy_err;
 496         }
 497
 498 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 499         if (addr_l.family == AF_INET && ipv6_addr_v4mapped(&addr_r.addr6)) {
 500                 ipv6_addr_set_v4mapped(addr_l.addr.s_addr, &addr_l.addr6);
 501                 addr_l.family = AF_INET6;
 502         }
 503         if (addr_r.family == AF_INET && ipv6_addr_v4mapped(&addr_l.addr6)) {
 504                 ipv6_addr_set_v4mapped(addr_r.addr.s_addr, &addr_r.addr6);
 505                 addr_r.family = AF_INET6;
 506         }
 507 #endif
 508         if (addr_l.family != addr_r.family) {
 509                 GENL_SET_ERR_MSG(info, "address families do not match");
 510                 err = -EINVAL;
 511                 goto destroy_err;
 512         }
 513
 514         if (!addr_l.port || !addr_r.port) {
 515                 GENL_SET_ERR_MSG(info, "missing local or remote port");
 516                 err = -EINVAL;
 517                 goto destroy_err;
 518         }
 519
 520         lock_sock(sk);
 521         ssk = mptcp_nl_find_ssk(msk, &addr_l, &addr_r);
 522         if (ssk) {
 523                 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
 524                 struct mptcp_pm_addr_entry entry = { .addr = addr_l };
 525
 526                 spin_lock_bh(&msk->pm.lock);
 527                 mptcp_userspace_pm_delete_local_addr(msk, &entry);
 528                 spin_unlock_bh(&msk->pm.lock);
 529                 mptcp_subflow_shutdown(sk, ssk, RCV_SHUTDOWN | SEND_SHUTDOWN);
 530                 mptcp_close_ssk(sk, ssk, subflow);
 531                 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_RMSUBFLOW);
 532                 err = 0;
 533         } else {
 534                 err = -ESRCH;
 535         }
 536         release_sock(sk);
 537
 538 destroy_err:
 539         sock_put(sk);
 540         return err;
 541 }
 542
 543 int mptcp_userspace_pm_set_flags(struct net *net, struct nlattr *token,
 544                                  struct mptcp_pm_addr_entry *loc,
 545                                  struct mptcp_pm_addr_entry *rem, u8 bkup)
 546 {
 547         struct mptcp_sock *msk;
 548         int ret = -EINVAL;
 549         struct sock *sk;
 550         u32 token_val;
 551
 552         token_val = nla_get_u32(token);
 553
 554         msk = mptcp_token_get_sock(net, token_val);
 555         if (!msk)
 556                 return ret;
 557
 558         sk = (struct sock *)msk;
 559
 560         if (!mptcp_pm_is_userspace(msk))
 561                 goto set_flags_err;
 562
 563         if (loc->addr.family == AF_UNSPEC ||
 564             rem->addr.family == AF_UNSPEC)
 565                 goto set_flags_err;
 566
 567         lock_sock(sk);
 568         ret = mptcp_pm_nl_mp_prio_send_ack(msk, &loc->addr, &rem->addr, bkup);
 569         release_sock(sk);
 570
 571 set_flags_err:
 572         sock_put(sk);
 573         return ret;
 574 }