hard-interface.c 17.6 KB
Newer Older
1
/*
2
 * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 * Marek Lindner, Simon Wunderlich
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 *
 */

#include "main.h"
#include "hard-interface.h"
#include "soft-interface.h"
#include "send.h"
#include "translation-table.h"
#include "routing.h"
#include "bat_sysfs.h"
#include "originator.h"
#include "hash.h"

#include <linux/if_arp.h>

34 35 36 37 38 39

static int batman_skb_recv(struct sk_buff *skb,
			   struct net_device *dev,
			   struct packet_type *ptype,
			   struct net_device *orig_dev);

40
void hardif_free_rcu(struct rcu_head *rcu)
41
{
42
	struct hard_iface *hard_iface;
43

44 45 46
	hard_iface = container_of(rcu, struct hard_iface, rcu);
	dev_put(hard_iface->net_dev);
	kfree(hard_iface);
47 48
}

49
struct hard_iface *hardif_get_by_netdev(const struct net_device *net_dev)
50
{
51
	struct hard_iface *hard_iface;
52 53

	rcu_read_lock();
54 55 56
	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
		if (hard_iface->net_dev == net_dev &&
		    atomic_inc_not_zero(&hard_iface->refcount))
57 58 59
			goto out;
	}

60
	hard_iface = NULL;
61 62 63

out:
	rcu_read_unlock();
64
	return hard_iface;
65 66
}

67
static int is_valid_iface(const struct net_device *net_dev)
68 69 70 71 72 73 74 75 76 77 78
{
	if (net_dev->flags & IFF_LOOPBACK)
		return 0;

	if (net_dev->type != ARPHRD_ETHER)
		return 0;

	if (net_dev->addr_len != ETH_ALEN)
		return 0;

	/* no batman over batman */
79
	if (softif_is_valid(net_dev))
80 81 82 83 84 85 86 87 88
		return 0;

	/* Device is being bridged */
	/* if (net_dev->priv_flags & IFF_BRIDGE_PORT)
		return 0; */

	return 1;
}

89
static struct hard_iface *hardif_get_active(const struct net_device *soft_iface)
90
{
91
	struct hard_iface *hard_iface;
92 93

	rcu_read_lock();
94 95
	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
		if (hard_iface->soft_iface != soft_iface)
96 97
			continue;

98 99
		if (hard_iface->if_status == IF_ACTIVE &&
		    atomic_inc_not_zero(&hard_iface->refcount))
100 101 102
			goto out;
	}

103
	hard_iface = NULL;
104 105 106

out:
	rcu_read_unlock();
107
	return hard_iface;
108 109
}

110
static void primary_if_update_addr(struct bat_priv *bat_priv)
111 112
{
	struct vis_packet *vis_packet;
113 114 115 116 117
	struct hard_iface *primary_if;

	primary_if = primary_if_get_selected(bat_priv);
	if (!primary_if)
		goto out;
118 119 120

	vis_packet = (struct vis_packet *)
				bat_priv->my_vis_info->skb_packet->data;
121
	memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
122
	memcpy(vis_packet->sender_orig,
123 124 125 126 127
	       primary_if->net_dev->dev_addr, ETH_ALEN);

out:
	if (primary_if)
		hardif_free_ref(primary_if);
128 129
}

130 131
static void primary_if_select(struct bat_priv *bat_priv,
			      struct hard_iface *new_hard_iface)
132
{
133
	struct hard_iface *curr_hard_iface;
134
	struct batman_ogm_packet *batman_ogm_packet;
135

136
	ASSERT_RTNL();
137

138 139
	if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount))
		new_hard_iface = NULL;
140

141
	curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1);
142
	rcu_assign_pointer(bat_priv->primary_if, new_hard_iface);
143

144 145
	if (curr_hard_iface)
		hardif_free_ref(curr_hard_iface);
146

147
	if (!new_hard_iface)
148
		return;
149

