bearer.c 30.6 KB
Newer Older
P
Per Liden 已提交
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
P
Per Liden 已提交
6 7
 * All rights reserved.
 *
P
Per Liden 已提交
8
 * Redistribution and use in source and binary forms, with or without
P
Per Liden 已提交
9 10
 * modification, are permitted provided that the following conditions are met:
 *
P
Per Liden 已提交
11 12 13 14 15 16 17 18
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
P
Per Liden 已提交
19
 *
P
Per Liden 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
P
Per Liden 已提交
34 35 36
 * POSSIBILITY OF SUCH DAMAGE.
 */

37
#include <net/sock.h>
P
Per Liden 已提交
38 39
#include "core.h"
#include "bearer.h"
40
#include "link.h"
P
Per Liden 已提交
41
#include "discover.h"
42
#include "monitor.h"
43
#include "bcast.h"
44
#include "netlink.h"
R
Richard Alpe 已提交
45
#include "udp_media.h"
46
#include "trace.h"
47
#include "crypto.h"
P
Per Liden 已提交
48

49
#define MAX_ADDR_STR 60
P
Per Liden 已提交
50

51
static struct tipc_media * const media_info_array[] = {
52 53 54
	&eth_media_info,
#ifdef CONFIG_TIPC_MEDIA_IB
	&ib_media_info,
E
Erik Hugne 已提交
55 56 57
#endif
#ifdef CONFIG_TIPC_MEDIA_UDP
	&udp_media_info,
58 59 60
#endif
	NULL
};
P
Per Liden 已提交
61

62 63 64 65
static struct tipc_bearer *bearer_get(struct net *net, int bearer_id)
{
	struct tipc_net *tn = tipc_net(net);

66
	return rcu_dereference(tn->bearer_list[bearer_id]);
67 68
}

69
static void bearer_disable(struct net *net, struct tipc_bearer *b);
70 71
static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
			   struct packet_type *pt, struct net_device *orig_dev);
72

P
Per Liden 已提交
73
/**
74
 * tipc_media_find - locates specified media object by name
P
Per Liden 已提交
75
 */
76
struct tipc_media *tipc_media_find(const char *name)
P
Per Liden 已提交
77 78 79
{
	u32 i;

80 81
	for (i = 0; media_info_array[i] != NULL; i++) {
		if (!strcmp(media_info_array[i]->name, name))
82
			break;
P
Per Liden 已提交
83
	}
84
	return media_info_array[i];
P
Per Liden 已提交
85 86
}

87 88 89
/**
 * media_find_id - locates specified media object by type identifier
 */
90
static struct tipc_media *media_find_id(u8 type)
91 92 93
{
	u32 i;

94 95
	for (i = 0; media_info_array[i] != NULL; i++) {
		if (media_info_array[i]->type_id == type)
96
			break;
97
	}
98
	return media_info_array[i];
P
Per Liden 已提交
99 100 101
}

/**
102
 * tipc_media_addr_printf - record media address in print buffer
P
Per Liden 已提交
103
 */
T
Tuong Lien 已提交
104
int tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
P
Per Liden 已提交
105
{
106
	char addr_str[MAX_ADDR_STR];
107
	struct tipc_media *m;
108
	int ret;
P
Per Liden 已提交
109

110
	m = media_find_id(a->media_id);
P
Per Liden 已提交
111

112 113
	if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
		ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
114 115
	else {
		u32 i;
P
Per Liden 已提交
116

R
Richard Alpe 已提交
117
		ret = scnprintf(buf, len, "UNKNOWN(%u)", a->media_id);
118
		for (i = 0; i < sizeof(a->value); i++)
T
Tuong Lien 已提交
119 120
			ret += scnprintf(buf + ret, len - ret,
					    "-%x", a->value[i]);
P
Per Liden 已提交
121
	}
T
Tuong Lien 已提交
122
	return ret;
P
Per Liden 已提交
123 124 125 126
}

/**
 * bearer_name_validate - validate & (optionally) deconstruct bearer name
127 128
 * @name: ptr to bearer name string
 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
129
 *
P
Per Liden 已提交
130 131
 * Returns 1 if bearer name is valid, otherwise 0.
 */
132
static int bearer_name_validate(const char *name,
133
				struct tipc_bearer_names *name_parts)
