1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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
50static struct tipc_media * const media_info_array[] = {
51 ð_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
61static 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
68static void bearer_disable(struct net *net, struct tipc_bearer *b);
69static 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
74
75struct 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
88
89static 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
102
103int 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
126
127
128
129
130
131static 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
141 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
142
143 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
144 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
145 return 0;
146
147
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
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
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
171
172struct 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
187
188
189
190
191int 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
207void 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
219void 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
233
234static 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
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;
338rejected:
339 pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
340 return res;
341}
342
343
344
345
346static 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
356
357
358
359static 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
376int 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
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
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
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
421
422
423
424void 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
437
438
439
440
441int 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
465bool 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
478int 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
492
493void 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
510
511void 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
536
537void 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
562
563
564
565
566
567
568
569
570
571static 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
593
594
595
596
597
598
599
600static 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
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
647static struct notifier_block notifier = {
648 .notifier_call = tipc_l2_device_event,
649 .priority = 0,
650};
651
652int tipc_bearer_setup(void)
653{
654 return register_netdevice_notifier(¬ifier);
655}
656
657void tipc_bearer_cleanup(void)
658{
659 unregister_netdevice_notifier(¬ifier);
660}
661
662void 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
678static 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
724prop_msg_full:
725 nla_nest_cancel(msg->skb, prop);
726attr_msg_full:
727 nla_nest_cancel(msg->skb, attrs);
728msg_full:
729 genlmsg_cancel(msg->skb, hdr);
730
731 return -EMSGSIZE;
732}
733
734int 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
766int 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);
810err_out:
811 rtnl_unlock();
812 nlmsg_free(rep);
813
814 return err;
815}
816
817int __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
848int 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
859int __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
902int 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
913int 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
956int __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
1013int 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
1024static 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
1062prop_msg_full:
1063 nla_nest_cancel(msg->skb, prop);
1064attr_msg_full:
1065 nla_nest_cancel(msg->skb, attrs);
1066msg_full:
1067 genlmsg_cancel(msg->skb, hdr);
1068
1069 return -EMSGSIZE;
1070}
1071
1072int 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
1098int 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);
1141err_out:
1142 rtnl_unlock();
1143 nlmsg_free(rep);
1144
1145 return err;
1146}
1147
1148int __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
1199int 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}
1209
