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