P
Per Liden 已提交
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
{
	char name_copy[TIPC_MAX_BEARER_NAME];
	char *media_name;
	char *if_name;
	u32 media_len;
	u32 if_len;

	/* copy bearer name & ensure length is OK */
	name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
	/* need above in case non-Posix strncpy() doesn't pad with nulls */
	strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
	if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
		return 0;

	/* ensure all component parts of bearer name are present */
	media_name = name_copy;
150 151
	if_name = strchr(media_name, ':');
	if (if_name == NULL)
P
Per Liden 已提交
152 153 154 155 156 157
		return 0;
	*(if_name++) = 0;
	media_len = if_name - media_name;
	if_len = strlen(if_name) + 1;

	/* validate component parts of bearer name */
158
	if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
159
	    (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
P
Per Liden 已提交
160 161 162 163 164 165 166 167 168 169 170
		return 0;

	/* return bearer name components, if necessary */
	if (name_parts) {
		strcpy(name_parts->media_name, media_name);
		strcpy(name_parts->if_name, if_name);
	}
	return 1;
}

/**
171
 * tipc_bearer_find - locates bearer object with matching bearer name
P
Per Liden 已提交
172
 */
173
struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
P
Per Liden 已提交
174
{
175
	struct tipc_net *tn = net_generic(net, tipc_net_id);
176
	struct tipc_bearer *b;
P
Per Liden 已提交
177 178
	u32 i;

179
	for (i = 0; i < MAX_BEARERS; i++) {
180 181 182
		b = rtnl_dereference(tn->bearer_list[i]);
		if (b && (!strcmp(b->name, name)))
			return b;
P
Per Liden 已提交
183
	}
184
	return NULL;
P
Per Liden 已提交
185 186
}

187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
/*     tipc_bearer_get_name - get the bearer name from its id.
 *     @net: network namespace
 *     @name: a pointer to the buffer where the name will be stored.
 *     @bearer_id: the id to get the name from.
 */
int tipc_bearer_get_name(struct net *net, char *name, u32 bearer_id)
{
	struct tipc_net *tn = tipc_net(net);
	struct tipc_bearer *b;

	if (bearer_id >= MAX_BEARERS)
		return -EINVAL;

	b = rtnl_dereference(tn->bearer_list[bearer_id]);
	if (!b)
		return -EINVAL;

	strcpy(name, b->name);
	return 0;
}

208
void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
P
Per Liden 已提交
209
{
210
	struct tipc_net *tn = net_generic(net, tipc_net_id);
211
	struct tipc_bearer *b;
212 213

	rcu_read_lock();
214
	b = rcu_dereference(tn->bearer_list[bearer_id]);
215
	if (b)
216
		tipc_disc_add_dest(b->disc);
217
	rcu_read_unlock();
P
Per Liden 已提交
218 219
}

220
void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
P
Per Liden 已提交
221
{
222
	struct tipc_net *tn = net_generic(net, tipc_net_id);
223
	struct tipc_bearer *b;
224 225

	rcu_read_lock();
226
	b = rcu_dereference(tn->bearer_list[bearer_id]);
227
	if (b)
228
		tipc_disc_remove_dest(b->disc);
229
	rcu_read_unlock();
P
Per Liden 已提交
230 231 232 233
}

/**
 * tipc_enable_bearer - enable bearer with the given name
234
 */
235
static int tipc_enable_bearer(struct net *net, const char *name,
236
			      u32 disc_domain, u32 prio,
E
Erik Hugne 已提交
237
			      struct nlattr *attr[])
P
Per Liden 已提交
238
{
239 240 241
	struct tipc_net *tn = tipc_net(net);
	struct tipc_bearer_names b_names;
	int with_this_prio = 1;
242 243
	struct tipc_bearer *b;
	struct tipc_media *m;
244
	struct sk_buff *skb;
245
	int bearer_id = 0;
P
Per Liden 已提交
246
	int res = -EINVAL;
247
	char *errstr = "";
P
Per Liden 已提交
248

249
	if (!bearer_name_validate(name, &b_names)) {
250 251
		errstr = "illegal name";
		goto rejected;
252
	}
253 254 255 256

	if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
		errstr = "illegal priority";
		goto rejected;
257
	}
P
Per Liden 已提交
258

259 260
	m = tipc_media_find(b_names.media_name);
	if (!m) {
261 262
		errstr = "media not registered";
		goto rejected;
P
Per Liden 已提交
263
	}
P
Per Liden 已提交
264

265 266
	if (prio == TIPC_MEDIA_LINK_PRI)
		prio = m->priority;
P
Per Liden 已提交
267

268 269 270 271 272
	/* Check new bearer vs existing ones and find free bearer id if any */
	while (bearer_id < MAX_BEARERS) {
		b = rtnl_dereference(tn->bearer_list[bearer_id]);
		if (!b)
			break;
273
		if (!strcmp(name, b->name)) {
274 275
			errstr = "already enabled";
			goto rejected;
P
Per Liden 已提交
276
		}
277 278 279 280 281 282 283 284 285 286
		bearer_id++;
		if (b->priority != prio)
			continue;
		if (++with_this_prio <= 2)
			continue;
		pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
			name, prio);
		if (prio == TIPC_MIN_LINK_PRI) {
			errstr = "cannot adjust to lower";
			goto rejected;
P
Per Liden 已提交
287
		}
288 289 290 291
		pr_warn("Bearer <%s>: trying with adjusted priority\n", name);
		prio--;
		bearer_id = 0;
		with_this_prio = 1;
P
Per Liden 已提交
292
	}
293

P
Per Liden 已提交
294
	if (bearer_id >= MAX_BEARERS) {
295 296
		errstr = "max 3 bearers permitted";
		goto rejected;
P
Per Liden 已提交
297 298
	}

299 300
	b = kzalloc(sizeof(*b), GFP_ATOMIC);
	if (!b)
Y
Ying Xue 已提交
301 302
		return -ENOMEM;

303 304 305
	strcpy(b->name, name);
	b->media = m;
	res = m->enable_media(net, b, attr);
P
Per Liden 已提交
306
	if (res) {
307
		kfree(b);
308 309
		errstr = "failed to enable media";
		goto rejected;
P
Per Liden 已提交
310 311
	}

