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