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 #include "mptcp_pm_gen.h"
  10
  11 void mptcp_free_local_addr_list(struct mptcp_sock *msk)
  12 {
  13         struct mptcp_pm_addr_entry *entry, *tmp;
  14         struct sock *sk = (struct sock *)msk;
  15         LIST_HEAD(free_list);
  16
  17         if (!mptcp_pm_is_userspace(msk))
  18                 return;
  19
  20         spin_lock_bh(&msk->pm.lock);
  21         list_splice_init(&msk->pm.userspace_pm_local_addr_list, &free_list);
  22         spin_unlock_bh(&msk->pm.lock);
  23
  24         list_for_each_entry_safe(entry, tmp, &free_list, list) {
  25                 sock_kfree_s(sk, entry, sizeof(*entry));
  26         }
  27 }
  28
  29 static int mptcp_userspace_pm_append_new_local_addr(struct mptcp_sock *msk,
  30                                                     struct mptcp_pm_addr_entry *entry,
  31                                                     bool needs_id)
  32 {
  33         DECLARE_BITMAP(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
  34         struct mptcp_pm_addr_entry *match = NULL;
  35         struct sock *sk = (struct sock *)msk;
  36         struct mptcp_pm_addr_entry *e;
  37         bool addr_match = false;
  38         bool id_match = false;
  39         int ret = -EINVAL;
  40
  41         bitmap_zero(id_bitmap, MPTCP_PM_MAX_ADDR_ID + 1);
  42
  43         spin_lock_bh(&msk->pm.lock);
  44         list_for_each_entry(e, &msk->pm.userspace_pm_local_addr_list, list) {
  45                 addr_match = mptcp_addresses_equal(&e->addr, &entry->addr, true);
  46                 if (addr_match && entry->addr.id == 0 && needs_id)
  47                         entry->addr.id = e->addr.id;
  48                 id_match = (e->addr.id == entry->addr.id);
  49                 if (addr_match && id_match) {
  50                         match = e;
  51                         break;
  52                 } else if (addr_match || id_match) {
  53                         break;
  54                 }
  55                 __set_bit(e->addr.id, id_bitmap);
  56         }
  57
  58         if (!match && !addr_match && !id_match) {
  59                 /* Memory for the entry is allocated from the
  60                  * sock option buffer.
  61                  */
  62                 e = sock_kmalloc(sk, sizeof(*e), GFP_ATOMIC);
  63                 if (!e) {
  64                         ret = -ENOMEM;
  65                         goto append_err;
  66                 }
  67
  68                 *e = *entry;
  69                 if (!e->addr.id && needs_id)
  70                         e->addr.id = find_next_zero_bit(id_bitmap,
  71                                                         MPTCP_PM_MAX_ADDR_ID + 1,
  72                                                         1);
  73                 list_add_tail_rcu(&e->list, &msk->pm.userspace_pm_local_addr_list);
  74                 msk->pm.local_addr_used++;
  75                 ret = e->addr.id;
  76         } else if (match) {
  77                 ret = entry->addr.id;
  78         }
  79
  80 append_err:
  81         spin_unlock_bh(&msk->pm.lock);
  82         return ret;
  83 }
  84
  85 /* If the subflow is closed from the other peer (not via a
  86  * subflow destroy command then), we want to keep the entry
  87  * not to assign the same ID to another address and to be
  88  * able to send RM_ADDR after the removal of the subflow.
  89  */
  90 static int mptcp_userspace_pm_delete_local_addr(struct mptcp_sock *msk,
  91                                                 struct mptcp_pm_addr_entry *addr)
  92 {
  93         struct mptcp_pm_addr_entry *entry, *tmp;
  94
  95         list_for_each_entry_safe(entry, tmp, &msk->pm.userspace_pm_local_addr_list, list) {
  96                 if (mptcp_addresses_equal(&entry->addr, &addr->addr, false)) {
  97                         /* TODO: a refcount is needed because the entry can
  98                          * be used multiple times (e.g. fullmesh mode).
  99                          */
 100                         list_del_rcu(&entry->list);
 101                         kfree(entry);
 102                         msk->pm.local_addr_used--;
 103                         return 0;
 104                 }
 105         }
 106
 107         return -EINVAL;
 108 }
 109
 110 static struct mptcp_pm_addr_entry *
 111 mptcp_userspace_pm_lookup_addr_by_id(struct mptcp_sock *msk, unsigned int id)
 112 {
 113         struct mptcp_pm_addr_entry *entry;
 114
 115         list_for_each_entry(entry, &msk->pm.userspace_pm_local_addr_list, list) {
 116                 if (entry->addr.id == id)
 117                         return entry;
 118         }
 119         return NULL;
 120 }
 121
 122 int mptcp_userspace_pm_get_flags_and_ifindex_by_id(struct mptcp_sock *msk,
 123                                                    unsigned int id,
 124                                                    u8 *flags, int *ifindex)
 125 {
 126         struct mptcp_pm_addr_entry *match;
 127
 128         spin_lock_bh(&msk->pm.lock);
 129         match = mptcp_userspace_pm_lookup_addr_by_id(msk, id);
 130         spin_unlock_bh(&msk->pm.lock);
 131         if (match) {
 132                 *flags = match->flags;
 133                 *ifindex = match->ifindex;
 134         }
 135
 136         return 0;
 137 }
 138
 139 int mptcp_userspace_pm_get_local_id(struct mptcp_sock *msk,
 140                                     struct mptcp_addr_info *skc)
 141 {
 142         struct mptcp_pm_addr_entry *entry = NULL, *e, new_entry;
 143         __be16 msk_sport =  ((struct inet_sock *)
 144                              inet_sk((struct sock *)msk))->inet_sport;
 145
 146         spin_lock_bh(&msk->pm.lock);
 147         list_for_each_entry(e, &msk->pm.userspace_pm_local_addr_list, list) {
 148                 if (mptcp_addresses_equal(&e->addr, skc, false)) {
 149                         entry = e;
 150                         break;
 151                 }
 152         }
 153         spin_unlock_bh(&msk->pm.lock);
 154         if (entry)
 155                 return entry->addr.id;
 156
 157         memset(&new_entry, 0, sizeof(struct mptcp_pm_addr_entry));
 158         new_entry.addr = *skc;
 159         new_entry.addr.id = 0;
 160         new_entry.flags = MPTCP_PM_ADDR_FLAG_IMPLICIT;
 161
 162         if (new_entry.addr.port == msk_sport)
 163                 new_entry.addr.port = 0;
 164
 165         return mptcp_userspace_pm_append_new_local_addr(msk, &new_entry, true);
 166 }
 167
 168 int mptcp_pm_nl_announce_doit(struct sk_buff *skb, struct genl_info *info)
 169 {
 170         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 171         struct nlattr *addr = info->attrs[MPTCP_PM_ATTR_ADDR];
 172         struct mptcp_pm_addr_entry addr_val;
 173         struct mptcp_sock *msk;
 174         int err = -EINVAL;
 175         struct sock *sk;
 176         u32 token_val;
 177
 178         if (!addr || !token) {
 179                 GENL_SET_ERR_MSG(info, "missing required inputs");
 180                 return err;
 181         }
 182
 183         token_val = nla_get_u32(token);
 184
 185         msk = mptcp_token_get_sock(sock_net(skb->sk), token_val);
 186         if (!msk) {
 187                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 188                 return err;
 189         }
 190
 191         sk = (struct sock *)msk;
 192
 193         if (!mptcp_pm_is_userspace(msk)) {
 194                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 195                 goto announce_err;
 196         }
 197
 198         err = mptcp_pm_parse_entry(addr, info, true, &addr_val);
 199         if (err < 0) {
 200                 GENL_SET_ERR_MSG(info, "error parsing local address");
 201                 goto announce_err;
 202         }
 203
 204         if (addr_val.addr.id == 0 || !(addr_val.flags & MPTCP_PM_ADDR_FLAG_SIGNAL)) {
 205                 GENL_SET_ERR_MSG(info, "invalid addr id or flags");
 206                 err = -EINVAL;
 207                 goto announce_err;
 208         }
 209
 210         err = mptcp_userspace_pm_append_new_local_addr(msk, &addr_val, false);
 211         if (err < 0) {
 212                 GENL_SET_ERR_MSG(info, "did not match address and id");
 213                 goto announce_err;
 214         }
 215
 216         lock_sock(sk);
 217         spin_lock_bh(&msk->pm.lock);
 218
 219         if (mptcp_pm_alloc_anno_list(msk, &addr_val.addr)) {
 220                 msk->pm.add_addr_signaled++;
 221                 mptcp_pm_announce_addr(msk, &addr_val.addr, false);
 222                 mptcp_pm_nl_addr_send_ack(msk);
 223         }
 224
 225         spin_unlock_bh(&msk->pm.lock);
 226         release_sock(sk);
 227
 228         err = 0;
 229  announce_err:
 230         sock_put(sk);
 231         return err;
 232 }
 233
 234 static int mptcp_userspace_pm_remove_id_zero_address(struct mptcp_sock *msk,
 235                                                      struct genl_info *info)
 236 {
 237         struct mptcp_rm_list list = { .nr = 0 };
 238         struct mptcp_subflow_context *subflow;
 239         struct sock *sk = (struct sock *)msk;
 240         bool has_id_0 = false;
 241         int err = -EINVAL;
 242
 243         lock_sock(sk);
 244         mptcp_for_each_subflow(msk, subflow) {
 245                 if (READ_ONCE(subflow->local_id) == 0) {
 246                         has_id_0 = true;
 247                         break;
 248                 }
 249         }
 250         if (!has_id_0) {
 251                 GENL_SET_ERR_MSG(info, "address with id 0 not found");
 252                 goto remove_err;
 253         }
 254
 255         list.ids[list.nr++] = 0;
 256
 257         spin_lock_bh(&msk->pm.lock);
 258         mptcp_pm_remove_addr(msk, &list);
 259         spin_unlock_bh(&msk->pm.lock);
 260
 261         err = 0;
 262
 263 remove_err:
 264         release_sock(sk);
 265         return err;
 266 }
 267
 268 int mptcp_pm_nl_remove_doit(struct sk_buff *skb, struct genl_info *info)
 269 {
 270         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 271         struct nlattr *id = info->attrs[MPTCP_PM_ATTR_LOC_ID];
 272         struct mptcp_pm_addr_entry *match;
 273         struct mptcp_pm_addr_entry *entry;
 274         struct mptcp_sock *msk;
 275         LIST_HEAD(free_list);
 276         int err = -EINVAL;
 277         struct sock *sk;
 278         u32 token_val;
 279         u8 id_val;
 280
 281         if (!id || !token) {
 282                 GENL_SET_ERR_MSG(info, "missing required inputs");
 283                 return err;
 284         }
 285
 286         id_val = nla_get_u8(id);
 287         token_val = nla_get_u32(token);
 288
 289         msk = mptcp_token_get_sock(sock_net(skb->sk), token_val);
 290         if (!msk) {
 291                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 292                 return err;
 293         }
 294
 295         sk = (struct sock *)msk;
 296
 297         if (!mptcp_pm_is_userspace(msk)) {
 298                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 299                 goto out;
 300         }
 301
 302         if (id_val == 0) {
 303                 err = mptcp_userspace_pm_remove_id_zero_address(msk, info);
 304                 goto out;
 305         }
 306
 307         lock_sock(sk);
 308
 309         match = mptcp_userspace_pm_lookup_addr_by_id(msk, id_val);
 310         if (!match) {
 311                 GENL_SET_ERR_MSG(info, "address with specified id not found");
 312                 release_sock(sk);
 313                 goto out;
 314         }
 315
 316         list_move(&match->list, &free_list);
 317
 318         mptcp_pm_remove_addrs(msk, &free_list);
 319
 320         release_sock(sk);
 321
 322         list_for_each_entry_safe(match, entry, &free_list, list) {
 323                 sock_kfree_s(sk, match, sizeof(*match));
 324         }
 325
 326         err = 0;
 327 out:
 328         sock_put(sk);
 329         return err;
 330 }
 331
 332 int mptcp_pm_nl_subflow_create_doit(struct sk_buff *skb, struct genl_info *info)
 333 {
 334         struct nlattr *raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
 335         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 336         struct nlattr *laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
 337         struct mptcp_pm_addr_entry local = { 0 };
 338         struct mptcp_addr_info addr_r;
 339         struct mptcp_sock *msk;
 340         int err = -EINVAL;
 341         struct sock *sk;
 342         u32 token_val;
 343
 344         if (!laddr || !raddr || !token) {
 345                 GENL_SET_ERR_MSG(info, "missing required inputs");
 346                 return err;
 347         }
 348
 349         token_val = nla_get_u32(token);
 350
 351         msk = mptcp_token_get_sock(genl_info_net(info), token_val);
 352         if (!msk) {
 353                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 354                 return err;
 355         }
 356
 357         sk = (struct sock *)msk;
 358
 359         if (!mptcp_pm_is_userspace(msk)) {
 360                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 361                 goto create_err;
 362         }
 363
 364         err = mptcp_pm_parse_entry(laddr, info, true, &local);
 365         if (err < 0) {
 366                 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "error parsing local addr");
 367                 goto create_err;
 368         }
 369
 370         if (local.flags & MPTCP_PM_ADDR_FLAG_SIGNAL) {
 371                 GENL_SET_ERR_MSG(info, "invalid addr flags");
 372                 err = -EINVAL;
 373                 goto create_err;
 374         }
 375         local.flags |= MPTCP_PM_ADDR_FLAG_SUBFLOW;
 376
 377         err = mptcp_pm_parse_addr(raddr, info, &addr_r);
 378         if (err < 0) {
 379                 NL_SET_ERR_MSG_ATTR(info->extack, raddr, "error parsing remote addr");
 380                 goto create_err;
 381         }
 382
 383         if (!mptcp_pm_addr_families_match(sk, &local.addr, &addr_r)) {
 384                 GENL_SET_ERR_MSG(info, "families mismatch");
 385                 err = -EINVAL;
 386                 goto create_err;
 387         }
 388
 389         err = mptcp_userspace_pm_append_new_local_addr(msk, &local, false);
 390         if (err < 0) {
 391                 GENL_SET_ERR_MSG(info, "did not match address and id");
 392                 goto create_err;
 393         }
 394
 395         lock_sock(sk);
 396
 397         err = __mptcp_subflow_connect(sk, &local.addr, &addr_r);
 398
 399         release_sock(sk);
 400
 401         spin_lock_bh(&msk->pm.lock);
 402         if (err)
 403                 mptcp_userspace_pm_delete_local_addr(msk, &local);
 404         else
 405                 msk->pm.subflows++;
 406         spin_unlock_bh(&msk->pm.lock);
 407
 408  create_err:
 409         sock_put(sk);
 410         return err;
 411 }
 412
 413 static struct sock *mptcp_nl_find_ssk(struct mptcp_sock *msk,
 414                                       const struct mptcp_addr_info *local,
 415                                       const struct mptcp_addr_info *remote)
 416 {
 417         struct mptcp_subflow_context *subflow;
 418
 419         if (local->family != remote->family)
 420                 return NULL;
 421
 422         mptcp_for_each_subflow(msk, subflow) {
 423                 const struct inet_sock *issk;
 424                 struct sock *ssk;
 425
 426                 ssk = mptcp_subflow_tcp_sock(subflow);
 427
 428                 if (local->family != ssk->sk_family)
 429                         continue;
 430
 431                 issk = inet_sk(ssk);
 432
 433                 switch (ssk->sk_family) {
 434                 case AF_INET:
 435                         if (issk->inet_saddr != local->addr.s_addr ||
 436                             issk->inet_daddr != remote->addr.s_addr)
 437                                 continue;
 438                         break;
 439 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 440                 case AF_INET6: {
 441                         const struct ipv6_pinfo *pinfo = inet6_sk(ssk);
 442
 443                         if (!ipv6_addr_equal(&local->addr6, &pinfo->saddr) ||
 444                             !ipv6_addr_equal(&remote->addr6, &ssk->sk_v6_daddr))
 445                                 continue;
 446                         break;
 447                 }
 448 #endif
 449                 default:
 450                         continue;
 451                 }
 452
 453                 if (issk->inet_sport == local->port &&
 454                     issk->inet_dport == remote->port)
 455                         return ssk;
 456         }
 457
 458         return NULL;
 459 }
 460
 461 int mptcp_pm_nl_subflow_destroy_doit(struct sk_buff *skb, struct genl_info *info)
 462 {
 463         struct nlattr *raddr = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
 464         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 465         struct nlattr *laddr = info->attrs[MPTCP_PM_ATTR_ADDR];
 466         struct mptcp_addr_info addr_l;
 467         struct mptcp_addr_info addr_r;
 468         struct mptcp_sock *msk;
 469         struct sock *sk, *ssk;
 470         int err = -EINVAL;
 471         u32 token_val;
 472
 473         if (!laddr || !raddr || !token) {
 474                 GENL_SET_ERR_MSG(info, "missing required inputs");
 475                 return err;
 476         }
 477
 478         token_val = nla_get_u32(token);
 479
 480         msk = mptcp_token_get_sock(genl_info_net(info), token_val);
 481         if (!msk) {
 482                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 483                 return err;
 484         }
 485
 486         sk = (struct sock *)msk;
 487
 488         if (!mptcp_pm_is_userspace(msk)) {
 489                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 490                 goto destroy_err;
 491         }
 492
 493         err = mptcp_pm_parse_addr(laddr, info, &addr_l);
 494         if (err < 0) {
 495                 NL_SET_ERR_MSG_ATTR(info->extack, laddr, "error parsing local addr");
 496                 goto destroy_err;
 497         }
 498
 499         err = mptcp_pm_parse_addr(raddr, info, &addr_r);
 500         if (err < 0) {
 501                 NL_SET_ERR_MSG_ATTR(info->extack, raddr, "error parsing remote addr");
 502                 goto destroy_err;
 503         }
 504
 505 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 506         if (addr_l.family == AF_INET && ipv6_addr_v4mapped(&addr_r.addr6)) {
 507                 ipv6_addr_set_v4mapped(addr_l.addr.s_addr, &addr_l.addr6);
 508                 addr_l.family = AF_INET6;
 509         }
 510         if (addr_r.family == AF_INET && ipv6_addr_v4mapped(&addr_l.addr6)) {
 511                 ipv6_addr_set_v4mapped(addr_r.addr.s_addr, &addr_r.addr6);
 512                 addr_r.family = AF_INET6;
 513         }
 514 #endif
 515         if (addr_l.family != addr_r.family) {
 516                 GENL_SET_ERR_MSG(info, "address families do not match");
 517                 err = -EINVAL;
 518                 goto destroy_err;
 519         }
 520
 521         if (!addr_l.port || !addr_r.port) {
 522                 GENL_SET_ERR_MSG(info, "missing local or remote port");
 523                 err = -EINVAL;
 524                 goto destroy_err;
 525         }
 526
 527         lock_sock(sk);
 528         ssk = mptcp_nl_find_ssk(msk, &addr_l, &addr_r);
 529         if (ssk) {
 530                 struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
 531                 struct mptcp_pm_addr_entry entry = { .addr = addr_l };
 532
 533                 spin_lock_bh(&msk->pm.lock);
 534                 mptcp_userspace_pm_delete_local_addr(msk, &entry);
 535                 spin_unlock_bh(&msk->pm.lock);
 536                 mptcp_subflow_shutdown(sk, ssk, RCV_SHUTDOWN | SEND_SHUTDOWN);
 537                 mptcp_close_ssk(sk, ssk, subflow);
 538                 MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_RMSUBFLOW);
 539                 err = 0;
 540         } else {
 541                 err = -ESRCH;
 542         }
 543         release_sock(sk);
 544
 545 destroy_err:
 546         sock_put(sk);
 547         return err;
 548 }
 549
 550 int mptcp_userspace_pm_set_flags(struct sk_buff *skb, struct genl_info *info)
 551 {
 552         struct mptcp_pm_addr_entry loc = { .addr = { .family = AF_UNSPEC }, };
 553         struct mptcp_pm_addr_entry rem = { .addr = { .family = AF_UNSPEC }, };
 554         struct nlattr *attr_rem = info->attrs[MPTCP_PM_ATTR_ADDR_REMOTE];
 555         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 556         struct nlattr *attr = info->attrs[MPTCP_PM_ATTR_ADDR];
 557         struct net *net = sock_net(skb->sk);
 558         struct mptcp_sock *msk;
 559         int ret = -EINVAL;
 560         struct sock *sk;
 561         u32 token_val;
 562         u8 bkup = 0;
 563
 564         token_val = nla_get_u32(token);
 565
 566         msk = mptcp_token_get_sock(net, token_val);
 567         if (!msk) {
 568                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 569                 return ret;
 570         }
 571
 572         sk = (struct sock *)msk;
 573
 574         if (!mptcp_pm_is_userspace(msk)) {
 575                 GENL_SET_ERR_MSG(info, "userspace PM not selected");
 576                 goto set_flags_err;
 577         }
 578
 579         ret = mptcp_pm_parse_entry(attr, info, false, &loc);
 580         if (ret < 0)
 581                 goto set_flags_err;
 582
 583         if (attr_rem) {
 584                 ret = mptcp_pm_parse_entry(attr_rem, info, false, &rem);
 585                 if (ret < 0)
 586                         goto set_flags_err;
 587         }
 588
 589         if (loc.addr.family == AF_UNSPEC ||
 590             rem.addr.family == AF_UNSPEC) {
 591                 GENL_SET_ERR_MSG(info, "invalid address families");
 592                 ret = -EINVAL;
 593                 goto set_flags_err;
 594         }
 595
 596         if (loc.flags & MPTCP_PM_ADDR_FLAG_BACKUP)
 597                 bkup = 1;
 598
 599         lock_sock(sk);
 600         ret = mptcp_pm_nl_mp_prio_send_ack(msk, &loc.addr, &rem.addr, bkup);
 601         release_sock(sk);
 602
 603 set_flags_err:
 604         sock_put(sk);
 605         return ret;
 606 }
 607
 608 int mptcp_userspace_pm_dump_addr(struct sk_buff *msg,
 609                                  struct netlink_callback *cb)
 610 {
 611         struct id_bitmap {
 612                 DECLARE_BITMAP(map, MPTCP_PM_MAX_ADDR_ID + 1);
 613         } *bitmap;
 614         const struct genl_info *info = genl_info_dump(cb);
 615         struct net *net = sock_net(msg->sk);
 616         struct mptcp_pm_addr_entry *entry;
 617         struct mptcp_sock *msk;
 618         struct nlattr *token;
 619         int ret = -EINVAL;
 620         struct sock *sk;
 621         void *hdr;
 622
 623         bitmap = (struct id_bitmap *)cb->ctx;
 624         token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 625
 626         msk = mptcp_token_get_sock(net, nla_get_u32(token));
 627         if (!msk) {
 628                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 629                 return ret;
 630         }
 631
 632         sk = (struct sock *)msk;
 633
 634         if (!mptcp_pm_is_userspace(msk)) {
 635                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 636                 goto out;
 637         }
 638
 639         lock_sock(sk);
 640         spin_lock_bh(&msk->pm.lock);
 641         list_for_each_entry(entry, &msk->pm.userspace_pm_local_addr_list, list) {
 642                 if (test_bit(entry->addr.id, bitmap->map))
 643                         continue;
 644
 645                 hdr = genlmsg_put(msg, NETLINK_CB(cb->skb).portid,
 646                                   cb->nlh->nlmsg_seq, &mptcp_genl_family,
 647                                   NLM_F_MULTI, MPTCP_PM_CMD_GET_ADDR);
 648                 if (!hdr)
 649                         break;
 650
 651                 if (mptcp_nl_fill_addr(msg, entry) < 0) {
 652                         genlmsg_cancel(msg, hdr);
 653                         break;
 654                 }
 655
 656                 __set_bit(entry->addr.id, bitmap->map);
 657                 genlmsg_end(msg, hdr);
 658         }
 659         spin_unlock_bh(&msk->pm.lock);
 660         release_sock(sk);
 661         ret = msg->len;
 662
 663 out:
 664         sock_put(sk);
 665         return ret;
 666 }
 667
 668 int mptcp_userspace_pm_get_addr(struct sk_buff *skb,
 669                                 struct genl_info *info)
 670 {
 671         struct nlattr *attr = info->attrs[MPTCP_PM_ENDPOINT_ADDR];
 672         struct nlattr *token = info->attrs[MPTCP_PM_ATTR_TOKEN];
 673         struct mptcp_pm_addr_entry addr, *entry;
 674         struct net *net = sock_net(skb->sk);
 675         struct mptcp_sock *msk;
 676         struct sk_buff *msg;
 677         int ret = -EINVAL;
 678         struct sock *sk;
 679         void *reply;
 680
 681         msk = mptcp_token_get_sock(net, nla_get_u32(token));
 682         if (!msk) {
 683                 NL_SET_ERR_MSG_ATTR(info->extack, token, "invalid token");
 684                 return ret;
 685         }
 686
 687         sk = (struct sock *)msk;
 688
 689         if (!mptcp_pm_is_userspace(msk)) {
 690                 GENL_SET_ERR_MSG(info, "invalid request; userspace PM not selected");
 691                 goto out;
 692         }
 693
 694         ret = mptcp_pm_parse_entry(attr, info, false, &addr);
 695         if (ret < 0)
 696                 goto out;
 697
 698         msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 699         if (!msg) {
 700                 ret = -ENOMEM;
 701                 goto out;
 702         }
 703
 704         reply = genlmsg_put_reply(msg, info, &mptcp_genl_family, 0,
 705                                   info->genlhdr->cmd);
 706         if (!reply) {
 707                 GENL_SET_ERR_MSG(info, "not enough space in Netlink message");
 708                 ret = -EMSGSIZE;
 709                 goto fail;
 710         }
 711
 712         lock_sock(sk);
 713         spin_lock_bh(&msk->pm.lock);
 714         entry = mptcp_userspace_pm_lookup_addr_by_id(msk, addr.addr.id);
 715         if (!entry) {
 716                 GENL_SET_ERR_MSG(info, "address not found");
 717                 ret = -EINVAL;
 718                 goto unlock_fail;
 719         }
 720
 721         ret = mptcp_nl_fill_addr(msg, entry);
 722         if (ret)
 723                 goto unlock_fail;
 724
 725         genlmsg_end(msg, reply);
 726         ret = genlmsg_reply(msg, info);
 727         spin_unlock_bh(&msk->pm.lock);
 728         release_sock(sk);
 729         sock_put(sk);
 730         return ret;
 731
 732 unlock_fail:
 733         spin_unlock_bh(&msk->pm.lock);
 734         release_sock(sk);
 735 fail:
 736         nlmsg_free(msg);
 737 out:
 738         sock_put(sk);
 739         return ret;
 740 }