312 313 314 315 316
	b->identity = bearer_id;
	b->tolerance = m->tolerance;
	b->window = m->window;
	b->domain = disc_domain;
	b->net_plane = bearer_id + 'A';
317
	b->priority = prio;
318
	test_and_set_bit_lock(0, &b->up);
T
Tuong Lien 已提交
319
	refcount_set(&b->refcnt, 1);
320

321
	res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
322
	if (res) {
323
		bearer_disable(net, b);
324 325
		errstr = "failed to create discoverer";
		goto rejected;
326
	}
327

328
	rcu_assign_pointer(tn->bearer_list[bearer_id], b);
329 330
	if (skb)
		tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
331

332 333
	if (tipc_mon_create(net, bearer_id)) {
		bearer_disable(net, b);
334
		return -ENOMEM;
335
	}
336

337 338
	pr_info("Enabled bearer <%s>, priority %u\n", name, prio);

339 340
	return res;
rejected:
341
	pr_warn("Enabling of bearer <%s> rejected, %s\n", name, errstr);
P
Per Liden 已提交
342 343 344 345
	return res;
}

/**
346
 * tipc_reset_bearer - Reset all links established over this bearer
P
Per Liden 已提交
347
 */
348
static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
P
Per Liden 已提交
349
{
350 351 352
	pr_info("Resetting bearer <%s>\n", b->name);
	tipc_node_delete_links(net, b->identity);
	tipc_disc_reset(net, b);
353
	return 0;
P
Per Liden 已提交
354 355
}

T
Tuong Lien 已提交
356 357 358 359 360 361 362 363 364 365 366
bool tipc_bearer_hold(struct tipc_bearer *b)
{
	return (b && refcount_inc_not_zero(&b->refcnt));
}

void tipc_bearer_put(struct tipc_bearer *b)
{
	if (b && refcount_dec_and_test(&b->refcnt))
		kfree_rcu(b, rcu);
}

P
Per Liden 已提交
367
/**
368
 * bearer_disable
369
 *
Y
Ying Xue 已提交
370
 * Note: This routine assumes caller holds RTNL lock.
P
Per Liden 已提交
371
 */
372
static void bearer_disable(struct net *net, struct tipc_bearer *b)
P
Per Liden 已提交
373
{
374 375
	struct tipc_net *tn = tipc_net(net);
	int bearer_id = b->identity;
376

377
	pr_info("Disabling bearer <%s>\n", b->name);
378
	clear_bit_unlock(0, &b->up);
379
	tipc_node_delete_links(net, bearer_id);
380
	b->media->disable_media(b);
381
	RCU_INIT_POINTER(b->media_ptr, NULL);
382 383
	if (b->disc)
		tipc_disc_delete(b->disc);
384
	RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
T
Tuong Lien 已提交
385
	tipc_bearer_put(b);
386
	tipc_mon_delete(net, bearer_id);
P
Per Liden 已提交
387 388
}

E
Erik Hugne 已提交
389 390
int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
			 struct nlattr *attr[])
391
{
392 393 394
	char *dev_name = strchr((const char *)b->name, ':') + 1;
	int hwaddr_len = b->media->hwaddr_len;
	u8 node_id[NODE_ID_LEN] = {0,};
395 396 397
	struct net_device *dev;

	/* Find device with specified name */
398
	dev = dev_get_by_name(net, dev_name);
399 400
	if (!dev)
		return -ENODEV;
M
Michal Kubeček 已提交
401 402 403 404
	if (tipc_mtu_bad(dev, 0)) {
		dev_put(dev);
		return -EINVAL;
	}
405 406 407 408 409
	if (dev == net->loopback_dev) {
		dev_put(dev);
		pr_info("Enabling <%s> not permitted\n", b->name);
		return -EINVAL;
	}
410

411 412 413 414 415 416
	/* Autoconfigure own node identity if needed */
	if (!tipc_own_id(net) && hwaddr_len <= NODE_ID_LEN) {
		memcpy(node_id, dev->dev_addr, hwaddr_len);
		tipc_net_init(net, node_id, 0);
	}
	if (!tipc_own_id(net)) {
417
		dev_put(dev);
418 419 420 421
		pr_warn("Failed to obtain node identity\n");
		return -EINVAL;
	}

422
	/* Associate TIPC bearer with L2 bearer */
423
	rcu_assign_pointer(b->media_ptr, dev);
424 425 426 427
	b->pt.dev = dev;
	b->pt.type = htons(ETH_P_TIPC);
	b->pt.func = tipc_l2_rcv_msg;
	dev_add_pack(&b->pt);
428
	memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
429
	memcpy(b->bcast_addr.value, dev->broadcast, hwaddr_len);
430
	b->bcast_addr.media_id = b->media->type_id;
431
	b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
432
	b->mtu = dev->mtu;
433
	b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
434 435 436 437
	rcu_assign_pointer(dev->tipc_ptr, b);
	return 0;
}

438
/* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
439
 *
440
 * Mark L2 bearer as inactive so that incoming buffers are thrown away
441 442 443
 */
