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