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