void tipc_disable_l2_media(struct tipc_bearer *b)
{
444 445 446
	struct net_device *dev;

	dev = (struct net_device *)rtnl_dereference(b->media_ptr);
447
	dev_remove_pack(&b->pt);
448
	RCU_INIT_POINTER(dev->tipc_ptr, NULL);
449
	synchronize_net();
450 451 452 453
	dev_put(dev);
}

/**
454
 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
455
 * @skb: the packet to be sent
456
 * @b: the bearer through which the packet is to be sent
457 458
 * @dest: peer destination address
 */
459
int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
460
		     struct tipc_bearer *b, struct tipc_media_addr *dest)
461
{
462
	struct net_device *dev;
463
	int delta;
464

465
	dev = (struct net_device *)rcu_dereference(b->media_ptr);
466 467
	if (!dev)
		return 0;
468

469 470 471 472 473
	delta = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
	if ((delta > 0) && pskb_expand_head(skb, delta, 0, GFP_ATOMIC)) {
		kfree_skb(skb);
		return 0;
	}
474 475 476 477 478 479
	skb_reset_network_header(skb);
	skb->dev = dev;
	skb->protocol = htons(ETH_P_TIPC);
	dev_hard_header(skb, dev, ETH_P_TIPC, dest->value,
			dev->dev_addr, skb->len);
	dev_queue_xmit(skb);
480 481 482
	return 0;
}

483 484 485 486 487 488 489 490 491 492 493 494 495
bool tipc_bearer_bcast_support(struct net *net, u32 bearer_id)
{
	bool supp = false;
	struct tipc_bearer *b;

	rcu_read_lock();
	b = bearer_get(net, bearer_id);
	if (b)
		supp = (b->bcast_addr.broadcast == TIPC_BROADCAST_SUPPORT);
	rcu_read_unlock();
	return supp;
}

496 497 498 499 500 501
int tipc_bearer_mtu(struct net *net, u32 bearer_id)
{
	int mtu = 0;
	struct tipc_bearer *b;

	rcu_read_lock();
502
	b = rcu_dereference(tipc_net(net)->bearer_list[bearer_id]);
503 504 505 506 507 508
	if (b)
		mtu = b->mtu;
	rcu_read_unlock();
	return mtu;
}

509 510 511 512 513 514
/* tipc_bearer_xmit_skb - sends buffer to destination over bearer
 */
void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
			  struct sk_buff *skb,
			  struct tipc_media_addr *dest)
{
515
	struct tipc_msg *hdr = buf_msg(skb);
516 517 518
	struct tipc_bearer *b;

	rcu_read_lock();
519
	b = bearer_get(net, bearer_id);
520 521 522 523 524 525 526
	if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr)))) {
#ifdef CONFIG_TIPC_CRYPTO
		tipc_crypto_xmit(net, &skb, b, dest, NULL);
		if (skb)
#endif
			b->media->send_msg(net, skb, b, dest);
	} else {
527
		kfree_skb(skb);
528
	}
529 530 531
	rcu_read_unlock();
}

532 533 534 535
/* tipc_bearer_xmit() -send buffer to destination over bearer
 */
void tipc_bearer_xmit(struct net *net, u32 bearer_id,
		      struct sk_buff_head *xmitq,
536 537
		      struct tipc_media_addr *dst,
		      struct tipc_node *__dnode)
538 539 540 541 542 543 544 545
{
	struct tipc_bearer *b;
	struct sk_buff *skb, *tmp;

	if (skb_queue_empty(xmitq))
		return;

	rcu_read_lock();
546
	b = bearer_get(net, bearer_id);
547 548 549 550
	if (unlikely(!b))
		__skb_queue_purge(xmitq);
	skb_queue_walk_safe(xmitq, skb, tmp) {
		__skb_dequeue(xmitq);
551 552 553 554 555 556 557
		if (likely(test_bit(0, &b->up) || msg_is_reset(buf_msg(skb)))) {
#ifdef CONFIG_TIPC_CRYPTO
			tipc_crypto_xmit(net, &skb, b, dst, __dnode);
			if (skb)
#endif
				b->media->send_msg(net, skb, b, dst);
		} else {
558
			kfree_skb(skb);
559
		}
560 561 562 563 564 565 566 567 568 569
	}
	rcu_read_unlock();
}

/* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
 */
void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
			 struct sk_buff_head *xmitq)
{
	struct tipc_net *tn = tipc_net(net);
570
	struct tipc_media_addr *dst;
571 572 573 574 575 576
	int net_id = tn->net_id;
	struct tipc_bearer *b;
	struct sk_buff *skb, *tmp;
	struct tipc_msg *hdr;

	rcu_read_lock();
577 578
	b = bearer_get(net, bearer_id);
	if (unlikely(!b || !test_bit(0, &b->up)))
579 580 581 582 583 584
		__skb_queue_purge(xmitq);
	skb_queue_walk_safe(xmitq, skb, tmp) {
		hdr = buf_msg(skb);
		msg_set_non_seq(hdr, 1);
		msg_set_mc_netid(hdr, net_id);
		__skb_dequeue(xmitq);
585 586 587 588 589 590
		dst = &b->bcast_addr;
#ifdef CONFIG_TIPC_CRYPTO
		tipc_crypto_xmit(net, &skb, b, dst, NULL);
		if (skb)
#endif
			b->media->send_msg(net, skb, b, dst);
591 592 593 594
	}
	rcu_read_unlock();
}