150 151 152 153
	batman_ogm_packet = (struct batman_ogm_packet *)
						(new_hard_iface->packet_buff);
	batman_ogm_packet->flags = PRIMARIES_FIRST_HOP;
	batman_ogm_packet->ttl = TTL;
154

155
	primary_if_update_addr(bat_priv);
156 157
}

158
static bool hardif_is_iface_up(const struct hard_iface *hard_iface)
159
{
160
	if (hard_iface->net_dev->flags & IFF_UP)
161 162 163 164 165
		return true;

	return false;
}

166
static void update_mac_addresses(struct hard_iface *hard_iface)
167
{
168 169 170 171
	struct batman_ogm_packet *batman_ogm_packet;

	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
	memcpy(batman_ogm_packet->orig,
172
	       hard_iface->net_dev->dev_addr, ETH_ALEN);
173
	memcpy(batman_ogm_packet->prev_sender,
174
	       hard_iface->net_dev->dev_addr, ETH_ALEN);
175 176
}

177
static void check_known_mac_addr(const struct net_device *net_dev)
178
{
179
	const struct hard_iface *hard_iface;
180 181

	rcu_read_lock();
182 183 184
	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
		if ((hard_iface->if_status != IF_ACTIVE) &&
		    (hard_iface->if_status != IF_TO_BE_ACTIVATED))
185 186
			continue;

187
		if (hard_iface->net_dev == net_dev)
188 189
			continue;

190 191
		if (!compare_eth(hard_iface->net_dev->dev_addr,
				 net_dev->dev_addr))
192 193 194 195
			continue;

		pr_warning("The newly added mac address (%pM) already exists "
			   "on: %s\n", net_dev->dev_addr,
196
			   hard_iface->net_dev->name);
197 198 199 200 201 202 203 204
		pr_warning("It is strongly recommended to keep mac addresses "
			   "unique to avoid problems!\n");
	}
	rcu_read_unlock();
}

int hardif_min_mtu(struct net_device *soft_iface)
{
205 206
	const struct bat_priv *bat_priv = netdev_priv(soft_iface);
	const struct hard_iface *hard_iface;
207 208 209 210 211 212 213 214
	/* allow big frames if all devices are capable to do so
	 * (have MTU > 1500 + BAT_HEADER_LEN) */
	int min_mtu = ETH_DATA_LEN;

	if (atomic_read(&bat_priv->fragmentation))
		goto out;

	rcu_read_lock();
215 216 217
	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
		if ((hard_iface->if_status != IF_ACTIVE) &&
		    (hard_iface->if_status != IF_TO_BE_ACTIVATED))
218 219
			continue;

220
		if (hard_iface->soft_iface != soft_iface)
221 222
			continue;

223
		min_mtu = min_t(int, hard_iface->net_dev->mtu - BAT_HEADER_LEN,
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
				min_mtu);
	}
	rcu_read_unlock();
out:
	return min_mtu;
}

/* adjusts the MTU if a new interface with a smaller MTU appeared. */
void update_min_mtu(struct net_device *soft_iface)
{
	int min_mtu;

	min_mtu = hardif_min_mtu(soft_iface);
	if (soft_iface->mtu != min_mtu)
		soft_iface->mtu = min_mtu;
}

241
static void hardif_activate_interface(struct hard_iface *hard_iface)
242 243
{
	struct bat_priv *bat_priv;
244
	struct hard_iface *primary_if = NULL;
245

246
	if (hard_iface->if_status != IF_INACTIVE)
247
		goto out;
248

249
	bat_priv = netdev_priv(hard_iface->soft_iface);
250

251 252
	update_mac_addresses(hard_iface);
	hard_iface->if_status = IF_TO_BE_ACTIVATED;
253 254 255

	/**
	 * the first active interface becomes our primary interface or
256
	 * the next active interface after the old primary interface was removed
257
	 */
258 259 260
	primary_if = primary_if_get_selected(bat_priv);
	if (!primary_if)
		primary_if_select(bat_priv, hard_iface);
261

262 263
	bat_info(hard_iface->soft_iface, "Interface activated: %s\n",
		 hard_iface->net_dev->name);
264

265
	update_min_mtu(hard_iface->soft_iface);
266 267 268 269

out:
	if (primary_if)
		hardif_free_ref(primary_if);
270 271
}

