ALSA: hda - Update descriptions about new position_fix values
[linux-2.6-block.git] / net / tipc / bearer.c
CommitLineData
b97bf3fd
PL
1/*
2 * net/tipc/bearer.c: TIPC bearer code
c4307285 3 *
35c55c98 4 * Copyright (c) 1996-2006, 2013-2016, Ericsson AB
e4d050cb 5 * Copyright (c) 2004-2006, 2010-2013, Wind River Systems
b97bf3fd
PL
6 * All rights reserved.
7 *
9ea1fd3c 8 * Redistribution and use in source and binary forms, with or without
b97bf3fd
PL
9 * modification, are permitted provided that the following conditions are met:
10 *
9ea1fd3c
PL
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.
b97bf3fd 19 *
9ea1fd3c
PL
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
b97bf3fd
PL
34 * POSSIBILITY OF SUCH DAMAGE.
35 */
36
7f9f95d9 37#include <net/sock.h>
b97bf3fd 38#include "core.h"
b97bf3fd 39#include "bearer.h"
0655f6a8 40#include "link.h"
b97bf3fd 41#include "discover.h"
35c55c98 42#include "monitor.h"
1da46568 43#include "bcast.h"
49cc66ea 44#include "netlink.h"
ef20cd4d 45#include "udp_media.h"
cf5f55f7 46#include "trace.h"
b97bf3fd 47
a29a194a 48#define MAX_ADDR_STR 60
b97bf3fd 49
ef72a7e0 50static struct tipc_media * const media_info_array[] = {
5702dbab
JPM
51 &eth_media_info,
52#ifdef CONFIG_TIPC_MEDIA_IB
53 &ib_media_info,
d0f91938
EH
54#endif
55#ifdef CONFIG_TIPC_MEDIA_UDP
56 &udp_media_info,
5702dbab
JPM
57#endif
58 NULL
59};
b97bf3fd 60
0d051bf9
JPM
61static struct tipc_bearer *bearer_get(struct net *net, int bearer_id)
62{
63 struct tipc_net *tn = tipc_net(net);
64
30a4616c 65 return rcu_dereference(tn->bearer_list[bearer_id]);
0d051bf9
JPM
66}
67
1a90632d 68static void bearer_disable(struct net *net, struct tipc_bearer *b);
d55c60eb
PB
69static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
70 struct packet_type *pt, struct net_device *orig_dev);
3a777ff8 71
b97bf3fd 72/**
5c216e1d 73 * tipc_media_find - locates specified media object by name
b97bf3fd 74 */
358a0d1c 75struct tipc_media *tipc_media_find(const char *name)
b97bf3fd 76{
b97bf3fd
PL
77 u32 i;
78
ef72a7e0
JPM
79 for (i = 0; media_info_array[i] != NULL; i++) {
80 if (!strcmp(media_info_array[i]->name, name))
5702dbab 81 break;
b97bf3fd 82 }
ef72a7e0 83 return media_info_array[i];
b97bf3fd
PL
84}
85
c79be454
AS
86/**
87 * media_find_id - locates specified media object by type identifier
88 */
358a0d1c 89static struct tipc_media *media_find_id(u8 type)
c79be454
AS
90{
91 u32 i;
92
ef72a7e0
JPM
93 for (i = 0; media_info_array[i] != NULL; i++) {
94 if (media_info_array[i]->type_id == type)
5702dbab 95 break;
c79be454 96 }
ef72a7e0 97 return media_info_array[i];
b97bf3fd
PL
98}
99
100/**
4323add6 101 * tipc_media_addr_printf - record media address in print buffer
b97bf3fd 102 */
b4b9771b 103int tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
b97bf3fd 104{
c61b666e 105 char addr_str[MAX_ADDR_STR];
1a90632d 106 struct tipc_media *m;
dc1aed37 107 int ret;
b97bf3fd 108
1a90632d 109 m = media_find_id(a->media_id);
b97bf3fd 110
1a90632d
JPM
111 if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
112 ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
c61b666e 113 else {
c61b666e 114 u32 i;
b97bf3fd 115
941787b8 116 ret = scnprintf(buf, len, "UNKNOWN(%u)", a->media_id);
3d749a6a 117 for (i = 0; i < sizeof(a->value); i++)
b4b9771b
TL
118 ret += scnprintf(buf + ret, len - ret,
119 "-%x", a->value[i]);
b97bf3fd 120 }
b4b9771b 121 return ret;
b97bf3fd
PL
122}
123
b97bf3fd
PL
124/**
125 * bearer_name_validate - validate & (optionally) deconstruct bearer name
2c53040f
BH
126 * @name: ptr to bearer name string
127 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
c4307285 128 *
b97bf3fd
PL
129 * Returns 1 if bearer name is valid, otherwise 0.
130 */
c4307285 131static int bearer_name_validate(const char *name,
f19765f4 132 struct tipc_bearer_names *name_parts)
b97bf3fd
PL
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 */
b97bf3fd
PL
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 */
b97bf3fd 148 media_name = name_copy;
2db9983a
AS
149 if_name = strchr(media_name, ':');
150 if (if_name == NULL)
b97bf3fd
PL
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 */
c4307285 157 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
fc073938 158 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
b97bf3fd
PL
159 return 0;
160
161 /* return bearer name components, if necessary */
b97bf3fd
PL
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/**
5c216e1d 170 * tipc_bearer_find - locates bearer object with matching bearer name
b97bf3fd 171 */
7f9f95d9 172struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
b97bf3fd 173{
7f9f95d9 174 struct tipc_net *tn = net_generic(net, tipc_net_id);
1a90632d 175 struct tipc_bearer *b;
b97bf3fd
PL
176 u32 i;
177
3874ccbb 178 for (i = 0; i < MAX_BEARERS; i++) {
1a90632d
JPM
179 b = rtnl_dereference(tn->bearer_list[i]);
180 if (b && (!strcmp(b->name, name)))
181 return b;
b97bf3fd 182 }
1fc54d8f 183 return NULL;
b97bf3fd
PL
184}
185
ff0d3e78
PB
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 */
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
7f9f95d9 207void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
b97bf3fd 208{
7f9f95d9 209 struct tipc_net *tn = net_generic(net, tipc_net_id);
1a90632d 210 struct tipc_bearer *b;
7a2f7d18
YX
211
212 rcu_read_lock();
30a4616c 213 b = rcu_dereference(tn->bearer_list[bearer_id]);
1a90632d 214 if (b)
b39e465e 215 tipc_disc_add_dest(b->disc);
7a2f7d18 216 rcu_read_unlock();
b97bf3fd
PL
217}
218
7f9f95d9 219void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
b97bf3fd 220{
7f9f95d9 221 struct tipc_net *tn = net_generic(net, tipc_net_id);
1a90632d 222 struct tipc_bearer *b;
7a2f7d18
YX
223
224 rcu_read_lock();
30a4616c 225 b = rcu_dereference(tn->bearer_list[bearer_id]);
1a90632d 226 if (b)
b39e465e 227 tipc_disc_remove_dest(b->disc);
7a2f7d18 228 rcu_read_unlock();
b97bf3fd
PL
229}
230
b97bf3fd
PL
231/**
232 * tipc_enable_bearer - enable bearer with the given name
c4307285 233 */
9ab15465 234static int tipc_enable_bearer(struct net *net, const char *name,
cb30a633 235 u32 disc_domain, u32 prio,
d0f91938 236 struct nlattr *attr[])
b97bf3fd 237{
cb30a633
JM
238 struct tipc_net *tn = tipc_net(net);
239 struct tipc_bearer_names b_names;
cb30a633 240 int with_this_prio = 1;
1a90632d
JPM
241 struct tipc_bearer *b;
242 struct tipc_media *m;
4e801fa1 243 struct sk_buff *skb;
cb30a633 244 int bearer_id = 0;
b97bf3fd 245 int res = -EINVAL;
cb30a633 246 char *errstr = "";
b97bf3fd 247
f19765f4 248 if (!bearer_name_validate(name, &b_names)) {
cb30a633
JM
249 errstr = "illegal name";
250 goto rejected;
a10bd924 251 }
cb30a633 252
cb30a633
JM
253 if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
254 errstr = "illegal priority";
255 goto rejected;
a10bd924 256 }
b97bf3fd 257
1a90632d
JPM
258 m = tipc_media_find(b_names.media_name);
259 if (!m) {
cb30a633
JM
260 errstr = "media not registered";
261 goto rejected;
b97bf3fd 262 }
16cb4b33 263
cb30a633
JM
264 if (prio == TIPC_MEDIA_LINK_PRI)
265 prio = m->priority;
b97bf3fd 266
cb30a633
JM
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;
1a90632d 272 if (!strcmp(name, b->name)) {
cb30a633
JM
273 errstr = "already enabled";
274 goto rejected;
b97bf3fd 275 }
cb30a633
JM
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;
b97bf3fd 286 }
cb30a633
JM
287 pr_warn("Bearer <%s>: trying with adjusted priority\n", name);
288 prio--;
289 bearer_id = 0;
290 with_this_prio = 1;
b97bf3fd 291 }
cb30a633 292
b97bf3fd 293 if (bearer_id >= MAX_BEARERS) {
cb30a633
JM
294 errstr = "max 3 bearers permitted";
295 goto rejected;
b97bf3fd
PL
296 }
297
1a90632d
JPM
298 b = kzalloc(sizeof(*b), GFP_ATOMIC);
299 if (!b)
7216cd94
YX
300 return -ENOMEM;
301
1a90632d
JPM
302 strcpy(b->name, name);
303 b->media = m;
304 res = m->enable_media(net, b, attr);
b97bf3fd 305 if (res) {
19142551 306 kfree(b);
cb30a633
JM
307 errstr = "failed to enable media";
308 goto rejected;
b97bf3fd
PL
309 }
310
1a90632d
JPM
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';
cb30a633 316 b->priority = prio;
0d051bf9 317 test_and_set_bit_lock(0, &b->up);
3a777ff8 318
4e801fa1 319 res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
3a777ff8 320 if (res) {
1a90632d 321 bearer_disable(net, b);
cb30a633
JM
322 errstr = "failed to create discoverer";
323 goto rejected;
3a777ff8 324 }
3874ccbb 325
1a90632d 326 rcu_assign_pointer(tn->bearer_list[bearer_id], b);
4e801fa1
JPM
327 if (skb)
328 tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
35c55c98 329
19142551
TR
330 if (tipc_mon_create(net, bearer_id)) {
331 bearer_disable(net, b);
35c55c98 332 return -ENOMEM;
19142551 333 }
35c55c98 334
20263641
JM
335 pr_info("Enabled bearer <%s>, priority %u\n", name, prio);
336
cb30a633
JM
337 return res;
338rejected:
20263641 339 pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
b97bf3fd
PL
340 return res;
341}
342
343/**
512137ee 344 * tipc_reset_bearer - Reset all links established over this bearer
b97bf3fd 345 */
1a90632d 346static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
b97bf3fd 347{
1a90632d
JPM
348 pr_info("Resetting bearer <%s>\n", b->name);
349 tipc_node_delete_links(net, b->identity);
350 tipc_disc_reset(net, b);
0e35fd5e 351 return 0;
b97bf3fd
PL
352}
353
354/**
617d3c7a 355 * bearer_disable
c4307285 356 *
7216cd94 357 * Note: This routine assumes caller holds RTNL lock.
b97bf3fd 358 */
1a90632d 359static void bearer_disable(struct net *net, struct tipc_bearer *b)
b97bf3fd 360{
5b7066c3
JPM
361 struct tipc_net *tn = tipc_net(net);
362 int bearer_id = b->identity;
3874ccbb 363
1a90632d 364 pr_info("Disabling bearer <%s>\n", b->name);
0d051bf9 365 clear_bit_unlock(0, &b->up);
5b7066c3 366 tipc_node_delete_links(net, bearer_id);
0d051bf9 367 b->media->disable_media(b);
1a90632d 368 RCU_INIT_POINTER(b->media_ptr, NULL);
b39e465e
JM
369 if (b->disc)
370 tipc_disc_delete(b->disc);
5b7066c3 371 RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
1a90632d 372 kfree_rcu(b, rcu);
35c55c98 373 tipc_mon_delete(net, bearer_id);
b97bf3fd
PL
374}
375
d0f91938
EH
376int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
377 struct nlattr *attr[])
e4d050cb 378{
52dfae5c
JM
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,};
e4d050cb 382 struct net_device *dev;
e4d050cb
YX
383
384 /* Find device with specified name */
52dfae5c 385 dev = dev_get_by_name(net, dev_name);
e4d050cb
YX
386 if (!dev)
387 return -ENODEV;
3de81b75
MK
388 if (tipc_mtu_bad(dev, 0)) {
389 dev_put(dev);
390 return -EINVAL;
391 }
e4d050cb 392
52dfae5c
JM
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)) {
63135ee0 399 dev_put(dev);
52dfae5c
JM
400 pr_warn("Failed to obtain node identity\n");
401 return -EINVAL;
402 }
403
38504c28 404 /* Associate TIPC bearer with L2 bearer */
2231c5af 405 rcu_assign_pointer(b->media_ptr, dev);
d55c60eb
PB
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);
38504c28 410 memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
52dfae5c 411 memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
e4d050cb 412 b->bcast_addr.media_id = b->media->type_id;
9999974a 413 b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
e4d050cb 414 b->mtu = dev->mtu;
38504c28 415 b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
e4d050cb
YX
416 rcu_assign_pointer(dev->tipc_ptr, b);
417 return 0;
418}
419
38504c28 420/* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
e4d050cb 421 *
282b3a05 422 * Mark L2 bearer as inactive so that incoming buffers are thrown away
e4d050cb
YX
423 */
424void tipc_disable_l2_media(struct tipc_bearer *b)
425{
2231c5af
YX
426 struct net_device *dev;
427
428 dev = (struct net_device *)rtnl_dereference(b->media_ptr);
d55c60eb 429 dev_remove_pack(&b->pt);
e4d050cb 430 RCU_INIT_POINTER(dev->tipc_ptr, NULL);
f1c8d8cb 431 synchronize_net();
e4d050cb
YX
432 dev_put(dev);
433}
434
435/**
38504c28 436 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
5b7066c3 437 * @skb: the packet to be sent
1a90632d 438 * @b: the bearer through which the packet is to be sent
e4d050cb
YX
439 * @dest: peer destination address
440 */
7214bcf8 441int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
1da46568 442 struct tipc_bearer *b, struct tipc_media_addr *dest)
e4d050cb 443{
2231c5af 444 struct net_device *dev;
e4d050cb 445 int delta;
2231c5af 446
30a4616c 447 dev = (struct net_device *)rcu_dereference(b->media_ptr);
2231c5af
YX
448 if (!dev)
449 return 0;
e4d050cb 450
0d051bf9
JPM
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 }
7214bcf8
JPM
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);
e4d050cb
YX
462 return 0;
463}
464
9999974a
JPM
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
959e1781
JPM
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();
30a4616c 484 b = rcu_dereference(tipc_net(net)->bearer_list[bearer_id]);
959e1781
JPM
485 if (b)
486 mtu = b->mtu;
487 rcu_read_unlock();
488 return mtu;
489}
490
60852d67
JPM
491/* tipc_bearer_xmit_skb - sends buffer to destination over bearer
492 */
493void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
494 struct sk_buff *skb,
495 struct tipc_media_addr *dest)
496{
0d051bf9 497 struct tipc_msg *hdr = buf_msg(skb);
60852d67
JPM
498 struct tipc_bearer *b;
499
500 rcu_read_lock();
0d051bf9
JPM
501 b = bearer_get(net, bearer_id);
502 if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr))))
60852d67 503 b->media->send_msg(net, skb, b, dest);
4e801fa1
JPM
504 else
505 kfree_skb(skb);
60852d67 506 rcu_read_unlock();
60852d67
JPM
507}
508
af9b028e
JPM
509/* tipc_bearer_xmit() -send buffer to destination over bearer
510 */
511void tipc_bearer_xmit(struct net *net, u32 bearer_id,
512 struct sk_buff_head *xmitq,
513 struct tipc_media_addr *dst)
514{
af9b028e
JPM
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();
0d051bf9 522 b = bearer_get(net, bearer_id);
4e801fa1
JPM
523 if (unlikely(!b))
524 __skb_queue_purge(xmitq);
525 skb_queue_walk_safe(xmitq, skb, tmp) {
526 __skb_dequeue(xmitq);
0d051bf9
JPM
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
5128b185 530 kfree_skb(skb);
b06b281e
JPM
531 }
532 rcu_read_unlock();
533}
534
535/* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
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();
0d051bf9
JPM
547 b = bearer_get(net, bearer_id);
548 if (unlikely(!b || !test_bit(0, &b->up)))
4e801fa1
JPM
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);
af9b028e
JPM
556 }
557 rcu_read_unlock();
558}
559
6e967adf
YX
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 */
4e801fa1 571static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
6e967adf
YX
572 struct packet_type *pt, struct net_device *orig_dev)
573{
1a90632d 574 struct tipc_bearer *b;
6e967adf 575
6e967adf 576 rcu_read_lock();
30a4616c
XL
577 b = rcu_dereference(dev->tipc_ptr) ?:
578 rcu_dereference(orig_dev->tipc_ptr);
0d051bf9 579 if (likely(b && test_bit(0, &b->up) &&
fed5f571 580 (skb->pkt_type <= PACKET_MULTICAST))) {
a8305bff 581 skb_mark_not_on_list(skb);
d55c60eb 582 tipc_rcv(dev_net(b->pt.dev), skb, b);
4e801fa1
JPM
583 rcu_read_unlock();
584 return NET_RX_SUCCESS;
6e967adf
YX
585 }
586 rcu_read_unlock();
4e801fa1 587 kfree_skb(skb);
6e967adf
YX
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 */
600static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
601 void *ptr)
602{
6e967adf 603 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
c93d3baa 604 struct net *net = dev_net(dev);
1a90632d 605 struct tipc_bearer *b;
6e967adf 606
1a90632d
JPM
607 b = rtnl_dereference(dev->tipc_ptr);
608 if (!b)
6e967adf 609 return NOTIFY_DONE;
6e967adf 610
cf5f55f7 611 trace_tipc_l2_device_event(dev, b, evt);
6e967adf
YX
612 switch (evt) {
613 case NETDEV_CHANGE:
94b6ddce
PB
614 if (netif_carrier_ok(dev) && netif_oper_up(dev)) {
615 test_and_set_bit_lock(0, &b->up);
6e967adf 616 break;
94b6ddce
PB
617 }
618 /* fall through */
282b3a05 619 case NETDEV_GOING_DOWN:
0d051bf9 620 clear_bit_unlock(0, &b->up);
5b7066c3
JPM
621 tipc_reset_bearer(net, b);
622 break;
94b6ddce
PB
623 case NETDEV_UP:
624 test_and_set_bit_lock(0, &b->up);
625 break;
6e967adf 626 case NETDEV_CHANGEMTU:
3de81b75
MK
627 if (tipc_mtu_bad(dev, 0)) {
628 bearer_disable(net, b);
629 break;
630 }
631 b->mtu = dev->mtu;
1a90632d 632 tipc_reset_bearer(net, b);
a21a584d 633 break;
6e967adf 634 case NETDEV_CHANGEADDR:
1a90632d 635 b->media->raw2addr(b, &b->addr,
5b7066c3 636 (char *)dev->dev_addr);
1a90632d 637 tipc_reset_bearer(net, b);
6e967adf
YX
638 break;
639 case NETDEV_UNREGISTER:
640 case NETDEV_CHANGENAME:
8e0deed9 641 bearer_disable(net, b);
6e967adf
YX
642 break;
643 }
6e967adf
YX
644 return NOTIFY_OK;
645}
646
6e967adf
YX
647static struct notifier_block notifier = {
648 .notifier_call = tipc_l2_device_event,
649 .priority = 0,
650};
651
652int tipc_bearer_setup(void)
653{
d55c60eb 654 return register_netdevice_notifier(&notifier);
6e967adf
YX
655}
656
657void tipc_bearer_cleanup(void)
658{
659 unregister_netdevice_notifier(&notifier);
6e967adf 660}
b97bf3fd 661
f2f9800d 662void tipc_bearer_stop(struct net *net)
b97bf3fd 663{
7f9f95d9 664 struct tipc_net *tn = net_generic(net, tipc_net_id);
1a90632d 665 struct tipc_bearer *b;
b97bf3fd
PL
666 u32 i;
667
b97bf3fd 668 for (i = 0; i < MAX_BEARERS; i++) {
1a90632d
JPM
669 b = rtnl_dereference(tn->bearer_list[i]);
670 if (b) {
671 bearer_disable(net, b);
7f9f95d9 672 tn->bearer_list[i] = NULL;
3874ccbb 673 }
b97bf3fd 674 }
b97bf3fd 675}
0655f6a8 676
35b9dd76 677/* Caller should hold rtnl_lock to protect the bearer */
d8182804 678static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
f2f67390 679 struct tipc_bearer *bearer, int nlflags)
35b9dd76
RA
680{
681 void *hdr;
682 struct nlattr *attrs;
683 struct nlattr *prop;
684
bfb3e5dd 685 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
f2f67390 686 nlflags, TIPC_NL_BEARER_GET);
35b9dd76
RA
687 if (!hdr)
688 return -EMSGSIZE;
689
ae0be8de 690 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER);
35b9dd76
RA
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
ae0be8de 697 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_PROP);
35b9dd76
RA
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;
682cd3cf
GM
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;
35b9dd76
RA
709
710 nla_nest_end(msg->skb, prop);
fdb3accc
RA
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
35b9dd76
RA
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;
7f9f95d9
YX
740 struct net *net = sock_net(skb->sk);
741 struct tipc_net *tn = net_generic(net, tipc_net_id);
35b9dd76
RA
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++) {
7f9f95d9 752 bearer = rtnl_dereference(tn->bearer_list[i]);
35b9dd76
RA
753 if (!bearer)
754 continue;
755
f2f67390 756 err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
35b9dd76
RA
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];
7f9f95d9 774 struct net *net = genl_info_net(info);
35b9dd76
RA
775
776 if (!info->attrs[TIPC_NLA_BEARER])
777 return -EINVAL;
778
8cb08174
JB
779 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
780 info->attrs[TIPC_NLA_BEARER],
781 tipc_nl_bearer_policy, info->extack);
35b9dd76
RA
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();
7f9f95d9 798 bearer = tipc_bearer_find(net, name);
35b9dd76
RA
799 if (!bearer) {
800 err = -EINVAL;
801 goto err_out;
802 }
803
f2f67390 804 err = __tipc_nl_add_bearer(&msg, bearer, 0);
35b9dd76
RA
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
d59d8b77 817int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
0655f6a8
RA
818{
819 int err;
820 char *name;
821 struct tipc_bearer *bearer;
822 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
9ab15465 823 struct net *net = sock_net(skb->sk);
0655f6a8
RA
824
825 if (!info->attrs[TIPC_NLA_BEARER])
826 return -EINVAL;
827
8cb08174
JB
828 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
829 info->attrs[TIPC_NLA_BEARER],
830 tipc_nl_bearer_policy, info->extack);
0655f6a8
RA
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
7f9f95d9 839 bearer = tipc_bearer_find(net, name);
d59d8b77 840 if (!bearer)
0655f6a8 841 return -EINVAL;
0655f6a8 842
b1c29f6b 843 bearer_disable(net, bearer);
0655f6a8
RA
844
845 return 0;
846}
847
d59d8b77
YX
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
45cf7edf 859int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
0655f6a8
RA
860{
861 int err;
862 char *bearer;
863 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
9ab15465 864 struct net *net = sock_net(skb->sk);
20263641 865 u32 domain = 0;
0655f6a8
RA
866 u32 prio;
867
868 prio = TIPC_MEDIA_LINK_PRI;
0655f6a8
RA
869
870 if (!info->attrs[TIPC_NLA_BEARER])
871 return -EINVAL;
872
8cb08174
JB
873 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
874 info->attrs[TIPC_NLA_BEARER],
875 tipc_nl_bearer_policy, info->extack);
0655f6a8
RA
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
45cf7edf
YX
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
0655f6a8 906 rtnl_lock();
45cf7edf 907 err = __tipc_nl_bearer_enable(skb, info);
0655f6a8
RA
908 rtnl_unlock();
909
45cf7edf 910 return err;
0655f6a8 911}
315c00bc 912
ef20cd4d
RA
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
8cb08174
JB
924 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
925 info->attrs[TIPC_NLA_BEARER],
926 tipc_nl_bearer_policy, info->extack);
ef20cd4d
RA
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
93532bb1 956int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
315c00bc 957{
315c00bc
RA
958 struct tipc_bearer *b;
959 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
c3d6fb85 960 struct net *net = sock_net(skb->sk);
37c64cf6
JM
961 char *name;
962 int err;
315c00bc
RA
963
964 if (!info->attrs[TIPC_NLA_BEARER])
965 return -EINVAL;
966
8cb08174
JB
967 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
968 info->attrs[TIPC_NLA_BEARER],
969 tipc_nl_bearer_policy, info->extack);
315c00bc
RA
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
7f9f95d9 977 b = tipc_bearer_find(net, name);
93532bb1 978 if (!b)
315c00bc 979 return -EINVAL;
315c00bc
RA
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);
93532bb1 986 if (err)
315c00bc 987 return err;
315c00bc 988
37c64cf6 989 if (props[TIPC_NLA_PROP_TOL]) {
315c00bc 990 b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
682cd3cf 991 tipc_node_apply_property(net, b, TIPC_NLA_PROP_TOL);
37c64cf6 992 }
315c00bc
RA
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]);
682cd3cf
GM
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 }
315c00bc 1008 }
315c00bc
RA
1009
1010 return 0;
1011}
46f15c67 1012
93532bb1
YX
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
d8182804 1024static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
f2f67390 1025 struct tipc_media *media, int nlflags)
46f15c67
RA
1026{
1027 void *hdr;
1028 struct nlattr *attrs;
1029 struct nlattr *prop;
1030
bfb3e5dd 1031 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
f2f67390 1032 nlflags, TIPC_NL_MEDIA_GET);
46f15c67
RA
1033 if (!hdr)
1034 return -EMSGSIZE;
1035
ae0be8de 1036 attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA);
46f15c67
RA
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
ae0be8de 1043 prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA_PROP);
46f15c67
RA
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;
901271e0
GM
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;
46f15c67
RA
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++) {
f2f67390
ND
1087 err = __tipc_nl_add_media(&msg, media_info_array[i],
1088 NLM_F_MULTI);
46f15c67
RA
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
8cb08174
JB
1110 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1111 info->attrs[TIPC_NLA_MEDIA],
1112 tipc_nl_media_policy, info->extack);
46f15c67
RA
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
f2f67390 1135 err = __tipc_nl_add_media(&msg, media, 0);
46f15c67
RA
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}
1e55417d 1147
07ffb223 1148int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1e55417d
RA
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
8cb08174
JB
1158 err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
1159 info->attrs[TIPC_NLA_MEDIA],
1160 tipc_nl_media_policy, info->extack);
1e55417d
RA
1161
1162 if (!attrs[TIPC_NLA_MEDIA_NAME])
1163 return -EINVAL;
1164 name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1165
1e55417d 1166 m = tipc_media_find(name);
07ffb223 1167 if (!m)
1e55417d 1168 return -EINVAL;
1e55417d
RA
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);
07ffb223 1175 if (err)
1e55417d 1176 return err;
1e55417d
RA
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]);
901271e0
GM
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 }
1e55417d 1194 }
1e55417d
RA
1195
1196 return 0;
1197}
07ffb223
YX
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}