595 596 597 598 599 600 601 602 603 604 605
/**
 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
 * @buf: the received packet
 * @dev: the net device that the packet was received on
 * @pt: the packet_type structure which was used to register this handler
 * @orig_dev: the original receive net device in case the device is a bond
 *
 * Accept only packets explicitly sent to this node, or broadcast packets;
 * ignores packets sent using interface multicast, and traffic sent to other
 * nodes (which can happen if interface is running in promiscuous mode).
 */
606
static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
607 608
			   struct packet_type *pt, struct net_device *orig_dev)
{
609
	struct tipc_bearer *b;
610 611

	rcu_read_lock();
612 613
	b = rcu_dereference(dev->tipc_ptr) ?:
		rcu_dereference(orig_dev->tipc_ptr);
614
	if (likely(b && test_bit(0, &b->up) &&
615
		   (skb->pkt_type <= PACKET_MULTICAST))) {
616
		skb_mark_not_on_list(skb);
617
		TIPC_SKB_CB(skb)->flags = 0;
618
		tipc_rcv(dev_net(b->pt.dev), skb, b);
619 620
		rcu_read_unlock();
		return NET_RX_SUCCESS;
621 622
	}
	rcu_read_unlock();
623
	kfree_skb(skb);
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
	return NET_RX_DROP;
}

/**
 * tipc_l2_device_event - handle device events from network device
 * @nb: the context of the notification
 * @evt: the type of event
 * @ptr: the net device that the event was on
 *
 * This function is called by the Ethernet driver in case of link
 * change event.
 */
static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
				void *ptr)
{
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
640
	struct net *net = dev_net(dev);
641
	struct tipc_bearer *b;
642

643 644
	b = rtnl_dereference(dev->tipc_ptr);
	if (!b)
645 646
		return NOTIFY_DONE;

647
	trace_tipc_l2_device_event(dev, b, evt);
648 649
	switch (evt) {
	case NETDEV_CHANGE:
650 651
		if (netif_carrier_ok(dev) && netif_oper_up(dev)) {
			test_and_set_bit_lock(0, &b->up);
652
			break;
653 654
		}
		/* fall through */
655
	case NETDEV_GOING_DOWN:
656
		clear_bit_unlock(0, &b->up);
657 658
		tipc_reset_bearer(net, b);
		break;
659 660 661
	case NETDEV_UP:
		test_and_set_bit_lock(0, &b->up);
		break;
662
	case NETDEV_CHANGEMTU:
M
Michal Kubeček 已提交
663 664 665 666 667
		if (tipc_mtu_bad(dev, 0)) {
			bearer_disable(net, b);
			break;
		}
		b->mtu = dev->mtu;
668
		tipc_reset_bearer(net, b);
669
		break;
670
	case NETDEV_CHANGEADDR:
671
		b->media->raw2addr(b, &b->addr,
672
				   (char *)dev->dev_addr);
673
		tipc_reset_bearer(net, b);
674 675 676
		break;
	case NETDEV_UNREGISTER:
	case NETDEV_CHANGENAME:
677
		bearer_disable(net, b);
678 679 680 681 682 683 684 685 686 687 688 689
		break;
	}
	return NOTIFY_OK;
}

static struct notifier_block notifier = {
	.notifier_call  = tipc_l2_device_event,
	.priority	= 0,
};

int tipc_bearer_setup(void)
{
690
	return register_netdevice_notifier(&notifier);
691 692 693 694 695 696
}

void tipc_bearer_cleanup(void)
{
	unregister_netdevice_notifier(&notifier);
}
P
Per Liden 已提交
697

698
void tipc_bearer_stop(struct net *net)
P
Per Liden 已提交
699
{
700
	struct tipc_net *tn = net_generic(net, tipc_net_id);
701
	struct tipc_bearer *b;
P
Per Liden 已提交
702 703 704
	u32 i;

	for (i = 0; i < MAX_BEARERS; i++) {
705 706 707
		b = rtnl_dereference(tn->bearer_list[i]);
		if (b) {
			bearer_disable(net, b);
708
			tn->bearer_list[i] = NULL;
709
		}
P
Per Liden 已提交
710 711
	}
}
712

713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
void tipc_clone_to_loopback(struct net *net, struct sk_buff_head *pkts)
{
	struct net_device *dev = net->loopback_dev;
	struct sk_buff *skb, *_skb;
	int exp;

	skb_queue_walk(pkts, _skb) {
		skb = pskb_copy(_skb, GFP_ATOMIC);
		if (!skb)
			continue;

		exp = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
		if (exp > 0 && pskb_expand_head(skb, exp, 0, GFP_ATOMIC)) {
			kfree_skb(skb);
			continue;
		}

		skb_reset_network_header(skb);
		dev_hard_header(skb, dev, ETH_P_TIPC, dev->dev_addr,
				dev->dev_addr, skb->len);
		skb->dev = dev;
		skb->pkt_type = PACKET_HOST;
		skb->ip_summed = CHECKSUM_UNNECESSARY;
		skb->protocol = eth_type_trans(skb, dev);
		netif_rx_ni(skb);
	}
}

static int tipc_loopback_rcv_pkt(struct sk_buff *skb, struct net_device *dev,
				 struct packet_type *pt, struct net_device *od)
{
	consume_skb(skb);
	return NET_RX_SUCCESS;
}

