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