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