int tipc_attach_loopback(struct net *net)
{
	struct net_device *dev = net->loopback_dev;
	struct tipc_net *tn = tipc_net(net);

	if (!dev)
		return -ENODEV;

	dev_hold(dev);
	tn->loopback_pt.dev = dev;
	tn->loopback_pt.type = htons(ETH_P_TIPC);
	tn->loopback_pt.func = tipc_loopback_rcv_pkt;
	dev_add_pack(&tn->loopback_pt);
	return 0;
}

void tipc_detach_loopback(struct net *net)
{
	struct tipc_net *tn = tipc_net(net);

	dev_remove_pack(&tn->loopback_pt);
	dev_put(net->loopback_dev);
}

772
/* Caller should hold rtnl_lock to protect the bearer */
773
static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
774
				struct tipc_bearer *bearer, int nlflags)
775 776 777 778 779
{
	void *hdr;
	struct nlattr *attrs;
	struct nlattr *prop;

780
	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
781
			  nlflags, TIPC_NL_BEARER_GET);
782 783 784
	if (!hdr)
		return -EMSGSIZE;

785
	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER);
786 787 788 789 790 791
	if (!attrs)
		goto msg_full;

	if (nla_put_string(msg->skb, TIPC_NLA_BEARER_NAME, bearer->name))
		goto attr_msg_full;

792
	prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_BEARER_PROP);
793 794 795 796 797 798 799 800
	if (!prop)
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, bearer->priority))
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, bearer->tolerance))
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bearer->window))
		goto prop_msg_full;
801 802 803
	if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP)
		if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, bearer->mtu))
			goto prop_msg_full;
804 805

	nla_nest_end(msg->skb, prop);
806 807 808 809 810 811 812 813

#ifdef CONFIG_TIPC_MEDIA_UDP
	if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP) {
		if (tipc_udp_nl_add_bearer_data(msg, bearer))
			goto attr_msg_full;
	}
#endif

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
	nla_nest_end(msg->skb, attrs);
	genlmsg_end(msg->skb, hdr);

	return 0;

prop_msg_full:
	nla_nest_cancel(msg->skb, prop);
attr_msg_full:
	nla_nest_cancel(msg->skb, attrs);
msg_full:
	genlmsg_cancel(msg->skb, hdr);

	return -EMSGSIZE;
}

int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	int err;
	int i = cb->args[0];
	struct tipc_bearer *bearer;
	struct tipc_nl_msg msg;
835 836
	struct net *net = sock_net(skb->sk);
	struct tipc_net *tn = net_generic(net, tipc_net_id);
837 838 839 840 841 842 843 844 845 846

	if (i == MAX_BEARERS)
		return 0;

	msg.skb = skb;
	msg.portid = NETLINK_CB(cb->skb).portid;
	msg.seq = cb->nlh->nlmsg_seq;

	rtnl_lock();
	for (i = 0; i < MAX_BEARERS; i++) {
847
		bearer = rtnl_dereference(tn->bearer_list[i]);
848 849 850
		if (!bearer)
			continue;

851
		err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
		if (err)
			break;
	}
	rtnl_unlock();

	cb->args[0] = i;
	return skb->len;
}

int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info)
{
	int err;
	char *name;
	struct sk_buff *rep;
	struct tipc_bearer *bearer;
	struct tipc_nl_msg msg;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
869
	struct net *net = genl_info_net(info);
870 871 872 873

	if (!info->attrs[TIPC_NLA_BEARER])
		return -EINVAL;

874 875 876
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
					  info->attrs[TIPC_NLA_BEARER],
					  tipc_nl_bearer_policy, info->extack);
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
	if (err)
		return err;

	if (!attrs[TIPC_NLA_BEARER_NAME])
		return -EINVAL;
	name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);

	rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!rep)
		return -ENOMEM;

	msg.skb = rep;
	msg.portid = info->snd_portid;
	msg.seq = info->snd_seq;

	rtnl_lock();
893
	bearer = tipc_bearer_find(net, name);
894 895 896 897 898
	if (!bearer) {
		err = -EINVAL;
		goto err_out;
	}

899
	err = __tipc_nl_add_bearer(&msg, bearer, 0);
900 901 902 903 904 905 906 907 908 909 910 911
	if (err)
		goto err_out;
	rtnl_unlock();

	return genlmsg_reply(rep, info);
err_out:
	rtnl_unlock();
	nlmsg_free(rep);

	return err;
}

912
int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
913 914 915 916 917
{
	int err;
	char *name;
	struct tipc_bearer *bearer;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
918
	struct net *net = sock_net(skb->sk);
919 920 921 922

	if (!info->attrs[TIPC_NLA_BEARER])
		return -EINVAL;

923 924 925
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
					  info->attrs[TIPC_NLA_BEARER],
					  tipc_nl_bearer_policy, info->extack);
926 927 928 929 930 931 932 933
	if (err)
		return err;

	if (!attrs[TIPC_NLA_BEARER_NAME])
		return -EINVAL;

	name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);

934
	bearer = tipc_bearer_find(net, name);
935
	if (!bearer)
936 937
		return -EINVAL;

938
	bearer_disable(net, bearer);