272
static void hardif_deactivate_interface(struct hard_iface *hard_iface)
273
{
274 275
	if ((hard_iface->if_status != IF_ACTIVE) &&
	    (hard_iface->if_status != IF_TO_BE_ACTIVATED))
276 277
		return;

278
	hard_iface->if_status = IF_INACTIVE;
279

280 281
	bat_info(hard_iface->soft_iface, "Interface deactivated: %s\n",
		 hard_iface->net_dev->name);
282

283
	update_min_mtu(hard_iface->soft_iface);
284 285
}

286 287
int hardif_enable_interface(struct hard_iface *hard_iface,
			    const char *iface_name)
288 289
{
	struct bat_priv *bat_priv;
290
	struct batman_ogm_packet *batman_ogm_packet;
291 292
	struct net_device *soft_iface;
	int ret;
293

294
	if (hard_iface->if_status != IF_NOT_IN_USE)
295 296
		goto out;

297
	if (!atomic_inc_not_zero(&hard_iface->refcount))
298 299
		goto out;

300
	soft_iface = dev_get_by_name(&init_net, iface_name);
301

302 303
	if (!soft_iface) {
		soft_iface = softif_create(iface_name);
304

305 306
		if (!soft_iface) {
			ret = -ENOMEM;
307
			goto err;
308
		}
309 310

		/* dev_get_by_name() increases the reference counter for us */
311 312 313 314 315 316 317 318 319 320
		dev_hold(soft_iface);
	}

	if (!softif_is_valid(soft_iface)) {
		pr_err("Can't create batman mesh interface %s: "
		       "already exists as regular interface\n",
		       soft_iface->name);
		dev_put(soft_iface);
		ret = -EINVAL;
		goto err;
321 322
	}

323
	hard_iface->soft_iface = soft_iface;
324
	bat_priv = netdev_priv(hard_iface->soft_iface);
325
	hard_iface->packet_len = BATMAN_OGM_LEN;
326
	hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);
327

328 329 330
	if (!hard_iface->packet_buff) {
		bat_err(hard_iface->soft_iface, "Can't add interface packet "
			"(%s): out of memory\n", hard_iface->net_dev->name);
331
		ret = -ENOMEM;
332 333 334
		goto err;
	}

335 336 337 338 339 340 341 342 343
	batman_ogm_packet = (struct batman_ogm_packet *)
						(hard_iface->packet_buff);
	batman_ogm_packet->packet_type = BAT_OGM;
	batman_ogm_packet->version = COMPAT_VERSION;
	batman_ogm_packet->flags = NO_FLAGS;
	batman_ogm_packet->ttl = 2;
	batman_ogm_packet->tq = TQ_MAX_VALUE;
	batman_ogm_packet->tt_num_changes = 0;
	batman_ogm_packet->ttvn = 0;
344

345
	hard_iface->if_num = bat_priv->num_ifaces;
346
	bat_priv->num_ifaces++;
347 348
	hard_iface->if_status = IF_INACTIVE;
	orig_hash_add_if(hard_iface, bat_priv->num_ifaces);
349

350 351 352 353
	hard_iface->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN);
	hard_iface->batman_adv_ptype.func = batman_skb_recv;
	hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
	dev_add_pack(&hard_iface->batman_adv_ptype);
354

355 356 357 358
	atomic_set(&hard_iface->seqno, 1);
	atomic_set(&hard_iface->frag_seqno, 1);
	bat_info(hard_iface->soft_iface, "Adding interface: %s\n",
		 hard_iface->net_dev->name);
359

360
	if (atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu <
361
		ETH_DATA_LEN + BAT_HEADER_LEN)
