]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - net/tipc/bearer.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'asoc-5.3' into asoc-linus
[mirror_ubuntu-hirsute-kernel.git] / net / tipc / bearer.c
1 /*
2 * net/tipc/bearer.c: TIPC bearer code
3 *
4 * Copyright (c) 1996-2006, 2013-2016, Ericsson AB
5 * Copyright (c) 2004-2006, 2010-2013, Wind River Systems
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
19 *
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
37 #include <net/sock.h>
38 #include "core.h"
39 #include "bearer.h"
40 #include "link.h"
41 #include "discover.h"
42 #include "monitor.h"
43 #include "bcast.h"
44 #include "netlink.h"
45 #include "udp_media.h"
46 #include "trace.h"
47
48 #define MAX_ADDR_STR 60
49
50 static struct tipc_media * const media_info_array[] = {
51 &eth_media_info,
52 #ifdef CONFIG_TIPC_MEDIA_IB
53 &ib_media_info,
54 #endif
55 #ifdef CONFIG_TIPC_MEDIA_UDP
56 &udp_media_info,
57 #endif
58 NULL
59 };
60
61 static struct tipc_bearer *bearer_get(struct net *net, int bearer_id)
62 {
63 struct tipc_net *tn = tipc_net(net);
64
65 return rcu_dereference(tn->bearer_list[bearer_id]);
66 }
67
68 static void bearer_disable(struct net *net, struct tipc_bearer *b);
69 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
70 struct packet_type *pt, struct net_device *orig_dev);
71
72 /**
73 * tipc_media_find - locates specified media object by name
74 */
75 struct tipc_media *tipc_media_find(const char *name)
76 {
77 u32 i;
78
79 for (i = 0; media_info_array[i] != NULL; i++) {
80 if (!strcmp(media_info_array[i]->name, name))
81 break;
82 }
83 return media_info_array[i];
84 }
85
86 /**
87 * media_find_id - locates specified media object by type identifier
88 */
89 static struct tipc_media *media_find_id(u8 type)
90 {
91 u32 i;
92
93 for (i = 0; media_info_array[i] != NULL; i++) {
94 if (media_info_array[i]->type_id == type)
95 break;
96 }
97 return media_info_array[i];
98 }
99
100 /**
101 * tipc_media_addr_printf - record media address in print buffer
102 */
103 int tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
104 {
105 char addr_str[MAX_ADDR_STR];
106 struct tipc_media *m;
107 int ret;
108
109 m = media_find_id(a->media_id);
110
111 if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
112 ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
113 else {
114 u32 i;
115
116 ret = scnprintf(buf, len, "UNKNOWN(%u)", a->media_id);
117 for (i = 0; i < sizeof(a->value); i++)
118 ret += scnprintf(buf + ret, len - ret,
119 "-%x", a->value[i]);
120 }
121 return ret;
122 }
123
124 /**
125 * bearer_name_validate - validate & (optionally) deconstruct bearer name
126 * @name: ptr to bearer name string
127 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
128 *
129 * Returns 1 if bearer name is valid, otherwise 0.
130 */
131 static int bearer_name_validate(const char *name,
132 struct tipc_bearer_names *name_parts)
133 {
134 char name_copy[TIPC_MAX_BEARER_NAME];
135 char *media_name;
136 char *if_name;
137 u32 media_len;
138 u32 if_len;
139
140 /* copy bearer name & ensure length is OK */
141 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
142 /* need above in case non-Posix strncpy() doesn't pad with nulls */
143 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
144 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
145 return 0;
146
147 /* ensure all component parts of bearer name are present */
148 media_name = name_copy;
149 if_name = strchr(media_name, ':');
150 if (if_name == NULL)
151 return 0;
152 *(if_name++) = 0;
153 media_len = if_name - media_name;
154 if_len = strlen(if_name) + 1;
155
156 /* validate component parts of bearer name */
157 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
158 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
159 return 0;
160
161 /* return bearer name components, if necessary */
162 if (name_parts) {
163 strcpy(name_parts->media_name, media_name);
164 strcpy(name_parts->if_name, if_name);
165 }
166 return 1;
167 }
168
169 /**
170 * tipc_bearer_find - locates bearer object with matching bearer name
171 */
172 struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
173 {
174 struct tipc_net *tn = net_generic(net, tipc_net_id);
175 struct tipc_bearer *b;
176 u32 i;
177
178 for (i = 0; i < MAX_BEARERS; i++) {
179 b = rtnl_dereference(tn->bearer_list[i]);
180 if (b && (!strcmp(b->name, name)))
181 return b;
182 }
183 return NULL;
184 }
185
186 /* tipc_bearer_get_name - get the bearer name from its id.
187 * @net: network namespace
188 * @name: a pointer to the buffer where the name will be stored.
189 * @bearer_id: the id to get the name from.
190 */
191 int tipc_bearer_get_name(struct net *net, char *name, u32 bearer_id)
192 {
193 struct tipc_net *tn = tipc_net(net);
194 struct tipc_bearer *b;
195
196 if (bearer_id >= MAX_BEARERS)
197 return -EINVAL;
198
199 b = rtnl_dereference(tn->bearer_list[bearer_id]);
200 if (!b)
201 return -EINVAL;
202
203 strcpy(name, b->name);
204 return 0;
205 }
206
207 void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
208 {
209 struct tipc_net *tn = net_generic(net, tipc_net_id);
210 struct tipc_bearer *b;
211
212 rcu_read_lock();
213 b = rcu_dereference(tn->bearer_list[bearer_id]);
214 if (b)
215 tipc_disc_add_dest(b->disc);
216 rcu_read_unlock();
217 }
218
219 void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
220 {
221 struct tipc_net *tn = net_generic(net, tipc_net_id);
222 struct tipc_bearer *b;
223
224 rcu_read_lock();
225 b = rcu_dereference(tn->bearer_list[bearer_id]);
226 if (b)
227 tipc_disc_remove_dest(b->disc);
228 rcu_read_unlock();
229 }
230
231 /**
232 * tipc_enable_bearer - enable bearer with the given name
233 */
234 static int tipc_enable_bearer(struct net *net, const char *name,
235 u32 disc_domain, u32 prio,
236 struct nlattr *attr[])
237 {
238 struct tipc_net *tn = tipc_net(net);
239 struct tipc_bearer_names b_names;
240 int with_this_prio = 1;
241 struct tipc_bearer *b;
242 struct tipc_media *m;
243 struct sk_buff *skb;
244 int bearer_id = 0;
245 int res = -EINVAL;
246 char *errstr = "";
247
248 if (!bearer_name_validate(name, &b_names)) {
249 errstr = "illegal name";
250 goto rejected;
251 }
252
253 if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
254 errstr = "illegal priority";
255 goto rejected;
256 }
257
258 m = tipc_media_find(b_names.media_name);
259 if (!m) {
260 errstr = "media not registered";
261 goto rejected;
262 }
263
264 if (prio == TIPC_MEDIA_LINK_PRI)
265 prio = m->priority;
266
267 /* Check new bearer vs existing ones and find free bearer id if any */
268 while (bearer_id < MAX_BEARERS) {
269 b = rtnl_dereference(tn->bearer_list[bearer_id]);
270 if (!b)
271 break;
272 if (!strcmp(name, b->name)) {
273 errstr = "already enabled";
274 goto rejected;
275 }
276 bearer_id++;
277 if (b->priority != prio)
278 continue;
279 if (++with_this_prio <= 2)
280 continue;
281 pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
282 name, prio);
283 if (prio == TIPC_MIN_LINK_PRI) {
284 errstr = "cannot adjust to lower";
285 goto rejected;
286 }
287 pr_warn("Bearer <%s>: trying with adjusted priority\n", name);
288 prio--;
289 bearer_id = 0;
290 with_this_prio = 1;
291 }
292
293 if (bearer_id >= MAX_BEARERS) {
294 errstr = "max 3 bearers permitted";
295 goto rejected;
296 }
297
298 b = kzalloc(sizeof(*b), GFP_ATOMIC);
299 if (!b)
300 return -ENOMEM;
301
302 strcpy(b->name, name);
303 b->media = m;
304 res = m->enable_media(net, b, attr);
305 if (res) {
306 kfree(b);
307 errstr = "failed to enable media";
308 goto rejected;
309 }
310
311 b->identity = bearer_id;
312 b->tolerance = m->tolerance;
313 b->window = m->window;
314 b->domain = disc_domain;
315 b->net_plane = bearer_id + 'A';
316 b->priority = prio;
317 test_and_set_bit_lock(0, &b->up);
318
319 res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
320 if (res) {
321 bearer_disable(net, b);
322 errstr = "failed to create discoverer";
323 goto rejected;
324 }
325
326 rcu_assign_pointer(tn->bearer_list[bearer_id], b);
327 if (skb)
328 tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
329
330 if (tipc_mon_create(net, bearer_id)) {
331 bearer_disable(net, b);
332 return -ENOMEM;
333 }
334
335 pr_info("Enabled bearer <%s>, priority %u\n", name, prio);
336
337 return res;
338 rejected:
339 pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
340 return res;
341 }
342
343 /**
344 * tipc_reset_bearer - Reset all links established over this bearer
345 */
346 static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
347 {
348 pr_info("Resetting bearer <%s>\n", b->name);
349 tipc_node_delete_links(net, b->identity);
350 tipc_disc_reset(net, b);
351 return 0;
352 }
353
354 /**
355 * bearer_disable
356 *
357 * Note: This routine assumes caller holds RTNL lock.
358 */
359 static void bearer_disable(struct net *net, struct tipc_bearer *b)
360 {
361 struct tipc_net *tn = tipc_net(net);
362 int bearer_id = b->identity;
363
364 pr_info("Disabling bearer <%s>\n", b->name);
365 clear_bit_unlock(0, &b->up);
366 tipc_node_delete_links(net, bearer_id);
367 b->media->disable_media(b);
368 RCU_INIT_POINTER(b->media_ptr, NULL);
369 if (b->disc)
370 tipc_disc_delete(b->disc);
371 RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
372 kfree_rcu(b, rcu);
373 tipc_mon_delete(net, bearer_id);
374 }
375
376 int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
377 struct nlattr *attr[])
378 {
379 char *dev_name = strchr((const char *)b->name, ':') + 1;
380 int hwaddr_len = b->media->hwaddr_len;
381 u8 node_id[NODE_ID_LEN] = {0,};
382 struct net_device *dev;
383
384 /* Find device with specified name */
385 dev = dev_get_by_name(net, dev_name);
386 if (!dev)
387 return -ENODEV;
388 if (tipc_mtu_bad(dev, 0)) {
389 dev_put(dev);
390 return -EINVAL;
391 }
392
393 /* Autoconfigure own node identity if needed */
394 if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) {
395 memcpy(node_id, dev->dev_addr, hwaddr_len);
396 tipc_net_init(net, node_id, 0);
397 }
398 if (!tipc_own_id(net)) {
399 dev_put(dev);
400 pr_warn("Failed to obtain node identity\n");
401 return -EINVAL;
402 }
403
404 /* Associate TIPC bearer with L2 bearer */
405 rcu_assign_pointer(b->media_ptr, dev);
406 b->pt.dev = dev;
407 b->pt.type = htons(ETH_P_TIPC);
408 b->pt.func = tipc_l2_rcv_msg;
409 dev_add_pack(&b->pt);
410 memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
411 memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
412 b->bcast_addr.media_id = b->media->type_id;
413 b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
414 b->mtu = dev->mtu;
415 b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
416 rcu_assign_pointer(dev->tipc_ptr, b);
417 return 0;
418 }
419
420 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
421 *
422 * Mark L2 bearer as inactive so that incoming buffers are thrown away
423 */
424 void tipc_disable_l2_media(struct tipc_bearer *b)
425 {
426 struct net_device *dev;
427
428 dev = (struct net_device *)rtnl_dereference(b->media_ptr);
429 dev_remove_pack(&b->pt);
430 RCU_INIT_POINTER(dev->tipc_ptr, NULL);
431 synchronize_net();
432 dev_put(dev);
433 }
434
435 /**
436 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
437 * @skb: the packet to be sent
438 * @b: the bearer through which the packet is to be sent
439 * @dest: peer destination address
440 */
441 int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
442 struct tipc_bearer *b, struct tipc_media_addr *dest)
443 {
444 struct net_device *dev;
445 int delta;
446
447 dev = (struct net_device *)rcu_dereference(b->media_ptr);
448 if (!dev)
449 return 0;
450
451 delta = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
452 if ((delta > 0) && pskb_expand_head(skb, delta, 0, GFP_ATOMIC)) {
453 kfree_skb(skb);
454 return 0;
455 }
456 skb_reset_network_header(skb);
457 skb->dev = dev;
458 skb->protocol = htons(ETH_P_TIPC);
459 dev_hard_header(skb, dev, ETH_P_TIPC, dest->value,
460 dev->dev_addr, skb->len);
461 dev_queue_xmit(skb);
462 return 0;
463 }
464
465 bool tipc_bearer_bcast_support(struct net *net, u32 bearer_id)
466 {
467 bool supp = false;
468 struct tipc_bearer *b;
469
470 rcu_read_lock();
471 b = bearer_get(net, bearer_id);
472 if (b)
473 supp = (b->bcast_addr.broadcast == TIPC_BROADCAST_SUPPORT);
474 rcu_read_unlock();
475 return supp;
476 }
477
478 int tipc_bearer_mtu(struct net *net, u32 bearer_id)
479 {
480 int mtu = 0;
481 struct tipc_bearer *b;
482
483 rcu_read_lock();
484 b = rcu_dereference(tipc_net(net)->bearer_list[bearer_id]);
485 if (b)
486 mtu = b->mtu;
487 rcu_read_unlock();
488 return mtu;
489 }
490
491 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
492 */
493 void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
494 struct sk_buff *skb,
495 struct tipc_media_addr *dest)
496 {
497 struct tipc_msg *hdr = buf_msg(skb);
498 struct tipc_bearer *b;
499
500 rcu_read_lock();
501 b = bearer_get(net, bearer_id);
502 if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr))))
503 b->media->send_msg(net, skb, b, dest);
504 else
505 kfree_skb(skb);
506 rcu_read_unlock();
507 }
508
509 /* tipc_bearer_xmit() -send buffer to destination over bearer
510 */
511 void tipc_bearer_xmit(struct net *net, u32 bearer_id,
512 struct sk_buff_head *xmitq,
513 struct tipc_media_addr *dst)
514 {
515 struct tipc_bearer *b;
516 struct sk_buff *skb, *tmp;
517
518 if (skb_queue_empty(xmitq))
519 return;
520
521 rcu_read_lock();
522 b = bearer_get(net, bearer_id);
523 if (unlikely(!b))
524 __skb_queue_purge(xmitq);
525 skb_queue_walk_safe(xmitq, skb, tmp) {
526 __skb_dequeue(xmitq);
527 if (likely(test_bit(0, &b->up) || msg_is_reset(buf_msg(skb))))
528 b->media->send_msg(net, skb, b, dst);
529 else
530 kfree_skb(skb);
531 }
532 rcu_read_unlock();
533 }
534
535 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
536 */
537 void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
538 struct sk_buff_head *xmitq)
539 {
540 struct tipc_net *tn = tipc_net(net);
541 int net_id = tn->net_id;
542 struct tipc_bearer *b;
543 struct sk_buff *skb, *tmp;
544 struct tipc_msg *hdr;
545
546 rcu_read_lock();
547 b = bearer_get(net, bearer_id);
548 if (unlikely(!b || !test_bit(0, &b->up)))
549 __skb_queue_purge(xmitq);
550 skb_queue_walk_safe(xmitq, skb, tmp) {
551 hdr = buf_msg(skb);
552 msg_set_non_seq(hdr, 1);
553 msg_set_mc_netid(hdr, net_id);
554 __skb_dequeue(xmitq);
555 b->media->send_msg(net, skb, b, &b->bcast_addr);
556 }
557 rcu_read_unlock();
558 }
559
560 /**
561 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
562 * @buf: the received packet
563 * @dev: the net device that the packet was received on
564 * @pt: the packet_type structure which was used to register this handler
565 * @orig_dev: the original receive net device in case the device is a bond
566 *
567 * Accept only packets explicitly sent to this node, or broadcast packets;
568 * ignores packets sent using interface multicast, and traffic sent to other
569 * nodes (which can happen if interface is running in promiscuous mode).
570 */
571 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
572 struct packet_type *pt, struct net_device *orig_dev)
573 {
574 struct tipc_bearer *b;
575
576 rcu_read_lock();
577 b = rcu_dereference(dev->tipc_ptr) ?:
578 rcu_dereference(orig_dev->tipc_ptr);
579 if (likely(b && test_bit(0, &b->up) &&
580 (skb->pkt_type <= PACKET_MULTICAST))) {
581 skb_mark_not_on_list(skb);
582 tipc_rcv(dev_net(b->pt.dev), skb, b);
583 rcu_read_unlock();
584 return NET_RX_SUCCESS;
585 }
586 rcu_read_unlock();
587 kfree_skb(skb);
588 return NET_RX_DROP;
589 }
590
591 /**
592 * tipc_l2_device_event - handle device events from network device
593 * @nb: the context of the notification
594 * @evt: the type of event
595 * @ptr: the net device that the event was on
596 *
597 * This function is called by the Ethernet driver in case of link
598 * change event.
599 */
600 static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
601 void *ptr)
602 {
603 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
604 struct net *net = dev_net(dev);
605 struct tipc_bearer *b;
606
607 b = rtnl_dereference(dev->tipc_ptr);
608 if (!b)
609 return NOTIFY_DONE;
610
611 trace_tipc_l2_device_event(dev, b, evt);
612 switch (evt) {
613 case NETDEV_CHANGE:
614 if (netif_carrier_ok(dev) && netif_oper_up(dev)) {
615 test_and_set_bit_lock(0, &b->up);
616 break;
617 }
618 /* fall through */
619 case NETDEV_GOING_DOWN:
620 clear_bit_unlock(0, &b->up);
621 tipc_reset_bearer(net, b);
622 break;
623 case NETDEV_UP:
624 test_and_set_bit_lock(0, &b->up);
625 break;
626 case NETDEV_CHANGEMTU:
627 if (tipc_mtu_bad(dev, 0)) {
628 bearer_disable(net, b);
629 break;
630 }
631 b->mtu = dev->mtu;
632 tipc_reset_bearer(net, b);
633 break;
634 case NETDEV_CHANGEADDR:
635 b->media->raw2addr(b, &b->addr,
636 (char *)dev->dev_addr);
637 tipc_reset_bearer(net, b);
638 break;
639 case NETDEV_UNREGISTER:
640 case NETDEV_CHANGENAME:
641 bearer_disable(net, b);
642 break;
643 }
644 return NOTIFY_OK;
645 }
646
647 static struct notifier_block notifier = {
648 .notifier_call = tipc_l2_device_event,
649 .priority = 0,
650 };
651
652 int tipc_bearer_setup(void)
653 {
654 return register_netdevice_notifier(&notifier);
655 }
656
657 void tipc_bearer_cleanup(void)
658 {
659 unregister_netdevice_notifier(&notifier);
660 }
661
662 void tipc_bearer_stop(struct net *net)
663 {
664 struct tipc_net *tn = net_generic(net, tipc_net_id);
665 struct tipc_bearer *b;
666 u32 i;
667
668 for (i = 0; i < MAX_BEARERS; i++) {
669 b = rtnl_dereference(tn->bearer_list[i]);
670 if (b) {
671 bearer_disable(net, b);
672 tn->bearer_list[i] = NULL;
673 }
674 }
675 }
676
677 /* Caller should hold rtnl_lock to protect the bearer */
678 static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
679 struct tipc_bearer *bearer, int nlflags)
680 {
681 void *hdr;
682 struct nlattr *attrs;
683 struct nlattr *prop;
684
685 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
686 nlflags, TIPC_NL_BEARER_GET);
687 if (!hdr)
688 return -EMSGSIZE;
689
690 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER);
691 if (!attrs)
692 goto msg_full;
693
694 if (nla_put_string(msg->skb, TIPC_NLA_BEARER_NAME, bearer->name))
695 goto attr_msg_full;
696
697 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_PROP);
698 if (!prop)
699 goto prop_msg_full;
700 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, bearer->priority))
701 goto prop_msg_full;
702 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, bearer->tolerance))
703 goto prop_msg_full;
704 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bearer->window))
705 goto prop_msg_full;
706 if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP)
707 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, bearer->mtu))
708 goto prop_msg_full;
709
710 nla_nest_end(msg->skb, prop);
711
712 #ifdef CONFIG_TIPC_MEDIA_UDP
713 if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP) {
714 if (tipc_udp_nl_add_bearer_data(msg, bearer))
715 goto attr_msg_full;
716 }
717 #endif
718
719 nla_nest_end(msg->skb, attrs);
720 genlmsg_end(msg->skb, hdr);
721
722 return 0;
723
724 prop_msg_full:
725 nla_nest_cancel(msg->skb, prop);
726 attr_msg_full:
727 nla_nest_cancel(msg->skb, attrs);
728 msg_full:
729 genlmsg_cancel(msg->skb, hdr);
730
731 return -EMSGSIZE;
732 }
733
734 int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb)
735 {
736 int err;
737 int i = cb->args[0];
738 struct tipc_bearer *bearer;
739 struct tipc_nl_msg msg;
740 struct net *net = sock_net(skb->sk);
741 struct tipc_net *tn = net_generic(net, tipc_net_id);
742
743 if (i == MAX_BEARERS)
744 return 0;
745
746 msg.skb = skb;
747 msg.portid = NETLINK_CB(cb->skb).portid;
748 msg.seq = cb->nlh->nlmsg_seq;
749
750 rtnl_lock();
751 for (i = 0; i < MAX_BEARERS; i++) {
752 bearer = rtnl_dereference(tn->bearer_list[i]);
753 if (!bearer)
754 continue;
755
756 err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
757 if (err)
758 break;
759 }
760 rtnl_unlock();
761
762 cb->args[0] = i;
763 return skb->len;
764 }
765
766 int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info)
767 {
768 int err;
769 char *name;
770 struct sk_buff *rep;
771 struct tipc_bearer *bearer;
772 struct tipc_nl_msg msg;
773 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
774 struct net *net = genl_info_net(info);
775
776 if (!info->attrs[TIPC_NLA_BEARER])
777 return -EINVAL;
778
779 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
780 info->attrs[TIPC_NLA_BEARER],
781 tipc_nl_bearer_policy, info->extack);
782 if (err)
783 return err;
784
785 if (!attrs[TIPC_NLA_BEARER_NAME])
786 return -EINVAL;
787 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
788
789 rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
790 if (!rep)
791 return -ENOMEM;
792
793 msg.skb = rep;
794 msg.portid = info->snd_portid;
795 msg.seq = info->snd_seq;
796
797 rtnl_lock();
798 bearer = tipc_bearer_find(net, name);
799 if (!bearer) {
800 err = -EINVAL;
801 goto err_out;
802 }
803
804 err = __tipc_nl_add_bearer(&msg, bearer, 0);
805 if (err)
806 goto err_out;
807 rtnl_unlock();
808
809 return genlmsg_reply(rep, info);
810 err_out:
811 rtnl_unlock();
812 nlmsg_free(rep);
813
814 return err;
815 }
816
817 int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
818 {
819 int err;
820 char *name;
821 struct tipc_bearer *bearer;
822 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
823 struct net *net = sock_net(skb->sk);
824
825 if (!info->attrs[TIPC_NLA_BEARER])
826 return -EINVAL;
827
828 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
829 info->attrs[TIPC_NLA_BEARER],
830 tipc_nl_bearer_policy, info->extack);
831 if (err)
832 return err;
833
834 if (!attrs[TIPC_NLA_BEARER_NAME])
835 return -EINVAL;
836
837 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
838
839 bearer = tipc_bearer_find(net, name);
840 if (!bearer)
841 return -EINVAL;
842
843 bearer_disable(net, bearer);
844
845 return 0;
846 }
847
848 int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
849 {
850 int err;
851
852 rtnl_lock();
853 err = __tipc_nl_bearer_disable(skb, info);
854 rtnl_unlock();
855
856 return err;
857 }
858
859 int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
860 {
861 int err;
862 char *bearer;
863 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
864 struct net *net = sock_net(skb->sk);
865 u32 domain = 0;
866 u32 prio;
867
868 prio = TIPC_MEDIA_LINK_PRI;
869
870 if (!info->attrs[TIPC_NLA_BEARER])
871 return -EINVAL;
872
873 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
874 info->attrs[TIPC_NLA_BEARER],
875 tipc_nl_bearer_policy, info->extack);
876 if (err)
877 return err;
878
879 if (!attrs[TIPC_NLA_BEARER_NAME])
880 return -EINVAL;
881
882 bearer = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
883
884 if (attrs[TIPC_NLA_BEARER_DOMAIN])
885 domain = nla_get_u32(attrs[TIPC_NLA_BEARER_DOMAIN]);
886
887 if (attrs[TIPC_NLA_BEARER_PROP]) {
888 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
889
890 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
891 props);
892 if (err)
893 return err;
894
895 if (props[TIPC_NLA_PROP_PRIO])
896 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
897 }
898
899 return tipc_enable_bearer(net, bearer, domain, prio, attrs);
900 }
901
902 int tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
903 {
904 int err;
905
906 rtnl_lock();
907 err = __tipc_nl_bearer_enable(skb, info);
908 rtnl_unlock();
909
910 return err;
911 }
912
913 int tipc_nl_bearer_add(struct sk_buff *skb, struct genl_info *info)
914 {
915 int err;
916 char *name;
917 struct tipc_bearer *b;
918 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
919 struct net *net = sock_net(skb->sk);
920
921 if (!info->attrs[TIPC_NLA_BEARER])
922 return -EINVAL;
923
924 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
925 info->attrs[TIPC_NLA_BEARER],
926 tipc_nl_bearer_policy, info->extack);
927 if (err)
928 return err;
929
930 if (!attrs[TIPC_NLA_BEARER_NAME])
931 return -EINVAL;
932 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
933
934 rtnl_lock();
935 b = tipc_bearer_find(net, name);
936 if (!b) {
937 rtnl_unlock();
938 return -EINVAL;
939 }
940
941 #ifdef CONFIG_TIPC_MEDIA_UDP
942 if (attrs[TIPC_NLA_BEARER_UDP_OPTS]) {
943 err = tipc_udp_nl_bearer_add(b,
944 attrs[TIPC_NLA_BEARER_UDP_OPTS]);
945 if (err) {
946 rtnl_unlock();
947 return err;
948 }
949 }
950 #endif
951 rtnl_unlock();
952
953 return 0;
954 }
955
956 int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
957 {
958 struct tipc_bearer *b;
959 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
960 struct net *net = sock_net(skb->sk);
961 char *name;
962 int err;
963
964 if (!info->attrs[TIPC_NLA_BEARER])
965 return -EINVAL;
966
967 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
968 info->attrs[TIPC_NLA_BEARER],
969 tipc_nl_bearer_policy, info->extack);
970 if (err)
971 return err;
972
973 if (!attrs[TIPC_NLA_BEARER_NAME])
974 return -EINVAL;
975 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
976
977 b = tipc_bearer_find(net, name);
978 if (!b)
979 return -EINVAL;
980
981 if (attrs[TIPC_NLA_BEARER_PROP]) {
982 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
983
984 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
985 props);
986 if (err)
987 return err;
988
989 if (props[TIPC_NLA_PROP_TOL]) {
990 b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
991 tipc_node_apply_property(net, b, TIPC_NLA_PROP_TOL);
992 }
993 if (props[TIPC_NLA_PROP_PRIO])
994 b->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
995 if (props[TIPC_NLA_PROP_WIN])
996 b->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
997 if (props[TIPC_NLA_PROP_MTU]) {
998 if (b->media->type_id != TIPC_MEDIA_TYPE_UDP)
999 return -EINVAL;
1000 #ifdef CONFIG_TIPC_MEDIA_UDP
1001 if (tipc_udp_mtu_bad(nla_get_u32
1002 (props[TIPC_NLA_PROP_MTU])))
1003 return -EINVAL;
1004 b->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1005 tipc_node_apply_property(net, b, TIPC_NLA_PROP_MTU);
1006 #endif
1007 }
1008 }
1009
1010 return 0;
1011 }
1012
1013 int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1014 {
1015 int err;
1016
1017 rtnl_lock();
1018 err = __tipc_nl_bearer_set(skb, info);
1019 rtnl_unlock();
1020
1021 return err;
1022 }
1023
1024 static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
1025 struct tipc_media *media, int nlflags)
1026 {
1027 void *hdr;
1028 struct nlattr *attrs;
1029 struct nlattr *prop;
1030
1031 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1032 nlflags, TIPC_NL_MEDIA_GET);
1033 if (!hdr)
1034 return -EMSGSIZE;
1035
1036 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA);
1037 if (!attrs)
1038 goto msg_full;
1039
1040 if (nla_put_string(msg->skb, TIPC_NLA_MEDIA_NAME, media->name))
1041 goto attr_msg_full;
1042
1043 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA_PROP);
1044 if (!prop)
1045 goto prop_msg_full;
1046 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, media->priority))
1047 goto prop_msg_full;
1048 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, media->tolerance))
1049 goto prop_msg_full;
1050 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, media->window))
1051 goto prop_msg_full;
1052 if (media->type_id == TIPC_MEDIA_TYPE_UDP)
1053 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, media->mtu))
1054 goto prop_msg_full;
1055
1056 nla_nest_end(msg->skb, prop);
1057 nla_nest_end(msg->skb, attrs);
1058 genlmsg_end(msg->skb, hdr);
1059
1060 return 0;
1061
1062 prop_msg_full:
1063 nla_nest_cancel(msg->skb, prop);
1064 attr_msg_full:
1065 nla_nest_cancel(msg->skb, attrs);
1066 msg_full:
1067 genlmsg_cancel(msg->skb, hdr);
1068
1069 return -EMSGSIZE;
1070 }
1071
1072 int tipc_nl_media_dump(struct sk_buff *skb, struct netlink_callback *cb)
1073 {
1074 int err;
1075 int i = cb->args[0];
1076 struct tipc_nl_msg msg;
1077
1078 if (i == MAX_MEDIA)
1079 return 0;
1080
1081 msg.skb = skb;
1082 msg.portid = NETLINK_CB(cb->skb).portid;
1083 msg.seq = cb->nlh->nlmsg_seq;
1084
1085 rtnl_lock();
1086 for (; media_info_array[i] != NULL; i++) {
1087 err = __tipc_nl_add_media(&msg, media_info_array[i],
1088 NLM_F_MULTI);
1089 if (err)
1090 break;
1091 }
1092 rtnl_unlock();
1093
1094 cb->args[0] = i;
1095 return skb->len;
1096 }
1097
1098 int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info)
1099 {
1100 int err;
1101 char *name;
1102 struct tipc_nl_msg msg;
1103 struct tipc_media *media;
1104 struct sk_buff *rep;
1105 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1106
1107 if (!info->attrs[TIPC_NLA_MEDIA])
1108 return -EINVAL;
1109
1110 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1111 info->attrs[TIPC_NLA_MEDIA],
1112 tipc_nl_media_policy, info->extack);
1113 if (err)
1114 return err;
1115
1116 if (!attrs[TIPC_NLA_MEDIA_NAME])
1117 return -EINVAL;
1118 name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1119
1120 rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1121 if (!rep)
1122 return -ENOMEM;
1123
1124 msg.skb = rep;
1125 msg.portid = info->snd_portid;
1126 msg.seq = info->snd_seq;
1127
1128 rtnl_lock();
1129 media = tipc_media_find(name);
1130 if (!media) {
1131 err = -EINVAL;
1132 goto err_out;
1133 }
1134
1135 err = __tipc_nl_add_media(&msg, media, 0);
1136 if (err)
1137 goto err_out;
1138 rtnl_unlock();
1139
1140 return genlmsg_reply(rep, info);
1141 err_out:
1142 rtnl_unlock();
1143 nlmsg_free(rep);
1144
1145 return err;
1146 }
1147
1148 int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1149 {
1150 int err;
1151 char *name;
1152 struct tipc_media *m;
1153 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1154
1155 if (!info->attrs[TIPC_NLA_MEDIA])
1156 return -EINVAL;
1157
1158 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1159 info->attrs[TIPC_NLA_MEDIA],
1160 tipc_nl_media_policy, info->extack);
1161
1162 if (!attrs[TIPC_NLA_MEDIA_NAME])
1163 return -EINVAL;
1164 name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1165
1166 m = tipc_media_find(name);
1167 if (!m)
1168 return -EINVAL;
1169
1170 if (attrs[TIPC_NLA_MEDIA_PROP]) {
1171 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1172
1173 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_MEDIA_PROP],
1174 props);
1175 if (err)
1176 return err;
1177
1178 if (props[TIPC_NLA_PROP_TOL])
1179 m->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1180 if (props[TIPC_NLA_PROP_PRIO])
1181 m->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1182 if (props[TIPC_NLA_PROP_WIN])
1183 m->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1184 if (props[TIPC_NLA_PROP_MTU]) {
1185 if (m->type_id != TIPC_MEDIA_TYPE_UDP)
1186 return -EINVAL;
1187 #ifdef CONFIG_TIPC_MEDIA_UDP
1188 if (tipc_udp_mtu_bad(nla_get_u32
1189 (props[TIPC_NLA_PROP_MTU])))
1190 return -EINVAL;
1191 m->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
1192 #endif
1193 }
1194 }
1195
1196 return 0;
1197 }
1198
1199 int tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1200 {
1201 int err;
1202
1203 rtnl_lock();
1204 err = __tipc_nl_media_set(skb, info);
1205 rtnl_unlock();
1206
1207 return err;
1208 }
Ubuntu Hirsute Linux kernel mirror