939 940 941 942

	return 0;
}

943 944 945 946 947 948 949 950 951 952 953
int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
{
	int err;

	rtnl_lock();
	err = __tipc_nl_bearer_disable(skb, info);
	rtnl_unlock();

	return err;
}

954
int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
955 956 957 958
{
	int err;
	char *bearer;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
959
	struct net *net = sock_net(skb->sk);
960
	u32 domain = 0;
961 962 963 964 965 966 967
	u32 prio;

	prio = TIPC_MEDIA_LINK_PRI;

	if (!info->attrs[TIPC_NLA_BEARER])
		return -EINVAL;

968 969 970
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
					  info->attrs[TIPC_NLA_BEARER],
					  tipc_nl_bearer_policy, info->extack);
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
	if (err)
		return err;

	if (!attrs[TIPC_NLA_BEARER_NAME])
		return -EINVAL;

	bearer = nla_data(attrs[TIPC_NLA_BEARER_NAME]);

	if (attrs[TIPC_NLA_BEARER_DOMAIN])
		domain = nla_get_u32(attrs[TIPC_NLA_BEARER_DOMAIN]);

	if (attrs[TIPC_NLA_BEARER_PROP]) {
		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];

		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
					      props);
		if (err)
			return err;

		if (props[TIPC_NLA_PROP_PRIO])
			prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
	}

994 995 996 997 998 999 1000
	return tipc_enable_bearer(net, bearer, domain, prio, attrs);
}

int tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
{
	int err;

1001
	rtnl_lock();
1002
	err = __tipc_nl_bearer_enable(skb, info);
1003 1004
	rtnl_unlock();

1005
	return err;
1006
}
1007

R
Richard Alpe 已提交
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
int tipc_nl_bearer_add(struct sk_buff *skb, struct genl_info *info)
{
	int err;
	char *name;
	struct tipc_bearer *b;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
	struct net *net = sock_net(skb->sk);

	if (!info->attrs[TIPC_NLA_BEARER])
		return -EINVAL;

1019 1020 1021
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
					  info->attrs[TIPC_NLA_BEARER],
					  tipc_nl_bearer_policy, info->extack);
R
Richard Alpe 已提交
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
	if (err)
		return err;

	if (!attrs[TIPC_NLA_BEARER_NAME])
		return -EINVAL;
	name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);

	rtnl_lock();
	b = tipc_bearer_find(net, name);
	if (!b) {
		rtnl_unlock();
		return -EINVAL;
	}

#ifdef CONFIG_TIPC_MEDIA_UDP
	if (attrs[TIPC_NLA_BEARER_UDP_OPTS]) {
		err = tipc_udp_nl_bearer_add(b,
					     attrs[TIPC_NLA_BEARER_UDP_OPTS]);
		if (err) {
			rtnl_unlock();
			return err;
		}
	}
#endif
	rtnl_unlock();

	return 0;
}

Y
Ying Xue 已提交
1051
int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1052 1053 1054
{
	struct tipc_bearer *b;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1055
	struct net *net = sock_net(skb->sk);
1056 1057
	char *name;
	int err;
1058 1059 1060 1061

	if (!info->attrs[TIPC_NLA_BEARER])
		return -EINVAL;

1062 1063 1064
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_BEARER_MAX,
					  info->attrs[TIPC_NLA_BEARER],
					  tipc_nl_bearer_policy, info->extack);
1065 1066 1067 1068 1069 1070 1071
	if (err)
		return err;

	if (!attrs[TIPC_NLA_BEARER_NAME])
		return -EINVAL;
	name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);

1072
	b = tipc_bearer_find(net, name);
Y
Ying Xue 已提交
1073
	if (!b)
1074 1075 1076 1077 1078 1079 1080
		return -EINVAL;

	if (attrs[TIPC_NLA_BEARER_PROP]) {
		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];

		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
					      props);
Y
Ying Xue 已提交
1081
		if (err)
1082 1083
			return err;

1084
		if (props[TIPC_NLA_PROP_TOL]) {
1085
			b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1086
			tipc_node_apply_property(net, b, TIPC_NLA_PROP_TOL);
1087
		}
1088 1089 1090 1091
		if (props[TIPC_NLA_PROP_PRIO])
			b->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
		if (props[TIPC_NLA_PROP_WIN])
			b->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
		if (props[TIPC_NLA_PROP_MTU]) {
			if (b->media->type_id != TIPC_MEDIA_TYPE_UDP)
				return -EINVAL;
#ifdef CONFIG_TIPC_MEDIA_UDP
			if (tipc_udp_mtu_bad(nla_get_u32
					     (props[TIPC_NLA_PROP_MTU])))
				return -EINVAL;
			b->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
			tipc_node_apply_property(net, b, TIPC_NLA_PROP_MTU);
#endif
		}
1103 1104 1105 1106
	}

	return 0;
}
1107

Y
Ying Xue 已提交
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
{
	int err;

	rtnl_lock();
	err = __tipc_nl_bearer_set(skb, info);
	rtnl_unlock();

	return err;
}

1119
static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
1120
			       struct tipc_media *media, int nlflags)
1121 1122 1123 1124 1125
{
	void *hdr;
	struct nlattr *attrs;
	struct nlattr *prop;

1126
	hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1127
			  nlflags, TIPC_NL_MEDIA_GET);