362
		bat_info(hard_iface->soft_iface,
363 364 365 366 367
			"The MTU of interface %s is too small (%i) to handle "
			"the transport of batman-adv packets. Packets going "
			"over this interface will be fragmented on layer2 "
			"which could impact the performance. Setting the MTU "
			"to %zi would solve the problem.\n",
368
			hard_iface->net_dev->name, hard_iface->net_dev->mtu,
369 370
			ETH_DATA_LEN + BAT_HEADER_LEN);

371
	if (!atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu <
372
		ETH_DATA_LEN + BAT_HEADER_LEN)
373
		bat_info(hard_iface->soft_iface,
374 375 376 377
			"The MTU of interface %s is too small (%i) to handle "
			"the transport of batman-adv packets. If you experience"
			" problems getting traffic through try increasing the "
			"MTU to %zi.\n",
378
			hard_iface->net_dev->name, hard_iface->net_dev->mtu,
379 380
			ETH_DATA_LEN + BAT_HEADER_LEN);

381 382
	if (hardif_is_iface_up(hard_iface))
		hardif_activate_interface(hard_iface);
383
	else
384
		bat_err(hard_iface->soft_iface, "Not using interface %s "
385
			"(retrying later): interface not active\n",
386
			hard_iface->net_dev->name);
387 388

	/* begin scheduling originator messages on that interface */
389
	schedule_own_packet(hard_iface);
390 391 392 393 394

out:
	return 0;

err:
395
	hardif_free_ref(hard_iface);
396
	return ret;
397 398
}

399
void hardif_disable_interface(struct hard_iface *hard_iface)
400
{
401
	struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
402
	struct hard_iface *primary_if = NULL;
403

404 405
	if (hard_iface->if_status == IF_ACTIVE)
		hardif_deactivate_interface(hard_iface);
406

407
	if (hard_iface->if_status != IF_INACTIVE)
408
		goto out;
409

410 411 412
	bat_info(hard_iface->soft_iface, "Removing interface: %s\n",
		 hard_iface->net_dev->name);
	dev_remove_pack(&hard_iface->batman_adv_ptype);
413 414

	bat_priv->num_ifaces--;
415
	orig_hash_del_if(hard_iface, bat_priv->num_ifaces);
416

417 418
	primary_if = primary_if_get_selected(bat_priv);
	if (hard_iface == primary_if) {
419
		struct hard_iface *new_if;
420

421
		new_if = hardif_get_active(hard_iface->soft_iface);
422
		primary_if_select(bat_priv, new_if);
423 424

		if (new_if)
425
			hardif_free_ref(new_if);
426 427
	}

428 429 430
	kfree(hard_iface->packet_buff);
	hard_iface->packet_buff = NULL;
	hard_iface->if_status = IF_NOT_IN_USE;
431

432
	/* delete all references to this hard_iface */
433
	purge_orig_ref(bat_priv);
434 435
	purge_outstanding_packets(bat_priv, hard_iface);
	dev_put(hard_iface->soft_iface);
436 437 438

	/* nobody uses this interface anymore */
	if (!bat_priv->num_ifaces)
439
		softif_destroy(hard_iface->soft_iface);
440

441 442
	hard_iface->soft_iface = NULL;
	hardif_free_ref(hard_iface);
443 444 445 446

out:
	if (primary_if)
		hardif_free_ref(primary_if);
447 448
}

449
static struct hard_iface *hardif_add_interface(struct net_device *net_dev)
450
{
451
	struct hard_iface *hard_iface;
452 453
	int ret;

454 455
	ASSERT_RTNL();

456 457 458 459 460 461
	ret = is_valid_iface(net_dev);
	if (ret != 1)
		goto out;

	dev_hold(net_dev);

462
	hard_iface = kmalloc(sizeof(*hard_iface), GFP_ATOMIC);
463
	if (!hard_iface) {
464 465 466 467 468
		pr_err("Can't add interface (%s): out of memory\n",
		       net_dev->name);
		goto release_dev;
	}

469
	ret = sysfs_add_hardif(&hard_iface->hardif_obj, net_dev);
470 471 472
	if (ret)
		goto free_if;

473 474 475 476 477
	hard_iface->if_num = -1;
	hard_iface->net_dev = net_dev;
	hard_iface->soft_iface = NULL;
	hard_iface->if_status = IF_NOT_IN_USE;
	INIT_LIST_HEAD(&hard_iface->list);
478
	/* extra reference for return */
479
	atomic_set(&hard_iface->refcount, 2);
480

481 482
	check_known_mac_addr(hard_iface->net_dev);
	list_add_tail_rcu(&hard_iface->list, &hardif_list);
483

484
	return hard_iface;
485 486

free_if:
487
	kfree(hard_iface);
488 489 490 491 492 493
release_dev:
	dev_put(net_dev);
out:
	return NULL;
}

