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