1128 1129 1130
	if (!hdr)
		return -EMSGSIZE;

1131
	attrs = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA);
1132 1133 1134 1135 1136 1137
	if (!attrs)
		goto msg_full;

	if (nla_put_string(msg->skb, TIPC_NLA_MEDIA_NAME, media->name))
		goto attr_msg_full;

1138
	prop = nla_nest_start_noflag(msg->skb, TIPC_NLA_MEDIA_PROP);
1139 1140 1141 1142 1143 1144 1145 1146
	if (!prop)
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, media->priority))
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, media->tolerance))
		goto prop_msg_full;
	if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, media->window))
		goto prop_msg_full;
1147 1148 1149
	if (media->type_id == TIPC_MEDIA_TYPE_UDP)
		if (nla_put_u32(msg->skb, TIPC_NLA_PROP_MTU, media->mtu))
			goto prop_msg_full;
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181

	nla_nest_end(msg->skb, prop);
	nla_nest_end(msg->skb, attrs);
	genlmsg_end(msg->skb, hdr);

	return 0;

prop_msg_full:
	nla_nest_cancel(msg->skb, prop);
attr_msg_full:
	nla_nest_cancel(msg->skb, attrs);
msg_full:
	genlmsg_cancel(msg->skb, hdr);

	return -EMSGSIZE;
}

int tipc_nl_media_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	int err;
	int i = cb->args[0];
	struct tipc_nl_msg msg;

	if (i == MAX_MEDIA)
		return 0;

	msg.skb = skb;
	msg.portid = NETLINK_CB(cb->skb).portid;
	msg.seq = cb->nlh->nlmsg_seq;

	rtnl_lock();
	for (; media_info_array[i] != NULL; i++) {
1182 1183
		err = __tipc_nl_add_media(&msg, media_info_array[i],
					  NLM_F_MULTI);
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
		if (err)
			break;
	}
	rtnl_unlock();

	cb->args[0] = i;
	return skb->len;
}

int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info)
{
	int err;
	char *name;
	struct tipc_nl_msg msg;
	struct tipc_media *media;
	struct sk_buff *rep;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];

	if (!info->attrs[TIPC_NLA_MEDIA])
		return -EINVAL;

1205 1206 1207
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
					  info->attrs[TIPC_NLA_MEDIA],
					  tipc_nl_media_policy, info->extack);
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
	if (err)
		return err;

	if (!attrs[TIPC_NLA_MEDIA_NAME])
		return -EINVAL;
	name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);

	rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!rep)
		return -ENOMEM;

	msg.skb = rep;
	msg.portid = info->snd_portid;
	msg.seq = info->snd_seq;

	rtnl_lock();
	media = tipc_media_find(name);
	if (!media) {
		err = -EINVAL;
		goto err_out;
	}

1230
	err = __tipc_nl_add_media(&msg, media, 0);
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
	if (err)
		goto err_out;
	rtnl_unlock();

	return genlmsg_reply(rep, info);
err_out:
	rtnl_unlock();
	nlmsg_free(rep);

	return err;
}
1242

Y
Ying Xue 已提交
1243
int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1244 1245 1246 1247 1248 1249 1250 1251 1252
{
	int err;
	char *name;
	struct tipc_media *m;
	struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];

	if (!info->attrs[TIPC_NLA_MEDIA])
		return -EINVAL;

1253 1254 1255
	err = nla_parse_nested_deprecated(attrs, TIPC_NLA_MEDIA_MAX,
					  info->attrs[TIPC_NLA_MEDIA],
					  tipc_nl_media_policy, info->extack);
1256 1257 1258 1259 1260 1261

	if (!attrs[TIPC_NLA_MEDIA_NAME])
		return -EINVAL;
	name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);

	m = tipc_media_find(name);
Y
Ying Xue 已提交
1262
	if (!m)
1263 1264 1265 1266 1267 1268 1269
		return -EINVAL;

	if (attrs[TIPC_NLA_MEDIA_PROP]) {
		struct nlattr *props[TIPC_NLA_PROP_MAX + 1];

		err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_MEDIA_PROP],
					      props);
Y
Ying Xue 已提交
1270
		if (err)
1271 1272 1273 1274 1275 1276 1277 1278
			return err;

		if (props[TIPC_NLA_PROP_TOL])
			m->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
		if (props[TIPC_NLA_PROP_PRIO])
			m->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
		if (props[TIPC_NLA_PROP_WIN])
			m->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
		if (props[TIPC_NLA_PROP_MTU]) {
			if (m->type_id != TIPC_MEDIA_TYPE_UDP)
				return -EINVAL;
#ifdef CONFIG_TIPC_MEDIA_UDP
			if (tipc_udp_mtu_bad(nla_get_u32
					     (props[TIPC_NLA_PROP_MTU])))
				return -EINVAL;
			m->mtu = nla_get_u32(props[TIPC_NLA_PROP_MTU]);
#endif
		}
1289 1290 1291 1292
	}

	return 0;
}
Y
Ying Xue 已提交
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303

int tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
{
	int err;

	rtnl_lock();
	err = __tipc_nl_media_set(skb, info);
	rtnl_unlock();

	return err;
}