494
static void hardif_remove_interface(struct hard_iface *hard_iface)
495
{
496 497
	ASSERT_RTNL();

498
	/* first deactivate interface */
499 500
	if (hard_iface->if_status != IF_NOT_IN_USE)
		hardif_disable_interface(hard_iface);
501

502
	if (hard_iface->if_status != IF_NOT_IN_USE)
503 504
		return;

505 506 507
	hard_iface->if_status = IF_TO_BE_REMOVED;
	sysfs_del_hardif(&hard_iface->hardif_obj);
	hardif_free_ref(hard_iface);
508 509 510 511
}

void hardif_remove_interfaces(void)
{
512
	struct hard_iface *hard_iface, *hard_iface_tmp;
513

514
	rtnl_lock();
515 516 517 518
	list_for_each_entry_safe(hard_iface, hard_iface_tmp,
				 &hardif_list, list) {
		list_del_rcu(&hard_iface->list);
		hardif_remove_interface(hard_iface);
519 520 521 522 523 524 525
	}
	rtnl_unlock();
}

static int hard_if_event(struct notifier_block *this,
			 unsigned long event, void *ptr)
{
526
	struct net_device *net_dev = ptr;
527
	struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev);
528
	struct hard_iface *primary_if = NULL;
529 530
	struct bat_priv *bat_priv;

531 532
	if (!hard_iface && event == NETDEV_REGISTER)
		hard_iface = hardif_add_interface(net_dev);
533

534
	if (!hard_iface)
535 536 537 538
		goto out;

	switch (event) {
	case NETDEV_UP:
539
		hardif_activate_interface(hard_iface);
540 541 542
		break;
	case NETDEV_GOING_DOWN:
	case NETDEV_DOWN:
543
		hardif_deactivate_interface(hard_iface);
544 545
		break;
	case NETDEV_UNREGISTER:
546
		list_del_rcu(&hard_iface->list);
547

548
		hardif_remove_interface(hard_iface);
549 550
		break;
	case NETDEV_CHANGEMTU:
551 552
		if (hard_iface->soft_iface)
			update_min_mtu(hard_iface->soft_iface);
553 554
		break;
	case NETDEV_CHANGEADDR:
555
		if (hard_iface->if_status == IF_NOT_IN_USE)
556 557
			goto hardif_put;

558 559
		check_known_mac_addr(hard_iface->net_dev);
		update_mac_addresses(hard_iface);
560

561
		bat_priv = netdev_priv(hard_iface->soft_iface);
562 563 564 565 566 567
		primary_if = primary_if_get_selected(bat_priv);
		if (!primary_if)
			goto hardif_put;

		if (hard_iface == primary_if)
			primary_if_update_addr(bat_priv);
568 569 570
		break;
	default:
		break;
J
Joe Perches 已提交
571
	}
572 573

hardif_put:
574
	hardif_free_ref(hard_iface);
575
out:
576 577
	if (primary_if)
		hardif_free_ref(primary_if);
578 579 580
	return NOTIFY_DONE;
}

581
/* incoming packets with the batman ethertype received on any active hard
582
 * interface */
583 584 585
static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
			   struct packet_type *ptype,
			   struct net_device *orig_dev)
