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