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