586 587
{
	struct bat_priv *bat_priv;
588
	struct batman_ogm_packet *batman_ogm_packet;
589
	struct hard_iface *hard_iface;
590 591
	int ret;

592
	hard_iface = container_of(ptype, struct hard_iface, batman_adv_ptype);
593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
	skb = skb_share_check(skb, GFP_ATOMIC);

	/* skb was released by skb_share_check() */
	if (!skb)
		goto err_out;

	/* packet should hold at least type and version */
	if (unlikely(!pskb_may_pull(skb, 2)))
		goto err_free;

	/* expect a valid ethernet header here. */
	if (unlikely(skb->mac_len != sizeof(struct ethhdr)
				|| !skb_mac_header(skb)))
		goto err_free;

608
	if (!hard_iface->soft_iface)
609 610
		goto err_free;

611
	bat_priv = netdev_priv(hard_iface->soft_iface);
612 613 614 615 616

	if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
		goto err_free;

	/* discard frames on not active interfaces */
617
	if (hard_iface->if_status != IF_ACTIVE)
618 619
		goto err_free;

620
	batman_ogm_packet = (struct batman_ogm_packet *)skb->data;
621

622
	if (batman_ogm_packet->version != COMPAT_VERSION) {
623 624
		bat_dbg(DBG_BATMAN, bat_priv,
			"Drop packet: incompatible batman version (%i)\n",
625
			batman_ogm_packet->version);
626 627 628 629 630 631
		goto err_free;
	}

	/* all receive handlers return whether they received or reused
	 * the supplied skb. if not, we have to free the skb. */

632
	switch (batman_ogm_packet->packet_type) {
633
		/* batman originator packet */
634
	case BAT_OGM:
635
		ret = recv_bat_packet(skb, hard_iface);
636 637 638 639
		break;

		/* batman icmp packet */
	case BAT_ICMP:
640
		ret = recv_icmp_packet(skb, hard_iface);
641 642 643 644
		break;

		/* unicast packet */
	case BAT_UNICAST:
645
		ret = recv_unicast_packet(skb, hard_iface);
646 647 648 649
		break;

		/* fragmented unicast packet */
	case BAT_UNICAST_FRAG:
650
		ret = recv_ucast_frag_packet(skb, hard_iface);
651 652 653 654
		break;

		/* broadcast packet */
	case BAT_BCAST:
655
		ret = recv_bcast_packet(skb, hard_iface);
656 657 658 659
		break;

		/* vis packet */
	case BAT_VIS:
660
		ret = recv_vis_packet(skb, hard_iface);
661
		break;
662 663 664 665
		/* Translation table query (request or response) */
	case BAT_TT_QUERY:
		ret = recv_tt_query(skb, hard_iface);
		break;
666 667 668 669
		/* Roaming advertisement */
	case BAT_ROAM_ADV:
		ret = recv_roam_adv(skb, hard_iface);
		break;
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
	default:
		ret = NET_RX_DROP;
	}

	if (ret == NET_RX_DROP)
		kfree_skb(skb);

	/* return NET_RX_SUCCESS in any case as we
	 * most probably dropped the packet for
	 * routing-logical reasons. */

	return NET_RX_SUCCESS;

err_free:
	kfree_skb(skb);
err_out:
	return NET_RX_DROP;
}

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
/* This function returns true if the interface represented by ifindex is a
 * 802.11 wireless device */
bool is_wifi_iface(int ifindex)
{
	struct net_device *net_device = NULL;
	bool ret = false;

	if (ifindex == NULL_IFINDEX)
		goto out;

	net_device = dev_get_by_index(&init_net, ifindex);
	if (!net_device)
		goto out;

#ifdef CONFIG_WIRELESS_EXT
	/* pre-cfg80211 drivers have to implement WEXT, so it is possible to
	 * check for wireless_handlers != NULL */
	if (net_device->wireless_handlers)
		ret = true;
	else
#endif
		/* cfg80211 drivers have to set ieee80211_ptr */
		if (net_device->ieee80211_ptr)
			ret = true;
out:
	if (net_device)
		dev_put(net_device);
	return ret;
}

719 720 721
struct notifier_block hard_if_notifier = {
	.notifier_call = hard_if_event,
};