Eric Lee / linux-smarc-t335x-v3.2

Commit 4a73a43741489a652588460e72be959e60bcb9ec

Authored by Linus Torvalds 2010-10-05 02:11:01 +0800

Exists in master and in 4 other branches

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6:
  vlan: dont drop packets from unknown vlans in promiscuous mode
  Phonet: Correct header retrieval after pskb_may_pull
  um: Proper Fix for f25c80a4: remove duplicate structure field initialization
  ip_gre: Fix dependencies wrt. ipv6.
  net-2.6: SYN retransmits: Add new parameter to retransmits_timed_out()
  iwl3945: queue the right work if the scan needs to be aborted
  mac80211: fix use-after-free

Showing 8 changed files Inline Diff

arch/um/drivers/net_kern.c
drivers/net/wireless/iwlwifi/iwl-agn-lib.c
drivers/net/wireless/iwlwifi/iwl3945-base.c
net/8021q/vlan_core.c
net/ipv4/Kconfig
net/ipv4/tcp_timer.c
net/mac80211/rx.c
net/phonet/pep.c

arch/um/drivers/net_kern.c

Diff comments View file @ 4a73a43

 /*
  * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and
  * James Leu (jleu@mindspring.net).
  * Copyright (C) 2001 by various other people who didn't put their name here.
  * Licensed under the GPL.
  */
 #include <linux/bootmem.h>
 #include <linux/etherdevice.h>
 #include <linux/ethtool.h>
 #include <linux/inetdevice.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
 #include <linux/platform_device.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include "init.h"
 #include "irq_kern.h"
 #include "irq_user.h"
 #include "mconsole_kern.h"
 #include "net_kern.h"
 #include "net_user.h"
 #define DRIVER_NAME "uml-netdev"
 static DEFINE_SPINLOCK(opened_lock);
 static LIST_HEAD(opened);
 /*
  * The drop_skb is used when we can't allocate an skb.  The
  * packet is read into drop_skb in order to get the data off the
  * connection to the host.
  * It is reallocated whenever a maximum packet size is seen which is
  * larger than any seen before.  update_drop_skb is called from
  * eth_configure when a new interface is added.
  */
 static DEFINE_SPINLOCK(drop_lock);
 static struct sk_buff *drop_skb;
 static int drop_max;
 static int update_drop_skb(int max)
 {
 	struct sk_buff *new;
 	unsigned long flags;
 	int err = 0;
 	spin_lock_irqsave(&drop_lock, flags);
 	if (max <= drop_max)
 		goto out;
 	err = -ENOMEM;
 	new = dev_alloc_skb(max);
 	if (new == NULL)
 		goto out;
 	skb_put(new, max);
 	kfree_skb(drop_skb);
 	drop_skb = new;
 	drop_max = max;
 	err = 0;
 out:
 	spin_unlock_irqrestore(&drop_lock, flags);
 	return err;
 }
 static int uml_net_rx(struct net_device *dev)
 {
 	struct uml_net_private *lp = netdev_priv(dev);
 	int pkt_len;
 	struct sk_buff *skb;
 	/* If we can't allocate memory, try again next round. */
 	skb = dev_alloc_skb(lp->max_packet);
 	if (skb == NULL) {
 		drop_skb->dev = dev;
 		/* Read a packet into drop_skb and don't do anything with it. */
 		(*lp->read)(lp->fd, drop_skb, lp);
 		dev->stats.rx_dropped++;
 		return 0;
 	}
 	skb->dev = dev;
 	skb_put(skb, lp->max_packet);
 	skb_reset_mac_header(skb);
 	pkt_len = (*lp->read)(lp->fd, skb, lp);
 	if (pkt_len > 0) {
 		skb_trim(skb, pkt_len);
 		skb->protocol = (*lp->protocol)(skb);
 		dev->stats.rx_bytes += skb->len;
 		dev->stats.rx_packets++;
 		netif_rx(skb);
 		return pkt_len;
 	}
 	kfree_skb(skb);
 	return pkt_len;
 }
 static void uml_dev_close(struct work_struct *work)
 {
 	struct uml_net_private *lp =
 		container_of(work, struct uml_net_private, work);
 	dev_close(lp->dev);
 }
 static irqreturn_t uml_net_interrupt(int irq, void *dev_id)
 {
 	struct net_device *dev = dev_id;
 	struct uml_net_private *lp = netdev_priv(dev);
 	int err;
 	if (!netif_running(dev))
 		return IRQ_NONE;
 	spin_lock(&lp->lock);
 	while ((err = uml_net_rx(dev)) > 0) ;
 	if (err < 0) {
 		printk(KERN_ERR
 		       "Device '%s' read returned %d, shutting it down\n",
 		       dev->name, err);
 		/* dev_close can't be called in interrupt context, and takes
 		 * again lp->lock.
 		 * And dev_close() can be safely called multiple times on the
 		 * same device, since it tests for (dev->flags & IFF_UP). So
 		 * there's no harm in delaying the device shutdown.
 		 * Furthermore, the workqueue will not re-enqueue an already
 		 * enqueued work item. */
 		schedule_work(&lp->work);
 		goto out;
 	}
 	reactivate_fd(lp->fd, UM_ETH_IRQ);
 out:
 	spin_unlock(&lp->lock);
 	return IRQ_HANDLED;
 }
 static int uml_net_open(struct net_device *dev)
 {
 	struct uml_net_private *lp = netdev_priv(dev);
 	int err;
 	if (lp->fd >= 0) {
 		err = -ENXIO;
 		goto out;
 	}
 	lp->fd = (*lp->open)(&lp->user);
 	if (lp->fd < 0) {
 		err = lp->fd;
 		goto out;
 	}
 	err = um_request_irq(dev->irq, lp->fd, IRQ_READ, uml_net_interrupt,
 			     IRQF_DISABLED | IRQF_SHARED, dev->name, dev);
 	if (err != 0) {
 		printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
 		err = -ENETUNREACH;
 		goto out_close;
 	}
 	lp->tl.data = (unsigned long) &lp->user;
 	netif_start_queue(dev);
 	/* clear buffer - it can happen that the host side of the interface
 	 * is full when we get here.  In this case, new data is never queued,
 	 * SIGIOs never arrive, and the net never works.
 	 */
 	while ((err = uml_net_rx(dev)) > 0) ;
 	spin_lock(&opened_lock);
 	list_add(&lp->list, &opened);
 	spin_unlock(&opened_lock);
 	return 0;
 out_close:
 	if (lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
 	lp->fd = -1;
 out:
 	return err;
 }
 static int uml_net_close(struct net_device *dev)
 {
 	struct uml_net_private *lp = netdev_priv(dev);
 	netif_stop_queue(dev);
 	free_irq(dev->irq, dev);
 	if (lp->close != NULL)
 		(*lp->close)(lp->fd, &lp->user);
 	lp->fd = -1;
 	spin_lock(&opened_lock);
 	list_del(&lp->list);
 	spin_unlock(&opened_lock);
 	return 0;
 }
 static int uml_net_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
 	struct uml_net_private *lp = netdev_priv(dev);
 	unsigned long flags;
 	int len;
 	netif_stop_queue(dev);
 	spin_lock_irqsave(&lp->lock, flags);
 	len = (*lp->write)(lp->fd, skb, lp);
 	if (len == skb->len) {
 		dev->stats.tx_packets++;
 		dev->stats.tx_bytes += skb->len;
 		dev->trans_start = jiffies;
 		netif_start_queue(dev);
 		/* this is normally done in the interrupt when tx finishes */
 		netif_wake_queue(dev);
 	}
 	else if (len == 0) {
 		netif_start_queue(dev);
 		dev->stats.tx_dropped++;
 	}
 	else {
 		netif_start_queue(dev);
 		printk(KERN_ERR "uml_net_start_xmit: failed(%d)\n", len);
 	}
 	spin_unlock_irqrestore(&lp->lock, flags);
 	dev_kfree_skb(skb);
 	return NETDEV_TX_OK;
 }
 static void uml_net_set_multicast_list(struct net_device *dev)
 {
 	return;
 }
 static void uml_net_tx_timeout(struct net_device *dev)
 {
 	dev->trans_start = jiffies;
 	netif_wake_queue(dev);
 }
-static int uml_net_set_mac(struct net_device *dev, void *addr)
-{
-	struct uml_net_private *lp = netdev_priv(dev);
-	struct sockaddr *hwaddr = addr;
-	spin_lock_irq(&lp->lock);
-	eth_mac_addr(dev, hwaddr->sa_data);
-	spin_unlock_irq(&lp->lock);
-	return 0;
-}
 static int uml_net_change_mtu(struct net_device *dev, int new_mtu)
 {
 	dev->mtu = new_mtu;
 	return 0;
 }
 static void uml_net_get_drvinfo(struct net_device *dev,
 				struct ethtool_drvinfo *info)
 {
 	strcpy(info->driver, DRIVER_NAME);
 	strcpy(info->version, "42");
 }
 static const struct ethtool_ops uml_net_ethtool_ops = {
 	.get_drvinfo	= uml_net_get_drvinfo,
 	.get_link	= ethtool_op_get_link,
 };
 static void uml_net_user_timer_expire(unsigned long _conn)
 {
 #ifdef undef
 	struct connection *conn = (struct connection *)_conn;
 	dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
 	do_connect(conn);
 #endif
 }
 static void setup_etheraddr(char *str, unsigned char *addr, char *name)
 {
 	char *end;
 	int i;
 	if (str == NULL)
 		goto random;
 	for (i = 0; i < 6; i++) {
 		addr[i] = simple_strtoul(str, &end, 16);
 		if ((end == str) ||
 		   ((*end != ':') && (*end != ',') && (*end != '\0'))) {
 			printk(KERN_ERR
 			       "setup_etheraddr: failed to parse '%s' "
 			       "as an ethernet address\n", str);
 			goto random;
 		}
 		str = end + 1;
 	}
 	if (is_multicast_ether_addr(addr)) {
 		printk(KERN_ERR
 		       "Attempt to assign a multicast ethernet address to a "
 		       "device disallowed\n");
 		goto random;
 	}
 	if (!is_valid_ether_addr(addr)) {
 		printk(KERN_ERR
 		       "Attempt to assign an invalid ethernet address to a "
 		       "device disallowed\n");
 		goto random;
 	}
 	if (!is_local_ether_addr(addr)) {
 		printk(KERN_WARNING
 		       "Warning: Assigning a globally valid ethernet "
 		       "address to a device\n");
 		printk(KERN_WARNING "You should set the 2nd rightmost bit in "
 		       "the first byte of the MAC,\n");
 		printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
 		       addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
 		       addr[5]);
 	}
 	return;
 random:
 	printk(KERN_INFO
 	       "Choosing a random ethernet address for device %s\n", name);
 	random_ether_addr(addr);
 }
 static DEFINE_SPINLOCK(devices_lock);
 static LIST_HEAD(devices);
 static struct platform_driver uml_net_driver = {
 	.driver = {
 		.name  = DRIVER_NAME,
 	},
 };
 static void net_device_release(struct device *dev)
 {
 	struct uml_net *device = dev_get_drvdata(dev);
 	struct net_device *netdev = device->dev;
 	struct uml_net_private *lp = netdev_priv(netdev);
 	if (lp->remove != NULL)
 		(*lp->remove)(&lp->user);
 	list_del(&device->list);
 	kfree(device);
 	free_netdev(netdev);
 }
 static const struct net_device_ops uml_netdev_ops = {
 	.ndo_open 		= uml_net_open,
 	.ndo_stop 		= uml_net_close,
 	.ndo_start_xmit 	= uml_net_start_xmit,
 	.ndo_set_multicast_list = uml_net_set_multicast_list,
 	.ndo_tx_timeout 	= uml_net_tx_timeout,
-	.ndo_set_mac_address	= uml_net_set_mac,
+	.ndo_set_mac_address	= eth_mac_addr,
 	.ndo_change_mtu 	= uml_net_change_mtu,
 	.ndo_validate_addr	= eth_validate_addr,
 };
 /*
  * Ensures that platform_driver_register is called only once by
  * eth_configure.  Will be set in an initcall.
  */
 static int driver_registered;
 static void eth_configure(int n, void *init, char *mac,
 			  struct transport *transport)
 {
 	struct uml_net *device;
 	struct net_device *dev;
 	struct uml_net_private *lp;
 	int err, size;
 	size = transport->private_size + sizeof(struct uml_net_private);
 	device = kzalloc(sizeof(*device), GFP_KERNEL);
 	if (device == NULL) {
 		printk(KERN_ERR "eth_configure failed to allocate struct "
 		       "uml_net\n");
 		return;
 	}
 	dev = alloc_etherdev(size);
 	if (dev == NULL) {
 		printk(KERN_ERR "eth_configure: failed to allocate struct "
 		       "net_device for eth%d\n", n);
 		goto out_free_device;
 	}
 	INIT_LIST_HEAD(&device->list);
 	device->index = n;
 	/* If this name ends up conflicting with an existing registered
 	 * netdevice, that is OK, register_netdev{,ice}() will notice this
 	 * and fail.
 	 */
 	snprintf(dev->name, sizeof(dev->name), "eth%d", n);
 	setup_etheraddr(mac, device->mac, dev->name);
 	printk(KERN_INFO "Netdevice %d (%pM) : ", n, device->mac);
 	lp = netdev_priv(dev);
 	/* This points to the transport private data. It's still clear, but we
 	 * must memset it to 0 *now*. Let's help the drivers. */
 	memset(lp, 0, size);
 	INIT_WORK(&lp->work, uml_dev_close);
 	/* sysfs register */
 	if (!driver_registered) {
 		platform_driver_register(&uml_net_driver);
 		driver_registered = 1;
 	}
 	device->pdev.id = n;
 	device->pdev.name = DRIVER_NAME;
 	device->pdev.dev.release = net_device_release;
 	dev_set_drvdata(&device->pdev.dev, device);
 	if (platform_device_register(&device->pdev))
 		goto out_free_netdev;
 	SET_NETDEV_DEV(dev,&device->pdev.dev);
 	device->dev = dev;
 	/*
 	 * These just fill in a data structure, so there's no failure
 	 * to be worried about.
 	 */
 	(*transport->kern->init)(dev, init);
 	*lp = ((struct uml_net_private)
 		{ .list  		= LIST_HEAD_INIT(lp->list),
 		  .dev 			= dev,
 		  .fd 			= -1,
 		  .mac 			= { 0xfe, 0xfd, 0x0, 0x0, 0x0, 0x0},
 		  .max_packet		= transport->user->max_packet,
 		  .protocol 		= transport->kern->protocol,
 		  .open 		= transport->user->open,
 		  .close 		= transport->user->close,
 		  .remove 		= transport->user->remove,
 		  .read 		= transport->kern->read,
 		  .write 		= transport->kern->write,
 		  .add_address 		= transport->user->add_address,
 		  .delete_address  	= transport->user->delete_address });
 	init_timer(&lp->tl);
 	spin_lock_init(&lp->lock);
 	lp->tl.function = uml_net_user_timer_expire;
 	memcpy(lp->mac, device->mac, sizeof(lp->mac));
 	if ((transport->user->init != NULL) &&
 	    ((*transport->user->init)(&lp->user, dev) != 0))
 		goto out_unregister;
-	eth_mac_addr(dev, device->mac);
+	/* don't use eth_mac_addr, it will not work here */
+	memcpy(dev->dev_addr, device->mac, ETH_ALEN);
 	dev->mtu = transport->user->mtu;
 	dev->netdev_ops = &uml_netdev_ops;
 	dev->ethtool_ops = &uml_net_ethtool_ops;
 	dev->watchdog_timeo = (HZ >> 1);
 	dev->irq = UM_ETH_IRQ;
 	err = update_drop_skb(lp->max_packet);
 	if (err)
 		goto out_undo_user_init;
 	rtnl_lock();
 	err = register_netdevice(dev);
 	rtnl_unlock();
 	if (err)
 		goto out_undo_user_init;
 	spin_lock(&devices_lock);
 	list_add(&device->list, &devices);
 	spin_unlock(&devices_lock);
 	return;
 out_undo_user_init:
 	if (transport->user->remove != NULL)
 		(*transport->user->remove)(&lp->user);
 out_unregister:
 	platform_device_unregister(&device->pdev);
 	return; /* platform_device_unregister frees dev and device */
 out_free_netdev:
 	free_netdev(dev);
 out_free_device:
 	kfree(device);
 }
 static struct uml_net *find_device(int n)
 {
 	struct uml_net *device;
 	struct list_head *ele;
 	spin_lock(&devices_lock);
 	list_for_each(ele, &devices) {
 		device = list_entry(ele, struct uml_net, list);
 		if (device->index == n)
 			goto out;
 	}
 	device = NULL;
  out:
 	spin_unlock(&devices_lock);
 	return device;
 }
 static int eth_parse(char *str, int *index_out, char **str_out,
 		     char **error_out)
 {
 	char *end;
 	int n, err = -EINVAL;
 	n = simple_strtoul(str, &end, 0);
 	if (end == str) {
 		*error_out = "Bad device number";
 		return err;
 	}
 	str = end;
 	if (*str != '=') {
 		*error_out = "Expected '=' after device number";
 		return err;
 	}
 	str++;
 	if (find_device(n)) {
 		*error_out = "Device already configured";
 		return err;
 	}
 	*index_out = n;
 	*str_out = str;
 	return 0;
 }
 struct eth_init {
 	struct list_head list;
 	char *init;
 	int index;
 };
 static DEFINE_SPINLOCK(transports_lock);
 static LIST_HEAD(transports);
 /* Filled in during early boot */
 static LIST_HEAD(eth_cmd_line);
 static int check_transport(struct transport *transport, char *eth, int n,
 			   void **init_out, char **mac_out)
 {
 	int len;
 	len = strlen(transport->name);
 	if (strncmp(eth, transport->name, len))
 		return 0;
 	eth += len;
 	if (*eth == ',')
 		eth++;
 	else if (*eth != '\0')
 		return 0;
 	*init_out = kmalloc(transport->setup_size, GFP_KERNEL);
 	if (*init_out == NULL)
 		return 1;
 	if (!transport->setup(eth, mac_out, *init_out)) {
 		kfree(*init_out);
 		*init_out = NULL;
 	}
 	return 1;
 }
 void register_transport(struct transport *new)
 {
 	struct list_head *ele, *next;
 	struct eth_init *eth;
 	void *init;
 	char *mac = NULL;
 	int match;
 	spin_lock(&transports_lock);
 	BUG_ON(!list_empty(&new->list));
 	list_add(&new->list, &transports);
 	spin_unlock(&transports_lock);
 	list_for_each_safe(ele, next, &eth_cmd_line) {
 		eth = list_entry(ele, struct eth_init, list);
 		match = check_transport(new, eth->init, eth->index, &init,
 					&mac);
 		if (!match)
 			continue;
 		else if (init != NULL) {
 			eth_configure(eth->index, init, mac, new);
 			kfree(init);
 		}
 		list_del(&eth->list);
 	}
 }
 static int eth_setup_common(char *str, int index)
 {
 	struct list_head *ele;
 	struct transport *transport;
 	void *init;
 	char *mac = NULL;
 	int found = 0;
 	spin_lock(&transports_lock);
 	list_for_each(ele, &transports) {
 		transport = list_entry(ele, struct transport, list);
 	        if (!check_transport(transport, str, index, &init, &mac))
 			continue;
 		if (init != NULL) {
 			eth_configure(index, init, mac, transport);
 			kfree(init);
 		}
 		found = 1;
 		break;
 	}
 	spin_unlock(&transports_lock);
 	return found;
 }
 static int __init eth_setup(char *str)
 {
 	struct eth_init *new;
 	char *error;
 	int n, err;
 	err = eth_parse(str, &n, &str, &error);
 	if (err) {
 		printk(KERN_ERR "eth_setup - Couldn't parse '%s' : %s\n",
 		       str, error);
 		return 1;
 	}
 	new = alloc_bootmem(sizeof(*new));
 	if (new == NULL) {
 		printk(KERN_ERR "eth_init : alloc_bootmem failed\n");
 		return 1;
 	}
 	INIT_LIST_HEAD(&new->list);
 	new->index = n;
 	new->init = str;
 	list_add_tail(&new->list, &eth_cmd_line);
 	return 1;
 }
 __setup("eth", eth_setup);
 __uml_help(eth_setup,
 "eth[0-9]+=<transport>,<options>\n"
 "    Configure a network device.\n\n"
 );
 static int net_config(char *str, char **error_out)
 {
 	int n, err;
 	err = eth_parse(str, &n, &str, error_out);
 	if (err)
 		return err;
 	/* This string is broken up and the pieces used by the underlying
 	 * driver.  So, it is freed only if eth_setup_common fails.
 	 */
 	str = kstrdup(str, GFP_KERNEL);
 	if (str == NULL) {
 	        *error_out = "net_config failed to strdup string";
 		return -ENOMEM;
 	}
 	err = !eth_setup_common(str, n);
 	if (err)
 		kfree(str);
 	return err;
 }
 static int net_id(char **str, int *start_out, int *end_out)
 {
 	char *end;
 	int n;
 	n = simple_strtoul(*str, &end, 0);
 	if ((*end != '\0') || (end == *str))
 		return -1;
 	*start_out = n;
 	*end_out = n;
 	*str = end;
 	return n;
 }
 static int net_remove(int n, char **error_out)
 {
 	struct uml_net *device;
 	struct net_device *dev;
 	struct uml_net_private *lp;
 	device = find_device(n);
 	if (device == NULL)
 		return -ENODEV;
 	dev = device->dev;
 	lp = netdev_priv(dev);
 	if (lp->fd > 0)
 		return -EBUSY;
 	unregister_netdev(dev);
 	platform_device_unregister(&device->pdev);
 	return 0;
 }
 static struct mc_device net_mc = {
 	.list		= LIST_HEAD_INIT(net_mc.list),
 	.name		= "eth",
 	.config		= net_config,
 	.get_config	= NULL,
 	.id		= net_id,
 	.remove		= net_remove,
 };
 #ifdef CONFIG_INET
 static int uml_inetaddr_event(struct notifier_block *this, unsigned long event,
 			      void *ptr)
 {
 	struct in_ifaddr *ifa = ptr;
 	struct net_device *dev = ifa->ifa_dev->dev;
 	struct uml_net_private *lp;
 	void (*proc)(unsigned char *, unsigned char *, void *);
 	unsigned char addr_buf[4], netmask_buf[4];
 	if (dev->netdev_ops->ndo_open != uml_net_open)
 		return NOTIFY_DONE;
 	lp = netdev_priv(dev);
 	proc = NULL;
 	switch (event) {
 	case NETDEV_UP:
 		proc = lp->add_address;
 		break;
 	case NETDEV_DOWN:
 		proc = lp->delete_address;
 		break;
 	}
 	if (proc != NULL) {
 		memcpy(addr_buf, &ifa->ifa_address, sizeof(addr_buf));
 		memcpy(netmask_buf, &ifa->ifa_mask, sizeof(netmask_buf));
 		(*proc)(addr_buf, netmask_buf, &lp->user);
 	}
 	return NOTIFY_DONE;
 }
 /* uml_net_init shouldn't be called twice on two CPUs at the same time */
 static struct notifier_block uml_inetaddr_notifier = {
 	.notifier_call		= uml_inetaddr_event,
 };
 static void inet_register(void)
 {
 	struct list_head *ele;
 	struct uml_net_private *lp;
 	struct in_device *ip;
 	struct in_ifaddr *in;
 	register_inetaddr_notifier(&uml_inetaddr_notifier);
 	/* Devices may have been opened already, so the uml_inetaddr_notifier
 	 * didn't get a chance to run for them.  This fakes it so that
 	 * addresses which have already been set up get handled properly.
 	 */
 	spin_lock(&opened_lock);
 	list_for_each(ele, &opened) {
 		lp = list_entry(ele, struct uml_net_private, list);
 		ip = lp->dev->ip_ptr;
 		if (ip == NULL)
 			continue;
 		in = ip->ifa_list;
 		while (in != NULL) {
 			uml_inetaddr_event(NULL, NETDEV_UP, in);
 			in = in->ifa_next;
 		}
 	}
 	spin_unlock(&opened_lock);
 }
 #else
 static inline void inet_register(void)
 {
 }
 #endif
 static int uml_net_init(void)
 {
 	mconsole_register_dev(&net_mc);
 	inet_register();
 	return 0;
 }
 __initcall(uml_net_init);
 static void close_devices(void)
 {
 	struct list_head *ele;
 	struct uml_net_private *lp;
 	spin_lock(&opened_lock);
 	list_for_each(ele, &opened) {
 		lp = list_entry(ele, struct uml_net_private, list);
 		free_irq(lp->dev->irq, lp->dev);
 		if ((lp->close != NULL) && (lp->fd >= 0))
 			(*lp->close)(lp->fd, &lp->user);
 		if (lp->remove != NULL)
 			(*lp->remove)(&lp->user);
 	}
 	spin_unlock(&opened_lock);
 }
 __uml_exitcall(close_devices);
 void iter_addresses(void *d, void (*cb)(unsigned char *, unsigned char *,
 					void *),
 		    void *arg)
 {
 	struct net_device *dev = d;
 	struct in_device *ip = dev->ip_ptr;
 	struct in_ifaddr *in;
 	unsigned char address[4], netmask[4];
 	if (ip == NULL) return;
 	in = ip->ifa_list;
 	while (in != NULL) {
 		memcpy(address, &in->ifa_address, sizeof(address));
 		memcpy(netmask, &in->ifa_mask, sizeof(netmask));
 		(*cb)(address, netmask, arg);
 		in = in->ifa_next;
 	}
 }
 int dev_netmask(void *d, void *m)
 {
 	struct net_device *dev = d;
 	struct in_device *ip = dev->ip_ptr;
 	struct in_ifaddr *in;
 	__be32 *mask_out = m;
 	if (ip == NULL)
 		return 1;
 	in = ip->ifa_list;
 	if (in == NULL)
 		return 1;
 	*mask_out = in->ifa_mask;
 	return 0;
 }
 void *get_output_buffer(int *len_out)
 {
 	void *ret;
 	ret = (void *) __get_free_pages(GFP_KERNEL, 0);
 	if (ret) *len_out = PAGE_SIZE;
 	else *len_out = 0;
 	return ret;
 }
 void free_output_buffer(void *buffer)
 {
 	free_pages((unsigned long) buffer, 0);
 }
 int tap_setup_common(char *str, char *type, char **dev_name, char **mac_out,
 		     char **gate_addr)
 {
 	char *remain;
 	remain = split_if_spec(str, dev_name, mac_out, gate_addr, NULL);
 	if (remain != NULL) {
 		printk(KERN_ERR "tap_setup_common - Extra garbage on "
 		       "specification : '%s'\n", remain);
 		return 1;
 	}
 	return 0;
 }
 unsigned short eth_protocol(struct sk_buff *skb)
 {
 	return eth_type_trans(skb, skb->dev);
 }

drivers/net/wireless/iwlwifi/iwl-agn-lib.c

Diff comments View file @ 4a73a43

drivers/net/wireless/iwlwifi/iwl3945-base.c

Diff comments View file @ 4a73a43

net/8021q/vlan_core.c

Diff comments View file @ 4a73a43

 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/if_vlan.h>
 #include <linux/netpoll.h>
 #include "vlan.h"
 /* VLAN rx hw acceleration helper.  This acts like netif_{rx,receive_skb}(). */
 int __vlan_hwaccel_rx(struct sk_buff *skb, struct vlan_group *grp,
 		      u16 vlan_tci, int polling)
 {
 	struct net_device *vlan_dev;
 	u16 vlan_id;
 	if (netpoll_rx(skb))
 		return NET_RX_DROP;
 	if (skb_bond_should_drop(skb, ACCESS_ONCE(skb->dev->master)))
 		skb->deliver_no_wcard = 1;
 	skb->skb_iif = skb->dev->ifindex;
 	__vlan_hwaccel_put_tag(skb, vlan_tci);
 	vlan_id = vlan_tci & VLAN_VID_MASK;
 	vlan_dev = vlan_group_get_device(grp, vlan_id);
 	if (vlan_dev)
 		skb->dev = vlan_dev;
-	else if (vlan_id)
+	else if (vlan_id) {
-		goto drop;
+		if (!(skb->dev->flags & IFF_PROMISC))
+			goto drop;
+		skb->pkt_type = PACKET_OTHERHOST;
+	}
 	return (polling ? netif_receive_skb(skb) : netif_rx(skb));
 drop:
 	dev_kfree_skb_any(skb);
 	return NET_RX_DROP;
 }
 EXPORT_SYMBOL(__vlan_hwaccel_rx);
 int vlan_hwaccel_do_receive(struct sk_buff *skb)
 {
 	struct net_device *dev = skb->dev;
 	struct vlan_rx_stats     *rx_stats;
 	skb->dev = vlan_dev_info(dev)->real_dev;
 	netif_nit_deliver(skb);
 	skb->dev = dev;
 	skb->priority = vlan_get_ingress_priority(dev, skb->vlan_tci);
 	skb->vlan_tci = 0;
 	rx_stats = this_cpu_ptr(vlan_dev_info(dev)->vlan_rx_stats);
 	u64_stats_update_begin(&rx_stats->syncp);
 	rx_stats->rx_packets++;
 	rx_stats->rx_bytes += skb->len;
 	switch (skb->pkt_type) {
 	case PACKET_BROADCAST:
 		break;
 	case PACKET_MULTICAST:
 		rx_stats->rx_multicast++;
 		break;
 	case PACKET_OTHERHOST:
 		/* Our lower layer thinks this is not local, let's make sure.
 		 * This allows the VLAN to have a different MAC than the
 		 * underlying device, and still route correctly. */
 		if (!compare_ether_addr(eth_hdr(skb)->h_dest,
 					dev->dev_addr))
 			skb->pkt_type = PACKET_HOST;
 		break;
 	}
 	u64_stats_update_end(&rx_stats->syncp);
 	return 0;
 }
 struct net_device *vlan_dev_real_dev(const struct net_device *dev)
 {
 	return vlan_dev_info(dev)->real_dev;
 }
 EXPORT_SYMBOL(vlan_dev_real_dev);
 u16 vlan_dev_vlan_id(const struct net_device *dev)
 {
 	return vlan_dev_info(dev)->vlan_id;
 }
 EXPORT_SYMBOL(vlan_dev_vlan_id);
 static gro_result_t
 vlan_gro_common(struct napi_struct *napi, struct vlan_group *grp,
 		unsigned int vlan_tci, struct sk_buff *skb)
 {
 	struct sk_buff *p;
 	struct net_device *vlan_dev;
 	u16 vlan_id;
 	if (skb_bond_should_drop(skb, ACCESS_ONCE(skb->dev->master)))
 		skb->deliver_no_wcard = 1;
 	skb->skb_iif = skb->dev->ifindex;
 	__vlan_hwaccel_put_tag(skb, vlan_tci);
 	vlan_id = vlan_tci & VLAN_VID_MASK;
 	vlan_dev = vlan_group_get_device(grp, vlan_id);
 	if (vlan_dev)
 		skb->dev = vlan_dev;
-	else if (vlan_id)
+	else if (vlan_id) {
-		goto drop;
+		if (!(skb->dev->flags & IFF_PROMISC))
+			goto drop;
+		skb->pkt_type = PACKET_OTHERHOST;
+	}
 	for (p = napi->gro_list; p; p = p->next) {
 		NAPI_GRO_CB(p)->same_flow =
 			p->dev == skb->dev && !compare_ether_header(
 				skb_mac_header(p), skb_gro_mac_header(skb));
 		NAPI_GRO_CB(p)->flush = 0;
 	}
 	return dev_gro_receive(napi, skb);
 drop:
 	return GRO_DROP;
 }
 gro_result_t vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
 			      unsigned int vlan_tci, struct sk_buff *skb)
 {
 	if (netpoll_rx_on(skb))
 		return vlan_hwaccel_receive_skb(skb, grp, vlan_tci)
 			? GRO_DROP : GRO_NORMAL;
 	skb_gro_reset_offset(skb);
 	return napi_skb_finish(vlan_gro_common(napi, grp, vlan_tci, skb), skb);
 }
 EXPORT_SYMBOL(vlan_gro_receive);
 gro_result_t vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
 			    unsigned int vlan_tci)
 {
 	struct sk_buff *skb = napi_frags_skb(napi);
 	if (!skb)
 		return GRO_DROP;
 	if (netpoll_rx_on(skb)) {
 		skb->protocol = eth_type_trans(skb, skb->dev);
 		return vlan_hwaccel_receive_skb(skb, grp, vlan_tci)
 			? GRO_DROP : GRO_NORMAL;
 	}
 	return napi_frags_finish(napi, skb,
 				 vlan_gro_common(napi, grp, vlan_tci, skb));
 }
 EXPORT_SYMBOL(vlan_gro_frags);

net/ipv4/Kconfig

Diff comments View file @ 4a73a43

 #
 # IP configuration
 #
 config IP_MULTICAST
 	bool "IP: multicasting"
 	help
 	  This is code for addressing several networked computers at once,
 	  enlarging your kernel by about 2 KB. You need multicasting if you
 	  intend to participate in the MBONE, a high bandwidth network on top
 	  of the Internet which carries audio and video broadcasts. More
 	  information about the MBONE is on the WWW at
 	  <http://www.savetz.com/mbone/>. Information about the multicast
 	  capabilities of the various network cards is contained in
 	  <file:Documentation/networking/multicast.txt>. For most people, it's
 	  safe to say N.
 config IP_ADVANCED_ROUTER
 	bool "IP: advanced router"
 	---help---
 	  If you intend to run your Linux box mostly as a router, i.e. as a
 	  computer that forwards and redistributes network packets, say Y; you
 	  will then be presented with several options that allow more precise
 	  control about the routing process.
 	  The answer to this question won't directly affect the kernel:
 	  answering N will just cause the configurator to skip all the
 	  questions about advanced routing.
 	  Note that your box can only act as a router if you enable IP
 	  forwarding in your kernel; you can do that by saying Y to "/proc
 	  file system support" and "Sysctl support" below and executing the
 	  line
 	  echo "1" > /proc/sys/net/ipv4/ip_forward
 	  at boot time after the /proc file system has been mounted.
 	  If you turn on IP forwarding, you should consider the rp_filter, which
 	  automatically rejects incoming packets if the routing table entry
 	  for their source address doesn't match the network interface they're
 	  arriving on. This has security advantages because it prevents the
 	  so-called IP spoofing, however it can pose problems if you use
 	  asymmetric routing (packets from you to a host take a different path
 	  than packets from that host to you) or if you operate a non-routing
 	  host which has several IP addresses on different interfaces. To turn
 	  rp_filter on use:
 	  echo 1 > /proc/sys/net/ipv4/conf/<device>/rp_filter
 	   or
 	  echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter
 	  Note that some distributions enable it in startup scripts.
 	  For details about rp_filter strict and loose mode read
 	  <file:Documentation/networking/ip-sysctl.txt>.
 	  If unsure, say N here.
 choice
 	prompt "Choose IP: FIB lookup algorithm (choose FIB_HASH if unsure)"
 	depends on IP_ADVANCED_ROUTER
 	default ASK_IP_FIB_HASH
 config ASK_IP_FIB_HASH
 	bool "FIB_HASH"
 	---help---
 	  Current FIB is very proven and good enough for most users.
 config IP_FIB_TRIE
 	bool "FIB_TRIE"
 	---help---
 	  Use new experimental LC-trie as FIB lookup algorithm.
 	  This improves lookup performance if you have a large
 	  number of routes.
 	  LC-trie is a longest matching prefix lookup algorithm which
 	  performs better than FIB_HASH for large routing tables.
 	  But, it consumes more memory and is more complex.
 	  LC-trie is described in:
 	  IP-address lookup using LC-tries. Stefan Nilsson and Gunnar Karlsson
 	  IEEE Journal on Selected Areas in Communications, 17(6):1083-1092,
 	  June 1999
 	  An experimental study of compression methods for dynamic tries
 	  Stefan Nilsson and Matti Tikkanen. Algorithmica, 33(1):19-33, 2002.
 	  http://www.nada.kth.se/~snilsson/public/papers/dyntrie2/
 endchoice
 config IP_FIB_HASH
 	def_bool ASK_IP_FIB_HASH || !IP_ADVANCED_ROUTER
 config IP_FIB_TRIE_STATS
 	bool "FIB TRIE statistics"
 	depends on IP_FIB_TRIE
 	---help---
 	  Keep track of statistics on structure of FIB TRIE table.
 	  Useful for testing and measuring TRIE performance.
 config IP_MULTIPLE_TABLES
 	bool "IP: policy routing"
 	depends on IP_ADVANCED_ROUTER
 	select FIB_RULES
 	---help---
 	  Normally, a router decides what to do with a received packet based
 	  solely on the packet's final destination address. If you say Y here,
 	  the Linux router will also be able to take the packet's source
 	  address into account. Furthermore, the TOS (Type-Of-Service) field
 	  of the packet can be used for routing decisions as well.
 	  If you are interested in this, please see the preliminary
 	  documentation at <http://www.compendium.com.ar/policy-routing.txt>
 	  and <ftp://post.tepkom.ru/pub/vol2/Linux/docs/advanced-routing.tex>.
 	  You will need supporting software from
 	  <ftp://ftp.tux.org/pub/net/ip-routing/>.
 	  If unsure, say N.
 config IP_ROUTE_MULTIPATH
 	bool "IP: equal cost multipath"
 	depends on IP_ADVANCED_ROUTER
 	help
 	  Normally, the routing tables specify a single action to be taken in
 	  a deterministic manner for a given packet. If you say Y here
 	  however, it becomes possible to attach several actions to a packet
 	  pattern, in effect specifying several alternative paths to travel
 	  for those packets. The router considers all these paths to be of
 	  equal "cost" and chooses one of them in a non-deterministic fashion
 	  if a matching packet arrives.
 config IP_ROUTE_VERBOSE
 	bool "IP: verbose route monitoring"
 	depends on IP_ADVANCED_ROUTER
 	help
 	  If you say Y here, which is recommended, then the kernel will print
 	  verbose messages regarding the routing, for example warnings about
 	  received packets which look strange and could be evidence of an
 	  attack or a misconfigured system somewhere. The information is
 	  handled by the klogd daemon which is responsible for kernel messages
 	  ("man klogd").
 config IP_PNP
 	bool "IP: kernel level autoconfiguration"
 	help
 	  This enables automatic configuration of IP addresses of devices and
 	  of the routing table during kernel boot, based on either information
 	  supplied on the kernel command line or by BOOTP or RARP protocols.
 	  You need to say Y only for diskless machines requiring network
 	  access to boot (in which case you want to say Y to "Root file system
 	  on NFS" as well), because all other machines configure the network
 	  in their startup scripts.
 config IP_PNP_DHCP
 	bool "IP: DHCP support"
 	depends on IP_PNP
 	---help---
 	  If you want your Linux box to mount its whole root file system (the
 	  one containing the directory /) from some other computer over the
 	  net via NFS and you want the IP address of your computer to be
 	  discovered automatically at boot time using the DHCP protocol (a
 	  special protocol designed for doing this job), say Y here. In case
 	  the boot ROM of your network card was designed for booting Linux and
 	  does DHCP itself, providing all necessary information on the kernel
 	  command line, you can say N here.
 	  If unsure, say Y. Note that if you want to use DHCP, a DHCP server
 	  must be operating on your network.  Read
 	  <file:Documentation/filesystems/nfs/nfsroot.txt> for details.
 config IP_PNP_BOOTP
 	bool "IP: BOOTP support"
 	depends on IP_PNP
 	---help---
 	  If you want your Linux box to mount its whole root file system (the
 	  one containing the directory /) from some other computer over the
 	  net via NFS and you want the IP address of your computer to be
 	  discovered automatically at boot time using the BOOTP protocol (a
 	  special protocol designed for doing this job), say Y here. In case
 	  the boot ROM of your network card was designed for booting Linux and
 	  does BOOTP itself, providing all necessary information on the kernel
 	  command line, you can say N here. If unsure, say Y. Note that if you
 	  want to use BOOTP, a BOOTP server must be operating on your network.
 	  Read <file:Documentation/filesystems/nfs/nfsroot.txt> for details.
 config IP_PNP_RARP
 	bool "IP: RARP support"
 	depends on IP_PNP
 	help
 	  If you want your Linux box to mount its whole root file system (the
 	  one containing the directory /) from some other computer over the
 	  net via NFS and you want the IP address of your computer to be
 	  discovered automatically at boot time using the RARP protocol (an
 	  older protocol which is being obsoleted by BOOTP and DHCP), say Y
 	  here. Note that if you want to use RARP, a RARP server must be
 	  operating on your network. Read
 	  <file:Documentation/filesystems/nfs/nfsroot.txt> for details.
 # not yet ready..
 #   bool '    IP: ARP support' CONFIG_IP_PNP_ARP
 config NET_IPIP
 	tristate "IP: tunneling"
 	select INET_TUNNEL
 	---help---
 	  Tunneling means encapsulating data of one protocol type within
 	  another protocol and sending it over a channel that understands the
 	  encapsulating protocol. This particular tunneling driver implements
 	  encapsulation of IP within IP, which sounds kind of pointless, but
 	  can be useful if you want to make your (or some other) machine
 	  appear on a different network than it physically is, or to use
 	  mobile-IP facilities (allowing laptops to seamlessly move between
 	  networks without changing their IP addresses).
 	  Saying Y to this option will produce two modules ( = code which can
 	  be inserted in and removed from the running kernel whenever you
 	  want). Most people won't need this and can say N.
 config NET_IPGRE
 	tristate "IP: GRE tunnels over IP"
+	depends on IPV6 || IPV6=n
 	help
 	  Tunneling means encapsulating data of one protocol type within
 	  another protocol and sending it over a channel that understands the
 	  encapsulating protocol. This particular tunneling driver implements
 	  GRE (Generic Routing Encapsulation) and at this time allows
 	  encapsulating of IPv4 or IPv6 over existing IPv4 infrastructure.
 	  This driver is useful if the other endpoint is a Cisco router: Cisco
 	  likes GRE much better than the other Linux tunneling driver ("IP
 	  tunneling" above). In addition, GRE allows multicast redistribution
 	  through the tunnel.
 config NET_IPGRE_BROADCAST
 	bool "IP: broadcast GRE over IP"
 	depends on IP_MULTICAST && NET_IPGRE
 	help
 	  One application of GRE/IP is to construct a broadcast WAN (Wide Area
 	  Network), which looks like a normal Ethernet LAN (Local Area
 	  Network), but can be distributed all over the Internet. If you want
 	  to do that, say Y here and to "IP multicast routing" below.
 config IP_MROUTE
 	bool "IP: multicast routing"
 	depends on IP_MULTICAST
 	help
 	  This is used if you want your machine to act as a router for IP
 	  packets that have several destination addresses. It is needed on the
 	  MBONE, a high bandwidth network on top of the Internet which carries
 	  audio and video broadcasts. In order to do that, you would most
 	  likely run the program mrouted. Information about the multicast
 	  capabilities of the various network cards is contained in
 	  <file:Documentation/networking/multicast.txt>. If you haven't heard
 	  about it, you don't need it.
 config IP_MROUTE_MULTIPLE_TABLES
 	bool "IP: multicast policy routing"
 	depends on IP_MROUTE && IP_ADVANCED_ROUTER
 	select FIB_RULES
 	help
 	  Normally, a multicast router runs a userspace daemon and decides
 	  what to do with a multicast packet based on the source and
 	  destination addresses. If you say Y here, the multicast router
 	  will also be able to take interfaces and packet marks into
 	  account and run multiple instances of userspace daemons
 	  simultaneously, each one handling a single table.
 	  If unsure, say N.
 config IP_PIMSM_V1
 	bool "IP: PIM-SM version 1 support"
 	depends on IP_MROUTE
 	help
 	  Kernel side support for Sparse Mode PIM (Protocol Independent
 	  Multicast) version 1. This multicast routing protocol is used widely
 	  because Cisco supports it. You need special software to use it
 	  (pimd-v1). Please see <http://netweb.usc.edu/pim/> for more
 	  information about PIM.
 	  Say Y if you want to use PIM-SM v1. Note that you can say N here if
 	  you just want to use Dense Mode PIM.
 config IP_PIMSM_V2
 	bool "IP: PIM-SM version 2 support"
 	depends on IP_MROUTE
 	help
 	  Kernel side support for Sparse Mode PIM version 2. In order to use
 	  this, you need an experimental routing daemon supporting it (pimd or
 	  gated-5). This routing protocol is not used widely, so say N unless
 	  you want to play with it.
 config ARPD
 	bool "IP: ARP daemon support"
 	---help---
 	  The kernel maintains an internal cache which maps IP addresses to
 	  hardware addresses on the local network, so that Ethernet/Token Ring/
 	  etc. frames are sent to the proper address on the physical networking
 	  layer. Normally, kernel uses the ARP protocol to resolve these
 	  mappings.
 	  Saying Y here adds support to have an user space daemon to do this
 	  resolution instead. This is useful for implementing an alternate
 	  address resolution protocol (e.g. NHRP on mGRE tunnels) and also for
 	  testing purposes.
 	  If unsure, say N.
 config SYN_COOKIES
 	bool "IP: TCP syncookie support"
 	---help---
 	  Normal TCP/IP networking is open to an attack known as "SYN
 	  flooding". This denial-of-service attack prevents legitimate remote
 	  users from being able to connect to your computer during an ongoing
 	  attack and requires very little work from the attacker, who can
 	  operate from anywhere on the Internet.
 	  SYN cookies provide protection against this type of attack. If you
 	  say Y here, the TCP/IP stack will use a cryptographic challenge
 	  protocol known as "SYN cookies" to enable legitimate users to
 	  continue to connect, even when your machine is under attack. There
 	  is no need for the legitimate users to change their TCP/IP software;
 	  SYN cookies work transparently to them. For technical information
 	  about SYN cookies, check out <http://cr.yp.to/syncookies.html>.
 	  If you are SYN flooded, the source address reported by the kernel is
 	  likely to have been forged by the attacker; it is only reported as
 	  an aid in tracing the packets to their actual source and should not
 	  be taken as absolute truth.
 	  SYN cookies may prevent correct error reporting on clients when the
 	  server is really overloaded. If this happens frequently better turn
 	  them off.
 	  If you say Y here, you can disable SYN cookies at run time by
 	  saying Y to "/proc file system support" and
 	  "Sysctl support" below and executing the command
 	  echo 0 > /proc/sys/net/ipv4/tcp_syncookies
 	  after the /proc file system has been mounted.
 	  If unsure, say N.
 config INET_AH
 	tristate "IP: AH transformation"
 	select XFRM
 	select CRYPTO
 	select CRYPTO_HMAC
 	select CRYPTO_MD5
 	select CRYPTO_SHA1
 	---help---
 	  Support for IPsec AH.
 	  If unsure, say Y.
 config INET_ESP
 	tristate "IP: ESP transformation"
 	select XFRM
 	select CRYPTO
 	select CRYPTO_AUTHENC
 	select CRYPTO_HMAC
 	select CRYPTO_MD5
 	select CRYPTO_CBC
 	select CRYPTO_SHA1
 	select CRYPTO_DES
 	---help---
 	  Support for IPsec ESP.
 	  If unsure, say Y.
 config INET_IPCOMP
 	tristate "IP: IPComp transformation"
 	select INET_XFRM_TUNNEL
 	select XFRM_IPCOMP
 	---help---
 	  Support for IP Payload Compression Protocol (IPComp) (RFC3173),
 	  typically needed for IPsec.
 	  If unsure, say Y.
 config INET_XFRM_TUNNEL
 	tristate
 	select INET_TUNNEL
 	default n
 config INET_TUNNEL
 	tristate
 	default n
 config INET_XFRM_MODE_TRANSPORT
 	tristate "IP: IPsec transport mode"
 	default y
 	select XFRM
 	---help---
 	  Support for IPsec transport mode.
 	  If unsure, say Y.
 config INET_XFRM_MODE_TUNNEL
 	tristate "IP: IPsec tunnel mode"
 	default y
 	select XFRM
 	---help---
 	  Support for IPsec tunnel mode.
 	  If unsure, say Y.
 config INET_XFRM_MODE_BEET
 	tristate "IP: IPsec BEET mode"
 	default y
 	select XFRM
 	---help---
 	  Support for IPsec BEET mode.
 	  If unsure, say Y.
 config INET_LRO
 	bool "Large Receive Offload (ipv4/tcp)"
 	default y
 	---help---
 	  Support for Large Receive Offload (ipv4/tcp).
 	  If unsure, say Y.
 config INET_DIAG
 	tristate "INET: socket monitoring interface"
 	default y
 	---help---
 	  Support for INET (TCP, DCCP, etc) socket monitoring interface used by
 	  native Linux tools such as ss. ss is included in iproute2, currently
 	  downloadable at <http://linux-net.osdl.org/index.php/Iproute2>.
 	  If unsure, say Y.
 config INET_TCP_DIAG
 	depends on INET_DIAG
 	def_tristate INET_DIAG
 menuconfig TCP_CONG_ADVANCED
 	bool "TCP: advanced congestion control"
 	---help---
 	  Support for selection of various TCP congestion control
 	  modules.
 	  Nearly all users can safely say no here, and a safe default
 	  selection will be made (CUBIC with new Reno as a fallback).
 	  If unsure, say N.
 if TCP_CONG_ADVANCED
 config TCP_CONG_BIC
 	tristate "Binary Increase Congestion (BIC) control"
 	default m
 	---help---
 	BIC-TCP is a sender-side only change that ensures a linear RTT
 	fairness under large windows while offering both scalability and
 	bounded TCP-friendliness. The protocol combines two schemes
 	called additive increase and binary search increase. When the
 	congestion window is large, additive increase with a large
 	increment ensures linear RTT fairness as well as good
 	scalability. Under small congestion windows, binary search
 	increase provides TCP friendliness.
 	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/
 config TCP_CONG_CUBIC
 	tristate "CUBIC TCP"
 	default y
 	---help---
 	This is version 2.0 of BIC-TCP which uses a cubic growth function
 	among other techniques.
 	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf
 config TCP_CONG_WESTWOOD
 	tristate "TCP Westwood+"
 	default m
 	---help---
 	TCP Westwood+ is a sender-side only modification of the TCP Reno
 	protocol stack that optimizes the performance of TCP congestion
 	control. It is based on end-to-end bandwidth estimation to set
 	congestion window and slow start threshold after a congestion
 	episode. Using this estimation, TCP Westwood+ adaptively sets a
 	slow start threshold and a congestion window which takes into
 	account the bandwidth used  at the time congestion is experienced.
 	TCP Westwood+ significantly increases fairness wrt TCP Reno in
 	wired networks and throughput over wireless links.
 config TCP_CONG_HTCP
         tristate "H-TCP"
         default m
 	---help---
 	H-TCP is a send-side only modifications of the TCP Reno
 	protocol stack that optimizes the performance of TCP
 	congestion control for high speed network links. It uses a
 	modeswitch to change the alpha and beta parameters of TCP Reno
 	based on network conditions and in a way so as to be fair with
 	other Reno and H-TCP flows.
 config TCP_CONG_HSTCP
 	tristate "High Speed TCP"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	Sally Floyd's High Speed TCP (RFC 3649) congestion control.
 	A modification to TCP's congestion control mechanism for use
 	with large congestion windows. A table indicates how much to
 	increase the congestion window by when an ACK is received.
  	For more detail	see http://www.icir.org/floyd/hstcp.html
 config TCP_CONG_HYBLA
 	tristate "TCP-Hybla congestion control algorithm"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	TCP-Hybla is a sender-side only change that eliminates penalization of
 	long-RTT, large-bandwidth connections, like when satellite legs are
 	involved, especially when sharing a common bottleneck with normal
 	terrestrial connections.
 config TCP_CONG_VEGAS
 	tristate "TCP Vegas"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	TCP Vegas is a sender-side only change to TCP that anticipates
 	the onset of congestion by estimating the bandwidth. TCP Vegas
 	adjusts the sending rate by modifying the congestion
 	window. TCP Vegas should provide less packet loss, but it is
 	not as aggressive as TCP Reno.
 config TCP_CONG_SCALABLE
 	tristate "Scalable TCP"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	Scalable TCP is a sender-side only change to TCP which uses a
 	MIMD congestion control algorithm which has some nice scaling
 	properties, though is known to have fairness issues.
 	See http://www.deneholme.net/tom/scalable/
 config TCP_CONG_LP
 	tristate "TCP Low Priority"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	TCP Low Priority (TCP-LP), a distributed algorithm whose goal is
 	to utilize only the excess network bandwidth as compared to the
 	``fair share`` of bandwidth as targeted by TCP.
 	See http://www-ece.rice.edu/networks/TCP-LP/
 config TCP_CONG_VENO
 	tristate "TCP Veno"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	TCP Veno is a sender-side only enhancement of TCP to obtain better
 	throughput over wireless networks. TCP Veno makes use of state
 	distinguishing to circumvent the difficult judgment of the packet loss
 	type. TCP Veno cuts down less congestion window in response to random
 	loss packets.
 	See http://www.ntu.edu.sg/home5/ZHOU0022/papers/CPFu03a.pdf
 config TCP_CONG_YEAH
 	tristate "YeAH TCP"
 	depends on EXPERIMENTAL
 	select TCP_CONG_VEGAS
 	default n
 	---help---
 	YeAH-TCP is a sender-side high-speed enabled TCP congestion control
 	algorithm, which uses a mixed loss/delay approach to compute the
 	congestion window. It's design goals target high efficiency,
 	internal, RTT and Reno fairness, resilience to link loss while
 	keeping network elements load as low as possible.
 	For further details look here:
 	  http://wil.cs.caltech.edu/pfldnet2007/paper/YeAH_TCP.pdf
 config TCP_CONG_ILLINOIS
 	tristate "TCP Illinois"
 	depends on EXPERIMENTAL
 	default n
 	---help---
 	TCP-Illinois is a sender-side modification of TCP Reno for
 	high speed long delay links. It uses round-trip-time to
 	adjust the alpha and beta parameters to achieve a higher average
 	throughput and maintain fairness.
 	For further details see:
 	  http://www.ews.uiuc.edu/~shaoliu/tcpillinois/index.html
 choice
 	prompt "Default TCP congestion control"
 	default DEFAULT_CUBIC
 	help
 	  Select the TCP congestion control that will be used by default
 	  for all connections.
 	config DEFAULT_BIC
 		bool "Bic" if TCP_CONG_BIC=y
 	config DEFAULT_CUBIC
 		bool "Cubic" if TCP_CONG_CUBIC=y
 	config DEFAULT_HTCP
 		bool "Htcp" if TCP_CONG_HTCP=y
 	config DEFAULT_HYBLA
 		bool "Hybla" if TCP_CONG_HYBLA=y
 	config DEFAULT_VEGAS
 		bool "Vegas" if TCP_CONG_VEGAS=y
 	config DEFAULT_VENO
 		bool "Veno" if TCP_CONG_VENO=y
 	config DEFAULT_WESTWOOD
 		bool "Westwood" if TCP_CONG_WESTWOOD=y
 	config DEFAULT_RENO
 		bool "Reno"
 endchoice
 endif
 config TCP_CONG_CUBIC
 	tristate
 	depends on !TCP_CONG_ADVANCED
 	default y
 config DEFAULT_TCP_CONG
 	string
 	default "bic" if DEFAULT_BIC
 	default "cubic" if DEFAULT_CUBIC
 	default "htcp" if DEFAULT_HTCP
 	default "hybla" if DEFAULT_HYBLA
 	default "vegas" if DEFAULT_VEGAS
 	default "westwood" if DEFAULT_WESTWOOD
 	default "veno" if DEFAULT_VENO
 	default "reno" if DEFAULT_RENO
 	default "cubic"
 config TCP_MD5SIG
 	bool "TCP: MD5 Signature Option support (RFC2385) (EXPERIMENTAL)"
 	depends on EXPERIMENTAL
 	select CRYPTO
 	select CRYPTO_MD5
 	---help---
 	  RFC2385 specifies a method of giving MD5 protection to TCP sessions.
 	  Its main (only?) use is to protect BGP sessions between core routers
 	  on the Internet.
 	  If unsure, say N.

net/ipv4/tcp_timer.c

Diff comments View file @ 4a73a43

 /*
  * INET		An implementation of the TCP/IP protocol suite for the LINUX
  *		operating system.  INET is implemented using the  BSD Socket
  *		interface as the means of communication with the user level.
  *
  *		Implementation of the Transmission Control Protocol(TCP).
  *
  * Authors:	Ross Biro
  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  *		Mark Evans, <evansmp@uhura.aston.ac.uk>
  *		Corey Minyard <wf-rch!minyard@relay.EU.net>
  *		Florian La Roche, <flla@stud.uni-sb.de>
  *		Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
  *		Linus Torvalds, <torvalds@cs.helsinki.fi>
  *		Alan Cox, <gw4pts@gw4pts.ampr.org>
  *		Matthew Dillon, <dillon@apollo.west.oic.com>
  *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
  *		Jorge Cwik, <jorge@laser.satlink.net>
  */
 #include <linux/module.h>
 #include <linux/gfp.h>
 #include <net/tcp.h>
 int sysctl_tcp_syn_retries __read_mostly = TCP_SYN_RETRIES;
 int sysctl_tcp_synack_retries __read_mostly = TCP_SYNACK_RETRIES;
 int sysctl_tcp_keepalive_time __read_mostly = TCP_KEEPALIVE_TIME;
 int sysctl_tcp_keepalive_probes __read_mostly = TCP_KEEPALIVE_PROBES;
 int sysctl_tcp_keepalive_intvl __read_mostly = TCP_KEEPALIVE_INTVL;
 int sysctl_tcp_retries1 __read_mostly = TCP_RETR1;
 int sysctl_tcp_retries2 __read_mostly = TCP_RETR2;
 int sysctl_tcp_orphan_retries __read_mostly;
 int sysctl_tcp_thin_linear_timeouts __read_mostly;
 static void tcp_write_timer(unsigned long);
 static void tcp_delack_timer(unsigned long);
 static void tcp_keepalive_timer (unsigned long data);
 void tcp_init_xmit_timers(struct sock *sk)
 {
 	inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer,
 				  &tcp_keepalive_timer);
 }
 EXPORT_SYMBOL(tcp_init_xmit_timers);
 static void tcp_write_err(struct sock *sk)
 {
 	sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
 	sk->sk_error_report(sk);
 	tcp_done(sk);
 	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONTIMEOUT);
 }
 /* Do not allow orphaned sockets to eat all our resources.
  * This is direct violation of TCP specs, but it is required
  * to prevent DoS attacks. It is called when a retransmission timeout
  * or zero probe timeout occurs on orphaned socket.
  *
  * Criteria is still not confirmed experimentally and may change.
  * We kill the socket, if:
  * 1. If number of orphaned sockets exceeds an administratively configured
  *    limit.
  * 2. If we have strong memory pressure.
  */
 static int tcp_out_of_resources(struct sock *sk, int do_reset)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	int shift = 0;
 	/* If peer does not open window for long time, or did not transmit
 	 * anything for long time, penalize it. */
 	if ((s32)(tcp_time_stamp - tp->lsndtime) > 2*TCP_RTO_MAX || !do_reset)
 		shift++;
 	/* If some dubious ICMP arrived, penalize even more. */
 	if (sk->sk_err_soft)
 		shift++;
 	if (tcp_too_many_orphans(sk, shift)) {
 		if (net_ratelimit())
 			printk(KERN_INFO "Out of socket memory\n");
 		/* Catch exceptional cases, when connection requires reset.
 		 *      1. Last segment was sent recently. */
 		if ((s32)(tcp_time_stamp - tp->lsndtime) <= TCP_TIMEWAIT_LEN ||
 		    /*  2. Window is closed. */
 		    (!tp->snd_wnd && !tp->packets_out))
 			do_reset = 1;
 		if (do_reset)
 			tcp_send_active_reset(sk, GFP_ATOMIC);
 		tcp_done(sk);
 		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONMEMORY);
 		return 1;
 	}
 	return 0;
 }
 /* Calculate maximal number or retries on an orphaned socket. */
 static int tcp_orphan_retries(struct sock *sk, int alive)
 {
 	int retries = sysctl_tcp_orphan_retries; /* May be zero. */
 	/* We know from an ICMP that something is wrong. */
 	if (sk->sk_err_soft && !alive)
 		retries = 0;
 	/* However, if socket sent something recently, select some safe
 	 * number of retries. 8 corresponds to >100 seconds with minimal
 	 * RTO of 200msec. */
 	if (retries == 0 && alive)
 		retries = 8;
 	return retries;
 }
 static void tcp_mtu_probing(struct inet_connection_sock *icsk, struct sock *sk)
 {
 	/* Black hole detection */
 	if (sysctl_tcp_mtu_probing) {
 		if (!icsk->icsk_mtup.enabled) {
 			icsk->icsk_mtup.enabled = 1;
 			tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
 		} else {
 			struct tcp_sock *tp = tcp_sk(sk);
 			int mss;
 			mss = tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low) >> 1;
 			mss = min(sysctl_tcp_base_mss, mss);
 			mss = max(mss, 68 - tp->tcp_header_len);
 			icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss);
 			tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
 		}
 	}
 }
 /* This function calculates a "timeout" which is equivalent to the timeout of a
  * TCP connection after "boundary" unsuccessful, exponentially backed-off
- * retransmissions with an initial RTO of TCP_RTO_MIN.
+ * retransmissions with an initial RTO of TCP_RTO_MIN or TCP_TIMEOUT_INIT if
+ * syn_set flag is set.
  */
 static bool retransmits_timed_out(struct sock *sk,
-				  unsigned int boundary)
+				  unsigned int boundary,
+				  bool syn_set)
 {
 	unsigned int timeout, linear_backoff_thresh;
 	unsigned int start_ts;
+	unsigned int rto_base = syn_set ? TCP_TIMEOUT_INIT : TCP_RTO_MIN;
 	if (!inet_csk(sk)->icsk_retransmits)
 		return false;
 	if (unlikely(!tcp_sk(sk)->retrans_stamp))
 		start_ts = TCP_SKB_CB(tcp_write_queue_head(sk))->when;
 	else
 		start_ts = tcp_sk(sk)->retrans_stamp;
-	linear_backoff_thresh = ilog2(TCP_RTO_MAX/TCP_RTO_MIN);
+	linear_backoff_thresh = ilog2(TCP_RTO_MAX/rto_base);
 	if (boundary <= linear_backoff_thresh)
-		timeout = ((2 << boundary) - 1) * TCP_RTO_MIN;
+		timeout = ((2 << boundary) - 1) * rto_base;
 	else
-		timeout = ((2 << linear_backoff_thresh) - 1) * TCP_RTO_MIN +
+		timeout = ((2 << linear_backoff_thresh) - 1) * rto_base +
 			  (boundary - linear_backoff_thresh) * TCP_RTO_MAX;
 	return (tcp_time_stamp - start_ts) >= timeout;
 }
 /* A write timeout has occurred. Process the after effects. */
 static int tcp_write_timeout(struct sock *sk)
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	int retry_until;
-	bool do_reset;
+	bool do_reset, syn_set = 0;
 	if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
 		if (icsk->icsk_retransmits)
 			dst_negative_advice(sk);
 		retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
+		syn_set = 1;
 	} else {
-		if (retransmits_timed_out(sk, sysctl_tcp_retries1)) {
+		if (retransmits_timed_out(sk, sysctl_tcp_retries1, 0)) {
 			/* Black hole detection */
 			tcp_mtu_probing(icsk, sk);
 			dst_negative_advice(sk);
 		}
 		retry_until = sysctl_tcp_retries2;
 		if (sock_flag(sk, SOCK_DEAD)) {
 			const int alive = (icsk->icsk_rto < TCP_RTO_MAX);
 			retry_until = tcp_orphan_retries(sk, alive);
 			do_reset = alive ||
-				   !retransmits_timed_out(sk, retry_until);
+				   !retransmits_timed_out(sk, retry_until, 0);
 			if (tcp_out_of_resources(sk, do_reset))
 				return 1;
 		}
 	}
-	if (retransmits_timed_out(sk, retry_until)) {
+	if (retransmits_timed_out(sk, retry_until, syn_set)) {
 		/* Has it gone just too far? */
 		tcp_write_err(sk);
 		return 1;
 	}
 	return 0;
 }
 static void tcp_delack_timer(unsigned long data)
 {
 	struct sock *sk = (struct sock *)data;
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	bh_lock_sock(sk);
 	if (sock_owned_by_user(sk)) {
 		/* Try again later. */
 		icsk->icsk_ack.blocked = 1;
 		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOCKED);
 		sk_reset_timer(sk, &icsk->icsk_delack_timer, jiffies + TCP_DELACK_MIN);
 		goto out_unlock;
 	}
 	sk_mem_reclaim_partial(sk);
 	if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
 		goto out;
 	if (time_after(icsk->icsk_ack.timeout, jiffies)) {
 		sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
 		goto out;
 	}
 	icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
 	if (!skb_queue_empty(&tp->ucopy.prequeue)) {
 		struct sk_buff *skb;
 		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSCHEDULERFAILED);
 		while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
 			sk_backlog_rcv(sk, skb);
 		tp->ucopy.memory = 0;
 	}
 	if (inet_csk_ack_scheduled(sk)) {
 		if (!icsk->icsk_ack.pingpong) {
 			/* Delayed ACK missed: inflate ATO. */
 			icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto);
 		} else {
 			/* Delayed ACK missed: leave pingpong mode and
 			 * deflate ATO.
 			 */
 			icsk->icsk_ack.pingpong = 0;
 			icsk->icsk_ack.ato      = TCP_ATO_MIN;
 		}
 		tcp_send_ack(sk);
 		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKS);
 	}
 	TCP_CHECK_TIMER(sk);
 out:
 	if (tcp_memory_pressure)
 		sk_mem_reclaim(sk);
 out_unlock:
 	bh_unlock_sock(sk);
 	sock_put(sk);
 }
 static void tcp_probe_timer(struct sock *sk)
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	struct tcp_sock *tp = tcp_sk(sk);
 	int max_probes;
 	if (tp->packets_out || !tcp_send_head(sk)) {
 		icsk->icsk_probes_out = 0;
 		return;
 	}
 	/* *WARNING* RFC 1122 forbids this
 	 *
 	 * It doesn't AFAIK, because we kill the retransmit timer -AK
 	 *
 	 * FIXME: We ought not to do it, Solaris 2.5 actually has fixing
 	 * this behaviour in Solaris down as a bug fix. [AC]
 	 *
 	 * Let me to explain. icsk_probes_out is zeroed by incoming ACKs
 	 * even if they advertise zero window. Hence, connection is killed only
 	 * if we received no ACKs for normal connection timeout. It is not killed
 	 * only because window stays zero for some time, window may be zero
 	 * until armageddon and even later. We are in full accordance
 	 * with RFCs, only probe timer combines both retransmission timeout
 	 * and probe timeout in one bottle.				--ANK
 	 */
 	max_probes = sysctl_tcp_retries2;
 	if (sock_flag(sk, SOCK_DEAD)) {
 		const int alive = ((icsk->icsk_rto << icsk->icsk_backoff) < TCP_RTO_MAX);
 		max_probes = tcp_orphan_retries(sk, alive);
 		if (tcp_out_of_resources(sk, alive || icsk->icsk_probes_out <= max_probes))
 			return;
 	}
 	if (icsk->icsk_probes_out > max_probes) {
 		tcp_write_err(sk);
 	} else {
 		/* Only send another probe if we didn't close things up. */
 		tcp_send_probe0(sk);
 	}
 }
 /*
  *	The TCP retransmit timer.
  */
 void tcp_retransmit_timer(struct sock *sk)
 {
 	struct tcp_sock *tp = tcp_sk(sk);
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	if (!tp->packets_out)
 		goto out;
 	WARN_ON(tcp_write_queue_empty(sk));
 	if (!tp->snd_wnd && !sock_flag(sk, SOCK_DEAD) &&
 	    !((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))) {
 		/* Receiver dastardly shrinks window. Our retransmits
 		 * become zero probes, but we should not timeout this
 		 * connection. If the socket is an orphan, time it out,
 		 * we cannot allow such beasts to hang infinitely.
 		 */
 #ifdef TCP_DEBUG
 		struct inet_sock *inet = inet_sk(sk);
 		if (sk->sk_family == AF_INET) {
 			LIMIT_NETDEBUG(KERN_DEBUG "TCP: Peer %pI4:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
 			       &inet->inet_daddr, ntohs(inet->inet_dport),
 			       inet->inet_num, tp->snd_una, tp->snd_nxt);
 		}
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 		else if (sk->sk_family == AF_INET6) {
 			struct ipv6_pinfo *np = inet6_sk(sk);
 			LIMIT_NETDEBUG(KERN_DEBUG "TCP: Peer %pI6:%u/%u unexpectedly shrunk window %u:%u (repaired)\n",
 			       &np->daddr, ntohs(inet->inet_dport),
 			       inet->inet_num, tp->snd_una, tp->snd_nxt);
 		}
 #endif
 #endif
 		if (tcp_time_stamp - tp->rcv_tstamp > TCP_RTO_MAX) {
 			tcp_write_err(sk);
 			goto out;
 		}
 		tcp_enter_loss(sk, 0);
 		tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
 		__sk_dst_reset(sk);
 		goto out_reset_timer;
 	}
 	if (tcp_write_timeout(sk))
 		goto out;
 	if (icsk->icsk_retransmits == 0) {
 		int mib_idx;
 		if (icsk->icsk_ca_state == TCP_CA_Disorder) {
 			if (tcp_is_sack(tp))
 				mib_idx = LINUX_MIB_TCPSACKFAILURES;
 			else
 				mib_idx = LINUX_MIB_TCPRENOFAILURES;
 		} else if (icsk->icsk_ca_state == TCP_CA_Recovery) {
 			if (tcp_is_sack(tp))
 				mib_idx = LINUX_MIB_TCPSACKRECOVERYFAIL;
 			else
 				mib_idx = LINUX_MIB_TCPRENORECOVERYFAIL;
 		} else if (icsk->icsk_ca_state == TCP_CA_Loss) {
 			mib_idx = LINUX_MIB_TCPLOSSFAILURES;
 		} else {
 			mib_idx = LINUX_MIB_TCPTIMEOUTS;
 		}
 		NET_INC_STATS_BH(sock_net(sk), mib_idx);
 	}
 	if (tcp_use_frto(sk)) {
 		tcp_enter_frto(sk);
 	} else {
 		tcp_enter_loss(sk, 0);
 	}
 	if (tcp_retransmit_skb(sk, tcp_write_queue_head(sk)) > 0) {
 		/* Retransmission failed because of local congestion,
 		 * do not backoff.
 		 */
 		if (!icsk->icsk_retransmits)
 			icsk->icsk_retransmits = 1;
 		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
 					  min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL),
 					  TCP_RTO_MAX);
 		goto out;
 	}
 	/* Increase the timeout each time we retransmit.  Note that
 	 * we do not increase the rtt estimate.  rto is initialized
 	 * from rtt, but increases here.  Jacobson (SIGCOMM 88) suggests
 	 * that doubling rto each time is the least we can get away with.
 	 * In KA9Q, Karn uses this for the first few times, and then
 	 * goes to quadratic.  netBSD doubles, but only goes up to *64,
 	 * and clamps at 1 to 64 sec afterwards.  Note that 120 sec is
 	 * defined in the protocol as the maximum possible RTT.  I guess
 	 * we'll have to use something other than TCP to talk to the
 	 * University of Mars.
 	 *
 	 * PAWS allows us longer timeouts and large windows, so once
 	 * implemented ftp to mars will work nicely. We will have to fix
 	 * the 120 second clamps though!
 	 */
 	icsk->icsk_backoff++;
 	icsk->icsk_retransmits++;
 out_reset_timer:
 	/* If stream is thin, use linear timeouts. Since 'icsk_backoff' is
 	 * used to reset timer, set to 0. Recalculate 'icsk_rto' as this
 	 * might be increased if the stream oscillates between thin and thick,
 	 * thus the old value might already be too high compared to the value
 	 * set by 'tcp_set_rto' in tcp_input.c which resets the rto without
 	 * backoff. Limit to TCP_THIN_LINEAR_RETRIES before initiating
 	 * exponential backoff behaviour to avoid continue hammering
 	 * linear-timeout retransmissions into a black hole
 	 */
 	if (sk->sk_state == TCP_ESTABLISHED &&
 	    (tp->thin_lto || sysctl_tcp_thin_linear_timeouts) &&
 	    tcp_stream_is_thin(tp) &&
 	    icsk->icsk_retransmits <= TCP_THIN_LINEAR_RETRIES) {
 		icsk->icsk_backoff = 0;
 		icsk->icsk_rto = min(__tcp_set_rto(tp), TCP_RTO_MAX);
 	} else {
 		/* Use normal (exponential) backoff */
 		icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);
 	}
 	inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto, TCP_RTO_MAX);
-	if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1))
+	if (retransmits_timed_out(sk, sysctl_tcp_retries1 + 1, 0))
 		__sk_dst_reset(sk);
 out:;
 }
 static void tcp_write_timer(unsigned long data)
 {
 	struct sock *sk = (struct sock *)data;
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	int event;
 	bh_lock_sock(sk);
 	if (sock_owned_by_user(sk)) {
 		/* Try again later */
 		sk_reset_timer(sk, &icsk->icsk_retransmit_timer, jiffies + (HZ / 20));
 		goto out_unlock;
 	}
 	if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending)
 		goto out;
 	if (time_after(icsk->icsk_timeout, jiffies)) {
 		sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
 		goto out;
 	}
 	event = icsk->icsk_pending;
 	icsk->icsk_pending = 0;
 	switch (event) {
 	case ICSK_TIME_RETRANS:
 		tcp_retransmit_timer(sk);
 		break;
 	case ICSK_TIME_PROBE0:
 		tcp_probe_timer(sk);
 		break;
 	}
 	TCP_CHECK_TIMER(sk);
 out:
 	sk_mem_reclaim(sk);
 out_unlock:
 	bh_unlock_sock(sk);
 	sock_put(sk);
 }
 /*
  *	Timer for listening sockets
  */
 static void tcp_synack_timer(struct sock *sk)
 {
 	inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
 				   TCP_TIMEOUT_INIT, TCP_RTO_MAX);
 }
 void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req)
 {
 	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPTIMEOUTS);
 }
 EXPORT_SYMBOL(tcp_syn_ack_timeout);
 void tcp_set_keepalive(struct sock *sk, int val)
 {
 	if ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))
 		return;
 	if (val && !sock_flag(sk, SOCK_KEEPOPEN))
 		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk)));
 	else if (!val)
 		inet_csk_delete_keepalive_timer(sk);
 }
 static void tcp_keepalive_timer (unsigned long data)
 {
 	struct sock *sk = (struct sock *) data;
 	struct inet_connection_sock *icsk = inet_csk(sk);
 	struct tcp_sock *tp = tcp_sk(sk);
 	u32 elapsed;
 	/* Only process if socket is not in use. */
 	bh_lock_sock(sk);
 	if (sock_owned_by_user(sk)) {
 		/* Try again later. */
 		inet_csk_reset_keepalive_timer (sk, HZ/20);
 		goto out;
 	}
 	if (sk->sk_state == TCP_LISTEN) {
 		tcp_synack_timer(sk);
 		goto out;
 	}
 	if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
 		if (tp->linger2 >= 0) {
 			const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
 			if (tmo > 0) {
 				tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
 				goto out;
 			}
 		}
 		tcp_send_active_reset(sk, GFP_ATOMIC);
 		goto death;
 	}
 	if (!sock_flag(sk, SOCK_KEEPOPEN) || sk->sk_state == TCP_CLOSE)
 		goto out;
 	elapsed = keepalive_time_when(tp);
 	/* It is alive without keepalive 8) */
 	if (tp->packets_out || tcp_send_head(sk))
 		goto resched;
 	elapsed = keepalive_time_elapsed(tp);
 	if (elapsed >= keepalive_time_when(tp)) {
 		if (icsk->icsk_probes_out >= keepalive_probes(tp)) {
 			tcp_send_active_reset(sk, GFP_ATOMIC);
 			tcp_write_err(sk);
 			goto out;
 		}
 		if (tcp_write_wakeup(sk) <= 0) {
 			icsk->icsk_probes_out++;
 			elapsed = keepalive_intvl_when(tp);
 		} else {
 			/* If keepalive was lost due to local congestion,
 			 * try harder.
 			 */
 			elapsed = TCP_RESOURCE_PROBE_INTERVAL;
 		}
 	} else {
 		/* It is tp->rcv_tstamp + keepalive_time_when(tp) */
 		elapsed = keepalive_time_when(tp) - elapsed;
 	}
 	TCP_CHECK_TIMER(sk);
 	sk_mem_reclaim(sk);
 resched:
 	inet_csk_reset_keepalive_timer (sk, elapsed);
 	goto out;
 death:
 	tcp_done(sk);
 out:
 	bh_unlock_sock(sk);
 	sock_put(sk);
 }

net/mac80211/rx.c

Diff comments View file @ 4a73a43

 /*
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  * Copyright 2007-2010	Johannes Berg <johannes@sipsolutions.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/jiffies.h>
 #include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/rcupdate.h>
 #include <net/mac80211.h>
 #include <net/ieee80211_radiotap.h>
 #include "ieee80211_i.h"
 #include "driver-ops.h"
 #include "led.h"
 #include "mesh.h"
 #include "wep.h"
 #include "wpa.h"
 #include "tkip.h"
 #include "wme.h"
 /*
  * monitor mode reception
  *
  * This function cleans up the SKB, i.e. it removes all the stuff
  * only useful for monitoring.
  */
 static struct sk_buff *remove_monitor_info(struct ieee80211_local *local,
 					   struct sk_buff *skb)
 {
 	if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS) {
 		if (likely(skb->len > FCS_LEN))
 			__pskb_trim(skb, skb->len - FCS_LEN);
 		else {
 			/* driver bug */
 			WARN_ON(1);
 			dev_kfree_skb(skb);
 			skb = NULL;
 		}
 	}
 	return skb;
 }
 static inline int should_drop_frame(struct sk_buff *skb,
 				    int present_fcs_len)
 {
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
 		return 1;
 	if (unlikely(skb->len < 16 + present_fcs_len))
 		return 1;
 	if (ieee80211_is_ctl(hdr->frame_control) &&
 	    !ieee80211_is_pspoll(hdr->frame_control) &&
 	    !ieee80211_is_back_req(hdr->frame_control))
 		return 1;
 	return 0;
 }
 static int
 ieee80211_rx_radiotap_len(struct ieee80211_local *local,
 			  struct ieee80211_rx_status *status)
 {
 	int len;
 	/* always present fields */
 	len = sizeof(struct ieee80211_radiotap_header) + 9;
 	if (status->flag & RX_FLAG_TSFT)
 		len += 8;
 	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
 		len += 1;
 	if (len & 1) /* padding for RX_FLAGS if necessary */
 		len++;
 	return len;
 }
 /*
  * ieee80211_add_rx_radiotap_header - add radiotap header
  *
  * add a radiotap header containing all the fields which the hardware provided.
  */
 static void
 ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
 				 struct sk_buff *skb,
 				 struct ieee80211_rate *rate,
 				 int rtap_len)
 {
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	struct ieee80211_radiotap_header *rthdr;
 	unsigned char *pos;
 	u16 rx_flags = 0;
 	rthdr = (struct ieee80211_radiotap_header *)skb_push(skb, rtap_len);
 	memset(rthdr, 0, rtap_len);
 	/* radiotap header, set always present flags */
 	rthdr->it_present =
 		cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 			    (1 << IEEE80211_RADIOTAP_CHANNEL) |
 			    (1 << IEEE80211_RADIOTAP_ANTENNA) |
 			    (1 << IEEE80211_RADIOTAP_RX_FLAGS));
 	rthdr->it_len = cpu_to_le16(rtap_len);
 	pos = (unsigned char *)(rthdr+1);
 	/* the order of the following fields is important */
 	/* IEEE80211_RADIOTAP_TSFT */
 	if (status->flag & RX_FLAG_TSFT) {
 		put_unaligned_le64(status->mactime, pos);
 		rthdr->it_present |=
 			cpu_to_le32(1 << IEEE80211_RADIOTAP_TSFT);
 		pos += 8;
 	}
 	/* IEEE80211_RADIOTAP_FLAGS */
 	if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
 		*pos |= IEEE80211_RADIOTAP_F_FCS;
 	if (status->flag & (RX_FLAG_FAILED_FCS_CRC | RX_FLAG_FAILED_PLCP_CRC))
 		*pos |= IEEE80211_RADIOTAP_F_BADFCS;
 	if (status->flag & RX_FLAG_SHORTPRE)
 		*pos |= IEEE80211_RADIOTAP_F_SHORTPRE;
 	pos++;
 	/* IEEE80211_RADIOTAP_RATE */
 	if (status->flag & RX_FLAG_HT) {
 		/*
 		 * TODO: add following information into radiotap header once
 		 * suitable fields are defined for it:
 		 * - MCS index (status->rate_idx)
 		 * - HT40 (status->flag & RX_FLAG_40MHZ)
 		 * - short-GI (status->flag & RX_FLAG_SHORT_GI)
 		 */
 		*pos = 0;
 	} else {
 		rthdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
 		*pos = rate->bitrate / 5;
 	}
 	pos++;
 	/* IEEE80211_RADIOTAP_CHANNEL */
 	put_unaligned_le16(status->freq, pos);
 	pos += 2;
 	if (status->band == IEEE80211_BAND_5GHZ)
 		put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
 				   pos);
 	else if (status->flag & RX_FLAG_HT)
 		put_unaligned_le16(IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ,
 				   pos);
 	else if (rate->flags & IEEE80211_RATE_ERP_G)
 		put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
 				   pos);
 	else
 		put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
 				   pos);
 	pos += 2;
 	/* IEEE80211_RADIOTAP_DBM_ANTSIGNAL */
 	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) {
 		*pos = status->signal;
 		rthdr->it_present |=
 			cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
 		pos++;
 	}
 	/* IEEE80211_RADIOTAP_LOCK_QUALITY is missing */
 	/* IEEE80211_RADIOTAP_ANTENNA */
 	*pos = status->antenna;
 	pos++;
 	/* IEEE80211_RADIOTAP_DB_ANTNOISE is not used */
 	/* IEEE80211_RADIOTAP_RX_FLAGS */
 	/* ensure 2 byte alignment for the 2 byte field as required */
 	if ((pos - (u8 *)rthdr) & 1)
 		pos++;
 	if (status->flag & RX_FLAG_FAILED_PLCP_CRC)
 		rx_flags |= IEEE80211_RADIOTAP_F_RX_BADPLCP;
 	put_unaligned_le16(rx_flags, pos);
 	pos += 2;
 }
 /*
  * This function copies a received frame to all monitor interfaces and
  * returns a cleaned-up SKB that no longer includes the FCS nor the
  * radiotap header the driver might have added.
  */
 static struct sk_buff *
 ieee80211_rx_monitor(struct ieee80211_local *local, struct sk_buff *origskb,
 		     struct ieee80211_rate *rate)
 {
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(origskb);
 	struct ieee80211_sub_if_data *sdata;
 	int needed_headroom = 0;
 	struct sk_buff *skb, *skb2;
 	struct net_device *prev_dev = NULL;
 	int present_fcs_len = 0;
 	/*
 	 * First, we may need to make a copy of the skb because
 	 *  (1) we need to modify it for radiotap (if not present), and
 	 *  (2) the other RX handlers will modify the skb we got.
 	 *
 	 * We don't need to, of course, if we aren't going to return
 	 * the SKB because it has a bad FCS/PLCP checksum.
 	 */
 	/* room for the radiotap header based on driver features */
 	needed_headroom = ieee80211_rx_radiotap_len(local, status);
 	if (local->hw.flags & IEEE80211_HW_RX_INCLUDES_FCS)
 		present_fcs_len = FCS_LEN;
 	/* make sure hdr->frame_control is on the linear part */
 	if (!pskb_may_pull(origskb, 2)) {
 		dev_kfree_skb(origskb);
 		return NULL;
 	}
 	if (!local->monitors) {
 		if (should_drop_frame(origskb, present_fcs_len)) {
 			dev_kfree_skb(origskb);
 			return NULL;
 		}
 		return remove_monitor_info(local, origskb);
 	}
 	if (should_drop_frame(origskb, present_fcs_len)) {
 		/* only need to expand headroom if necessary */
 		skb = origskb;
 		origskb = NULL;
 		/*
 		 * This shouldn't trigger often because most devices have an
 		 * RX header they pull before we get here, and that should
 		 * be big enough for our radiotap information. We should
 		 * probably export the length to drivers so that we can have
 		 * them allocate enough headroom to start with.
 		 */
 		if (skb_headroom(skb) < needed_headroom &&
 		    pskb_expand_head(skb, needed_headroom, 0, GFP_ATOMIC)) {
 			dev_kfree_skb(skb);
 			return NULL;
 		}
 	} else {
 		/*
 		 * Need to make a copy and possibly remove radiotap header
 		 * and FCS from the original.
 		 */
 		skb = skb_copy_expand(origskb, needed_headroom, 0, GFP_ATOMIC);
 		origskb = remove_monitor_info(local, origskb);
 		if (!skb)
 			return origskb;
 	}
 	/* prepend radiotap information */
 	ieee80211_add_rx_radiotap_header(local, skb, rate, needed_headroom);
 	skb_reset_mac_header(skb);
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 	skb->pkt_type = PACKET_OTHERHOST;
 	skb->protocol = htons(ETH_P_802_2);
 	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 		if (sdata->vif.type != NL80211_IFTYPE_MONITOR)
 			continue;
 		if (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES)
 			continue;
 		if (!ieee80211_sdata_running(sdata))
 			continue;
 		if (prev_dev) {
 			skb2 = skb_clone(skb, GFP_ATOMIC);
 			if (skb2) {
 				skb2->dev = prev_dev;
 				netif_receive_skb(skb2);
 			}
 		}
 		prev_dev = sdata->dev;
 		sdata->dev->stats.rx_packets++;
 		sdata->dev->stats.rx_bytes += skb->len;
 	}
 	if (prev_dev) {
 		skb->dev = prev_dev;
 		netif_receive_skb(skb);
 	} else
 		dev_kfree_skb(skb);
 	return origskb;
 }
 static void ieee80211_parse_qos(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	int tid;
 	/* does the frame have a qos control field? */
 	if (ieee80211_is_data_qos(hdr->frame_control)) {
 		u8 *qc = ieee80211_get_qos_ctl(hdr);
 		/* frame has qos control */
 		tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
 		if (*qc & IEEE80211_QOS_CONTROL_A_MSDU_PRESENT)
 			rx->flags |= IEEE80211_RX_AMSDU;
 		else
 			rx->flags &= ~IEEE80211_RX_AMSDU;
 	} else {
 		/*
 		 * IEEE 802.11-2007, 7.1.3.4.1 ("Sequence Number field"):
 		 *
 		 *	Sequence numbers for management frames, QoS data
 		 *	frames with a broadcast/multicast address in the
 		 *	Address 1 field, and all non-QoS data frames sent
 		 *	by QoS STAs are assigned using an additional single
 		 *	modulo-4096 counter, [...]
 		 *
 		 * We also use that counter for non-QoS STAs.
 		 */
 		tid = NUM_RX_DATA_QUEUES - 1;
 	}
 	rx->queue = tid;
 	/* Set skb->priority to 1d tag if highest order bit of TID is not set.
 	 * For now, set skb->priority to 0 for other cases. */
 	rx->skb->priority = (tid > 7) ? 0 : tid;
 }
 /**
  * DOC: Packet alignment
  *
  * Drivers always need to pass packets that are aligned to two-byte boundaries
  * to the stack.
  *
  * Additionally, should, if possible, align the payload data in a way that
  * guarantees that the contained IP header is aligned to a four-byte
  * boundary. In the case of regular frames, this simply means aligning the
  * payload to a four-byte boundary (because either the IP header is directly
  * contained, or IV/RFC1042 headers that have a length divisible by four are
  * in front of it).  If the payload data is not properly aligned and the
  * architecture doesn't support efficient unaligned operations, mac80211
  * will align the data.
  *
  * With A-MSDU frames, however, the payload data address must yield two modulo
  * four because there are 14-byte 802.3 headers within the A-MSDU frames that
  * push the IP header further back to a multiple of four again. Thankfully, the
  * specs were sane enough this time around to require padding each A-MSDU
  * subframe to a length that is a multiple of four.
  *
  * Padding like Atheros hardware adds which is inbetween the 802.11 header and
  * the payload is not supported, the driver is required to move the 802.11
  * header to be directly in front of the payload in that case.
  */
 static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
 {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 	WARN_ONCE((unsigned long)rx->skb->data & 1,
 		  "unaligned packet at 0x%p\n", rx->skb->data);
 #endif
 }
 /* rx handlers */
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_passive_scan(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_local *local = rx->local;
 	struct sk_buff *skb = rx->skb;
 	if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning)))
 		return ieee80211_scan_rx(rx->sdata, skb);
 	if (unlikely(test_bit(SCAN_SW_SCANNING, &local->scanning) &&
 		     (rx->flags & IEEE80211_RX_IN_SCAN))) {
 		/* drop all the other packets during a software scan anyway */
 		if (ieee80211_scan_rx(rx->sdata, skb) != RX_QUEUED)
 			dev_kfree_skb(skb);
 		return RX_QUEUED;
 	}
 	if (unlikely(rx->flags & IEEE80211_RX_IN_SCAN)) {
 		/* scanning finished during invoking of handlers */
 		I802_DEBUG_INC(local->rx_handlers_drop_passive_scan);
 		return RX_DROP_UNUSABLE;
 	}
 	return RX_CONTINUE;
 }
 static int ieee80211_is_unicast_robust_mgmt_frame(struct sk_buff *skb)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	if (skb->len < 24 || is_multicast_ether_addr(hdr->addr1))
 		return 0;
 	return ieee80211_is_robust_mgmt_frame(hdr);
 }
 static int ieee80211_is_multicast_robust_mgmt_frame(struct sk_buff *skb)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	if (skb->len < 24 || !is_multicast_ether_addr(hdr->addr1))
 		return 0;
 	return ieee80211_is_robust_mgmt_frame(hdr);
 }
 /* Get the BIP key index from MMIE; return -1 if this is not a BIP frame */
 static int ieee80211_get_mmie_keyidx(struct sk_buff *skb)
 {
 	struct ieee80211_mgmt *hdr = (struct ieee80211_mgmt *) skb->data;
 	struct ieee80211_mmie *mmie;
 	if (skb->len < 24 + sizeof(*mmie) ||
 	    !is_multicast_ether_addr(hdr->da))
 		return -1;
 	if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *) hdr))
 		return -1; /* not a robust management frame */
 	mmie = (struct ieee80211_mmie *)
 		(skb->data + skb->len - sizeof(*mmie));
 	if (mmie->element_id != WLAN_EID_MMIE ||
 	    mmie->length != sizeof(*mmie) - 2)
 		return -1;
 	return le16_to_cpu(mmie->key_id);
 }
 static ieee80211_rx_result
 ieee80211_rx_mesh_check(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	unsigned int hdrlen = ieee80211_hdrlen(hdr->frame_control);
 	char *dev_addr = rx->sdata->vif.addr;
 	if (ieee80211_is_data(hdr->frame_control)) {
 		if (is_multicast_ether_addr(hdr->addr1)) {
 			if (ieee80211_has_tods(hdr->frame_control) ||
 				!ieee80211_has_fromds(hdr->frame_control))
 				return RX_DROP_MONITOR;
 			if (memcmp(hdr->addr3, dev_addr, ETH_ALEN) == 0)
 				return RX_DROP_MONITOR;
 		} else {
 			if (!ieee80211_has_a4(hdr->frame_control))
 				return RX_DROP_MONITOR;
 			if (memcmp(hdr->addr4, dev_addr, ETH_ALEN) == 0)
 				return RX_DROP_MONITOR;
 		}
 	}
 	/* If there is not an established peer link and this is not a peer link
 	 * establisment frame, beacon or probe, drop the frame.
 	 */
 	if (!rx->sta || sta_plink_state(rx->sta) != PLINK_ESTAB) {
 		struct ieee80211_mgmt *mgmt;
 		if (!ieee80211_is_mgmt(hdr->frame_control))
 			return RX_DROP_MONITOR;
 		if (ieee80211_is_action(hdr->frame_control)) {
 			mgmt = (struct ieee80211_mgmt *)hdr;
 			if (mgmt->u.action.category != WLAN_CATEGORY_MESH_PLINK)
 				return RX_DROP_MONITOR;
 			return RX_CONTINUE;
 		}
 		if (ieee80211_is_probe_req(hdr->frame_control) ||
 		    ieee80211_is_probe_resp(hdr->frame_control) ||
 		    ieee80211_is_beacon(hdr->frame_control))
 			return RX_CONTINUE;
 		return RX_DROP_MONITOR;
 	}
 #define msh_h_get(h, l) ((struct ieee80211s_hdr *) ((u8 *)h + l))
 	if (ieee80211_is_data(hdr->frame_control) &&
 	    is_multicast_ether_addr(hdr->addr1) &&
 	    mesh_rmc_check(hdr->addr3, msh_h_get(hdr, hdrlen), rx->sdata))
 		return RX_DROP_MONITOR;
 #undef msh_h_get
 	return RX_CONTINUE;
 }
 #define SEQ_MODULO 0x1000
 #define SEQ_MASK   0xfff
 static inline int seq_less(u16 sq1, u16 sq2)
 {
 	return ((sq1 - sq2) & SEQ_MASK) > (SEQ_MODULO >> 1);
 }
 static inline u16 seq_inc(u16 sq)
 {
 	return (sq + 1) & SEQ_MASK;
 }
 static inline u16 seq_sub(u16 sq1, u16 sq2)
 {
 	return (sq1 - sq2) & SEQ_MASK;
 }
 static void ieee80211_release_reorder_frame(struct ieee80211_hw *hw,
 					    struct tid_ampdu_rx *tid_agg_rx,
 					    int index,
 					    struct sk_buff_head *frames)
 {
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_rate *rate = NULL;
 	struct sk_buff *skb = tid_agg_rx->reorder_buf[index];
 	struct ieee80211_rx_status *status;
 	if (!skb)
 		goto no_frame;
 	status = IEEE80211_SKB_RXCB(skb);
 	/* release the reordered frames to stack */
 	sband = hw->wiphy->bands[status->band];
 	if (!(status->flag & RX_FLAG_HT))
 		rate = &sband->bitrates[status->rate_idx];
 	tid_agg_rx->stored_mpdu_num--;
 	tid_agg_rx->reorder_buf[index] = NULL;
 	__skb_queue_tail(frames, skb);
 no_frame:
 	tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
 }
 static void ieee80211_release_reorder_frames(struct ieee80211_hw *hw,
 					     struct tid_ampdu_rx *tid_agg_rx,
 					     u16 head_seq_num,
 					     struct sk_buff_head *frames)
 {
 	int index;
 	while (seq_less(tid_agg_rx->head_seq_num, head_seq_num)) {
 		index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
 							tid_agg_rx->buf_size;
 		ieee80211_release_reorder_frame(hw, tid_agg_rx, index, frames);
 	}
 }
 /*
  * Timeout (in jiffies) for skb's that are waiting in the RX reorder buffer. If
  * the skb was added to the buffer longer than this time ago, the earlier
  * frames that have not yet been received are assumed to be lost and the skb
  * can be released for processing. This may also release other skb's from the
  * reorder buffer if there are no additional gaps between the frames.
  */
 #define HT_RX_REORDER_BUF_TIMEOUT (HZ / 10)
 /*
  * As this function belongs to the RX path it must be under
  * rcu_read_lock protection. It returns false if the frame
  * can be processed immediately, true if it was consumed.
  */
 static bool ieee80211_sta_manage_reorder_buf(struct ieee80211_hw *hw,
 					     struct tid_ampdu_rx *tid_agg_rx,
 					     struct sk_buff *skb,
 					     struct sk_buff_head *frames)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	u16 sc = le16_to_cpu(hdr->seq_ctrl);
 	u16 mpdu_seq_num = (sc & IEEE80211_SCTL_SEQ) >> 4;
 	u16 head_seq_num, buf_size;
 	int index;
 	buf_size = tid_agg_rx->buf_size;
 	head_seq_num = tid_agg_rx->head_seq_num;
 	/* frame with out of date sequence number */
 	if (seq_less(mpdu_seq_num, head_seq_num)) {
 		dev_kfree_skb(skb);
 		return true;
 	}
 	/*
 	 * If frame the sequence number exceeds our buffering window
 	 * size release some previous frames to make room for this one.
 	 */
 	if (!seq_less(mpdu_seq_num, head_seq_num + buf_size)) {
 		head_seq_num = seq_inc(seq_sub(mpdu_seq_num, buf_size));
 		/* release stored frames up to new head to stack */
 		ieee80211_release_reorder_frames(hw, tid_agg_rx, head_seq_num,
 						 frames);
 	}
 	/* Now the new frame is always in the range of the reordering buffer */
 	index = seq_sub(mpdu_seq_num, tid_agg_rx->ssn) % tid_agg_rx->buf_size;
 	/* check if we already stored this frame */
 	if (tid_agg_rx->reorder_buf[index]) {
 		dev_kfree_skb(skb);
 		return true;
 	}
 	/*
 	 * If the current MPDU is in the right order and nothing else
 	 * is stored we can process it directly, no need to buffer it.
 	 */
 	if (mpdu_seq_num == tid_agg_rx->head_seq_num &&
 	    tid_agg_rx->stored_mpdu_num == 0) {
 		tid_agg_rx->head_seq_num = seq_inc(tid_agg_rx->head_seq_num);
 		return false;
 	}
 	/* put the frame in the reordering buffer */
 	tid_agg_rx->reorder_buf[index] = skb;
 	tid_agg_rx->reorder_time[index] = jiffies;
 	tid_agg_rx->stored_mpdu_num++;
 	/* release the buffer until next missing frame */
 	index = seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
 						tid_agg_rx->buf_size;
 	if (!tid_agg_rx->reorder_buf[index] &&
 	    tid_agg_rx->stored_mpdu_num > 1) {
 		/*
 		 * No buffers ready to be released, but check whether any
 		 * frames in the reorder buffer have timed out.
 		 */
 		int j;
 		int skipped = 1;
 		for (j = (index + 1) % tid_agg_rx->buf_size; j != index;
 		     j = (j + 1) % tid_agg_rx->buf_size) {
 			if (!tid_agg_rx->reorder_buf[j]) {
 				skipped++;
 				continue;
 			}
 			if (!time_after(jiffies, tid_agg_rx->reorder_time[j] +
 					HT_RX_REORDER_BUF_TIMEOUT))
 				break;
 #ifdef CONFIG_MAC80211_HT_DEBUG
 			if (net_ratelimit())
 				printk(KERN_DEBUG "%s: release an RX reorder "
 				       "frame due to timeout on earlier "
 				       "frames\n",
 				       wiphy_name(hw->wiphy));
 #endif
 			ieee80211_release_reorder_frame(hw, tid_agg_rx,
 							j, frames);
 			/*
 			 * Increment the head seq# also for the skipped slots.
 			 */
 			tid_agg_rx->head_seq_num =
 				(tid_agg_rx->head_seq_num + skipped) & SEQ_MASK;
 			skipped = 0;
 		}
 	} else while (tid_agg_rx->reorder_buf[index]) {
 		ieee80211_release_reorder_frame(hw, tid_agg_rx, index, frames);
 		index =	seq_sub(tid_agg_rx->head_seq_num, tid_agg_rx->ssn) %
 							tid_agg_rx->buf_size;
 	}
 	return true;
 }
 /*
  * Reorder MPDUs from A-MPDUs, keeping them on a buffer. Returns
  * true if the MPDU was buffered, false if it should be processed.
  */
 static void ieee80211_rx_reorder_ampdu(struct ieee80211_rx_data *rx,
 				       struct sk_buff_head *frames)
 {
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_local *local = rx->local;
 	struct ieee80211_hw *hw = &local->hw;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 	struct sta_info *sta = rx->sta;
 	struct tid_ampdu_rx *tid_agg_rx;
 	u16 sc;
 	int tid;
 	if (!ieee80211_is_data_qos(hdr->frame_control))
 		goto dont_reorder;
 	/*
 	 * filter the QoS data rx stream according to
 	 * STA/TID and check if this STA/TID is on aggregation
 	 */
 	if (!sta)
 		goto dont_reorder;
 	tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK;
 	tid_agg_rx = rcu_dereference(sta->ampdu_mlme.tid_rx[tid]);
 	if (!tid_agg_rx)
 		goto dont_reorder;
 	/* qos null data frames are excluded */
 	if (unlikely(hdr->frame_control & cpu_to_le16(IEEE80211_STYPE_NULLFUNC)))
 		goto dont_reorder;
 	/* new, potentially un-ordered, ampdu frame - process it */
 	/* reset session timer */
 	if (tid_agg_rx->timeout)
 		mod_timer(&tid_agg_rx->session_timer,
 			  TU_TO_EXP_TIME(tid_agg_rx->timeout));
 	/* if this mpdu is fragmented - terminate rx aggregation session */
 	sc = le16_to_cpu(hdr->seq_ctrl);
 	if (sc & IEEE80211_SCTL_FRAG) {
 		skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
 		skb_queue_tail(&rx->sdata->skb_queue, skb);
 		ieee80211_queue_work(&local->hw, &rx->sdata->work);
 		return;
 	}
 	/*
 	 * No locking needed -- we will only ever process one
 	 * RX packet at a time, and thus own tid_agg_rx. All
 	 * other code manipulating it needs to (and does) make
 	 * sure that we cannot get to it any more before doing
 	 * anything with it.
 	 */
 	if (ieee80211_sta_manage_reorder_buf(hw, tid_agg_rx, skb, frames))
 		return;
  dont_reorder:
 	__skb_queue_tail(frames, skb);
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_check(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	/* Drop duplicate 802.11 retransmissions (IEEE 802.11 Chap. 9.2.9) */
 	if (rx->sta && !is_multicast_ether_addr(hdr->addr1)) {
 		if (unlikely(ieee80211_has_retry(hdr->frame_control) &&
 			     rx->sta->last_seq_ctrl[rx->queue] ==
 			     hdr->seq_ctrl)) {
 			if (rx->flags & IEEE80211_RX_RA_MATCH) {
 				rx->local->dot11FrameDuplicateCount++;
 				rx->sta->num_duplicates++;
 			}
 			return RX_DROP_MONITOR;
 		} else
 			rx->sta->last_seq_ctrl[rx->queue] = hdr->seq_ctrl;
 	}
 	if (unlikely(rx->skb->len < 16)) {
 		I802_DEBUG_INC(rx->local->rx_handlers_drop_short);
 		return RX_DROP_MONITOR;
 	}
 	/* Drop disallowed frame classes based on STA auth/assoc state;
 	 * IEEE 802.11, Chap 5.5.
 	 *
 	 * mac80211 filters only based on association state, i.e. it drops
 	 * Class 3 frames from not associated stations. hostapd sends
 	 * deauth/disassoc frames when needed. In addition, hostapd is
 	 * responsible for filtering on both auth and assoc states.
 	 */
 	if (ieee80211_vif_is_mesh(&rx->sdata->vif))
 		return ieee80211_rx_mesh_check(rx);
 	if (unlikely((ieee80211_is_data(hdr->frame_control) ||
 		      ieee80211_is_pspoll(hdr->frame_control)) &&
 		     rx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 		     (!rx->sta || !test_sta_flags(rx->sta, WLAN_STA_ASSOC)))) {
 		if ((!ieee80211_has_fromds(hdr->frame_control) &&
 		     !ieee80211_has_tods(hdr->frame_control) &&
 		     ieee80211_is_data(hdr->frame_control)) ||
 		    !(rx->flags & IEEE80211_RX_RA_MATCH)) {
 			/* Drop IBSS frames and frames for other hosts
 			 * silently. */
 			return RX_DROP_MONITOR;
 		}
 		return RX_DROP_MONITOR;
 	}
 	return RX_CONTINUE;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_decrypt(struct ieee80211_rx_data *rx)
 {
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	int keyidx;
 	int hdrlen;
 	ieee80211_rx_result result = RX_DROP_UNUSABLE;
 	struct ieee80211_key *stakey = NULL;
 	int mmie_keyidx = -1;
 	__le16 fc;
 	/*
 	 * Key selection 101
 	 *
 	 * There are four types of keys:
 	 *  - GTK (group keys)
 	 *  - IGTK (group keys for management frames)
 	 *  - PTK (pairwise keys)
 	 *  - STK (station-to-station pairwise keys)
 	 *
 	 * When selecting a key, we have to distinguish between multicast
 	 * (including broadcast) and unicast frames, the latter can only
 	 * use PTKs and STKs while the former always use GTKs and IGTKs.
 	 * Unless, of course, actual WEP keys ("pre-RSNA") are used, then
 	 * unicast frames can also use key indices like GTKs. Hence, if we
 	 * don't have a PTK/STK we check the key index for a WEP key.
 	 *
 	 * Note that in a regular BSS, multicast frames are sent by the
 	 * AP only, associated stations unicast the frame to the AP first
 	 * which then multicasts it on their behalf.
 	 *
 	 * There is also a slight problem in IBSS mode: GTKs are negotiated
 	 * with each station, that is something we don't currently handle.
 	 * The spec seems to expect that one negotiates the same key with
 	 * every station but there's no such requirement; VLANs could be
 	 * possible.
 	 */
 	/*
 	 * No point in finding a key and decrypting if the frame is neither
 	 * addressed to us nor a multicast frame.
 	 */
 	if (!(rx->flags & IEEE80211_RX_RA_MATCH))
 		return RX_CONTINUE;
 	/* start without a key */
 	rx->key = NULL;
 	if (rx->sta)
 		stakey = rcu_dereference(rx->sta->key);
 	fc = hdr->frame_control;
 	if (!ieee80211_has_protected(fc))
 		mmie_keyidx = ieee80211_get_mmie_keyidx(rx->skb);
 	if (!is_multicast_ether_addr(hdr->addr1) && stakey) {
 		rx->key = stakey;
 		/* Skip decryption if the frame is not protected. */
 		if (!ieee80211_has_protected(fc))
 			return RX_CONTINUE;
 	} else if (mmie_keyidx >= 0) {
 		/* Broadcast/multicast robust management frame / BIP */
 		if ((status->flag & RX_FLAG_DECRYPTED) &&
 		    (status->flag & RX_FLAG_IV_STRIPPED))
 			return RX_CONTINUE;
 		if (mmie_keyidx < NUM_DEFAULT_KEYS ||
 		    mmie_keyidx >= NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
 			return RX_DROP_MONITOR; /* unexpected BIP keyidx */
 		rx->key = rcu_dereference(rx->sdata->keys[mmie_keyidx]);
 	} else if (!ieee80211_has_protected(fc)) {
 		/*
 		 * The frame was not protected, so skip decryption. However, we
 		 * need to set rx->key if there is a key that could have been
 		 * used so that the frame may be dropped if encryption would
 		 * have been expected.
 		 */
 		struct ieee80211_key *key = NULL;
 		if (ieee80211_is_mgmt(fc) &&
 		    is_multicast_ether_addr(hdr->addr1) &&
 		    (key = rcu_dereference(rx->sdata->default_mgmt_key)))
 			rx->key = key;
 		else if ((key = rcu_dereference(rx->sdata->default_key)))
 			rx->key = key;
 		return RX_CONTINUE;
 	} else {
 		u8 keyid;
 		/*
 		 * The device doesn't give us the IV so we won't be
 		 * able to look up the key. That's ok though, we
 		 * don't need to decrypt the frame, we just won't
 		 * be able to keep statistics accurate.
 		 * Except for key threshold notifications, should
 		 * we somehow allow the driver to tell us which key
 		 * the hardware used if this flag is set?
 		 */
 		if ((status->flag & RX_FLAG_DECRYPTED) &&
 		    (status->flag & RX_FLAG_IV_STRIPPED))
 			return RX_CONTINUE;
 		hdrlen = ieee80211_hdrlen(fc);
 		if (rx->skb->len < 8 + hdrlen)
 			return RX_DROP_UNUSABLE; /* TODO: count this? */
 		/*
 		 * no need to call ieee80211_wep_get_keyidx,
 		 * it verifies a bunch of things we've done already
 		 */
 		skb_copy_bits(rx->skb, hdrlen + 3, &keyid, 1);
 		keyidx = keyid >> 6;
 		rx->key = rcu_dereference(rx->sdata->keys[keyidx]);
 		/*
 		 * RSNA-protected unicast frames should always be sent with
 		 * pairwise or station-to-station keys, but for WEP we allow
 		 * using a key index as well.
 		 */
 		if (rx->key && rx->key->conf.alg != ALG_WEP &&
 		    !is_multicast_ether_addr(hdr->addr1))
 			rx->key = NULL;
 	}
 	if (rx->key) {
 		rx->key->tx_rx_count++;
 		/* TODO: add threshold stuff again */
 	} else {
 		return RX_DROP_MONITOR;
 	}
 	if (skb_linearize(rx->skb))
 		return RX_DROP_UNUSABLE;
 	/* the hdr variable is invalid now! */
 	switch (rx->key->conf.alg) {
 	case ALG_WEP:
 		/* Check for weak IVs if possible */
 		if (rx->sta && ieee80211_is_data(fc) &&
 		    (!(status->flag & RX_FLAG_IV_STRIPPED) ||
 		     !(status->flag & RX_FLAG_DECRYPTED)) &&
 		    ieee80211_wep_is_weak_iv(rx->skb, rx->key))
 			rx->sta->wep_weak_iv_count++;
 		result = ieee80211_crypto_wep_decrypt(rx);
 		break;
 	case ALG_TKIP:
 		result = ieee80211_crypto_tkip_decrypt(rx);
 		break;
 	case ALG_CCMP:
 		result = ieee80211_crypto_ccmp_decrypt(rx);
 		break;
 	case ALG_AES_CMAC:
 		result = ieee80211_crypto_aes_cmac_decrypt(rx);
 		break;
 	}
 	/* either the frame has been decrypted or will be dropped */
 	status->flag |= RX_FLAG_DECRYPTED;
 	return result;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_check_more_data(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_local *local;
 	struct ieee80211_hdr *hdr;
 	struct sk_buff *skb;
 	local = rx->local;
 	skb = rx->skb;
 	hdr = (struct ieee80211_hdr *) skb->data;
 	if (!local->pspolling)
 		return RX_CONTINUE;
 	if (!ieee80211_has_fromds(hdr->frame_control))
 		/* this is not from AP */
 		return RX_CONTINUE;
 	if (!ieee80211_is_data(hdr->frame_control))
 		return RX_CONTINUE;
 	if (!ieee80211_has_moredata(hdr->frame_control)) {
 		/* AP has no more frames buffered for us */
 		local->pspolling = false;
 		return RX_CONTINUE;
 	}
 	/* more data bit is set, let's request a new frame from the AP */
 	ieee80211_send_pspoll(local, rx->sdata);
 	return RX_CONTINUE;
 }
 static void ap_sta_ps_start(struct sta_info *sta)
 {
 	struct ieee80211_sub_if_data *sdata = sta->sdata;
 	struct ieee80211_local *local = sdata->local;
 	atomic_inc(&sdata->bss->num_sta_ps);
 	set_sta_flags(sta, WLAN_STA_PS_STA);
 	drv_sta_notify(local, sdata, STA_NOTIFY_SLEEP, &sta->sta);
 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
 	printk(KERN_DEBUG "%s: STA %pM aid %d enters power save mode\n",
 	       sdata->name, sta->sta.addr, sta->sta.aid);
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
 }
 static void ap_sta_ps_end(struct sta_info *sta)
 {
 	struct ieee80211_sub_if_data *sdata = sta->sdata;
 	atomic_dec(&sdata->bss->num_sta_ps);
 	clear_sta_flags(sta, WLAN_STA_PS_STA);
 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
 	printk(KERN_DEBUG "%s: STA %pM aid %d exits power save mode\n",
 	       sdata->name, sta->sta.addr, sta->sta.aid);
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
 	if (test_sta_flags(sta, WLAN_STA_PS_DRIVER)) {
 #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
 		printk(KERN_DEBUG "%s: STA %pM aid %d driver-ps-blocked\n",
 		       sdata->name, sta->sta.addr, sta->sta.aid);
 #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
 		return;
 	}
 	ieee80211_sta_ps_deliver_wakeup(sta);
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_sta_process(struct ieee80211_rx_data *rx)
 {
 	struct sta_info *sta = rx->sta;
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	if (!sta)
 		return RX_CONTINUE;
 	/*
 	 * Update last_rx only for IBSS packets which are for the current
 	 * BSSID to avoid keeping the current IBSS network alive in cases
 	 * where other STAs start using different BSSID.
 	 */
 	if (rx->sdata->vif.type == NL80211_IFTYPE_ADHOC) {
 		u8 *bssid = ieee80211_get_bssid(hdr, rx->skb->len,
 						NL80211_IFTYPE_ADHOC);
 		if (compare_ether_addr(bssid, rx->sdata->u.ibss.bssid) == 0)
 			sta->last_rx = jiffies;
 	} else if (!is_multicast_ether_addr(hdr->addr1)) {
 		/*
 		 * Mesh beacons will update last_rx when if they are found to
 		 * match the current local configuration when processed.
 		 */
 		sta->last_rx = jiffies;
 	}
 	if (!(rx->flags & IEEE80211_RX_RA_MATCH))
 		return RX_CONTINUE;
 	if (rx->sdata->vif.type == NL80211_IFTYPE_STATION)
 		ieee80211_sta_rx_notify(rx->sdata, hdr);
 	sta->rx_fragments++;
 	sta->rx_bytes += rx->skb->len;
 	sta->last_signal = status->signal;
 	/*
 	 * Change STA power saving mode only at the end of a frame
 	 * exchange sequence.
 	 */
 	if (!ieee80211_has_morefrags(hdr->frame_control) &&
 	    (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
 	     rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) {
 		if (test_sta_flags(sta, WLAN_STA_PS_STA)) {
 			/*
 			 * Ignore doze->wake transitions that are
 			 * indicated by non-data frames, the standard
 			 * is unclear here, but for example going to
 			 * PS mode and then scanning would cause a
 			 * doze->wake transition for the probe request,
 			 * and that is clearly undesirable.
 			 */
 			if (ieee80211_is_data(hdr->frame_control) &&
 			    !ieee80211_has_pm(hdr->frame_control))
 				ap_sta_ps_end(sta);
 		} else {
 			if (ieee80211_has_pm(hdr->frame_control))
 				ap_sta_ps_start(sta);
 		}
 	}
 	/*
 	 * Drop (qos-)data::nullfunc frames silently, since they
 	 * are used only to control station power saving mode.
 	 */
 	if (ieee80211_is_nullfunc(hdr->frame_control) ||
 	    ieee80211_is_qos_nullfunc(hdr->frame_control)) {
 		I802_DEBUG_INC(rx->local->rx_handlers_drop_nullfunc);
 		/*
 		 * If we receive a 4-addr nullfunc frame from a STA
 		 * that was not moved to a 4-addr STA vlan yet, drop
 		 * the frame to the monitor interface, to make sure
 		 * that hostapd sees it
 		 */
 		if (ieee80211_has_a4(hdr->frame_control) &&
 		    (rx->sdata->vif.type == NL80211_IFTYPE_AP ||
 		     (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
 		      !rx->sdata->u.vlan.sta)))
 			return RX_DROP_MONITOR;
 		/*
 		 * Update counter and free packet here to avoid
 		 * counting this as a dropped packed.
 		 */
 		sta->rx_packets++;
 		dev_kfree_skb(rx->skb);
 		return RX_QUEUED;
 	}
 	return RX_CONTINUE;
 } /* ieee80211_rx_h_sta_process */
 static inline struct ieee80211_fragment_entry *
 ieee80211_reassemble_add(struct ieee80211_sub_if_data *sdata,
 			 unsigned int frag, unsigned int seq, int rx_queue,
 			 struct sk_buff **skb)
 {
 	struct ieee80211_fragment_entry *entry;
 	int idx;
 	idx = sdata->fragment_next;
 	entry = &sdata->fragments[sdata->fragment_next++];
 	if (sdata->fragment_next >= IEEE80211_FRAGMENT_MAX)
 		sdata->fragment_next = 0;
 	if (!skb_queue_empty(&entry->skb_list)) {
 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
 		struct ieee80211_hdr *hdr =
 			(struct ieee80211_hdr *) entry->skb_list.next->data;
 		printk(KERN_DEBUG "%s: RX reassembly removed oldest "
 		       "fragment entry (idx=%d age=%lu seq=%d last_frag=%d "
 		       "addr1=%pM addr2=%pM\n",
 		       sdata->name, idx,
 		       jiffies - entry->first_frag_time, entry->seq,
 		       entry->last_frag, hdr->addr1, hdr->addr2);
 #endif
 		__skb_queue_purge(&entry->skb_list);
 	}
 	__skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
 	*skb = NULL;
 	entry->first_frag_time = jiffies;
 	entry->seq = seq;
 	entry->rx_queue = rx_queue;
 	entry->last_frag = frag;
 	entry->ccmp = 0;
 	entry->extra_len = 0;
 	return entry;
 }
 static inline struct ieee80211_fragment_entry *
 ieee80211_reassemble_find(struct ieee80211_sub_if_data *sdata,
 			  unsigned int frag, unsigned int seq,
 			  int rx_queue, struct ieee80211_hdr *hdr)
 {
 	struct ieee80211_fragment_entry *entry;
 	int i, idx;
 	idx = sdata->fragment_next;
 	for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++) {
 		struct ieee80211_hdr *f_hdr;
 		idx--;
 		if (idx < 0)
 			idx = IEEE80211_FRAGMENT_MAX - 1;
 		entry = &sdata->fragments[idx];
 		if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
 		    entry->rx_queue != rx_queue ||
 		    entry->last_frag + 1 != frag)
 			continue;
 		f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
 		/*
 		 * Check ftype and addresses are equal, else check next fragment
 		 */
 		if (((hdr->frame_control ^ f_hdr->frame_control) &
 		     cpu_to_le16(IEEE80211_FCTL_FTYPE)) ||
 		    compare_ether_addr(hdr->addr1, f_hdr->addr1) != 0 ||
 		    compare_ether_addr(hdr->addr2, f_hdr->addr2) != 0)
 			continue;
 		if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
 			__skb_queue_purge(&entry->skb_list);
 			continue;
 		}
 		return entry;
 	}
 	return NULL;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_defragment(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr;
 	u16 sc;
 	__le16 fc;
 	unsigned int frag, seq;
 	struct ieee80211_fragment_entry *entry;
 	struct sk_buff *skb;
 	hdr = (struct ieee80211_hdr *)rx->skb->data;
 	fc = hdr->frame_control;
 	sc = le16_to_cpu(hdr->seq_ctrl);
 	frag = sc & IEEE80211_SCTL_FRAG;
 	if (likely((!ieee80211_has_morefrags(fc) && frag == 0) ||
 		   (rx->skb)->len < 24 ||
 		   is_multicast_ether_addr(hdr->addr1))) {
 		/* not fragmented */
 		goto out;
 	}
 	I802_DEBUG_INC(rx->local->rx_handlers_fragments);
 	if (skb_linearize(rx->skb))
 		return RX_DROP_UNUSABLE;
 	/*
 	 *  skb_linearize() might change the skb->data and
 	 *  previously cached variables (in this case, hdr) need to
 	 *  be refreshed with the new data.
 	 */
 	hdr = (struct ieee80211_hdr *)rx->skb->data;
 	seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
 	if (frag == 0) {
 		/* This is the first fragment of a new frame. */
 		entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
 						 rx->queue, &(rx->skb));
 		if (rx->key && rx->key->conf.alg == ALG_CCMP &&
 		    ieee80211_has_protected(fc)) {
 			int queue = ieee80211_is_mgmt(fc) ?
 				NUM_RX_DATA_QUEUES : rx->queue;
 			/* Store CCMP PN so that we can verify that the next
 			 * fragment has a sequential PN value. */
 			entry->ccmp = 1;
 			memcpy(entry->last_pn,
 			       rx->key->u.ccmp.rx_pn[queue],
 			       CCMP_PN_LEN);
 		}
 		return RX_QUEUED;
 	}
 	/* This is a fragment for a frame that should already be pending in
 	 * fragment cache. Add this fragment to the end of the pending entry.
 	 */
 	entry = ieee80211_reassemble_find(rx->sdata, frag, seq, rx->queue, hdr);
 	if (!entry) {
 		I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
 		return RX_DROP_MONITOR;
 	}
 	/* Verify that MPDUs within one MSDU have sequential PN values.
 	 * (IEEE 802.11i, 8.3.3.4.5) */
 	if (entry->ccmp) {
 		int i;
 		u8 pn[CCMP_PN_LEN], *rpn;
 		int queue;
 		if (!rx->key || rx->key->conf.alg != ALG_CCMP)
 			return RX_DROP_UNUSABLE;
 		memcpy(pn, entry->last_pn, CCMP_PN_LEN);
 		for (i = CCMP_PN_LEN - 1; i >= 0; i--) {
 			pn[i]++;
 			if (pn[i])
 				break;
 		}
 		queue = ieee80211_is_mgmt(fc) ?
 			NUM_RX_DATA_QUEUES : rx->queue;
 		rpn = rx->key->u.ccmp.rx_pn[queue];
 		if (memcmp(pn, rpn, CCMP_PN_LEN))
 			return RX_DROP_UNUSABLE;
 		memcpy(entry->last_pn, pn, CCMP_PN_LEN);
 	}
 	skb_pull(rx->skb, ieee80211_hdrlen(fc));
 	__skb_queue_tail(&entry->skb_list, rx->skb);
 	entry->last_frag = frag;
 	entry->extra_len += rx->skb->len;
 	if (ieee80211_has_morefrags(fc)) {
 		rx->skb = NULL;
 		return RX_QUEUED;
 	}
 	rx->skb = __skb_dequeue(&entry->skb_list);
 	if (skb_tailroom(rx->skb) < entry->extra_len) {
 		I802_DEBUG_INC(rx->local->rx_expand_skb_head2);
 		if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
 					      GFP_ATOMIC))) {
 			I802_DEBUG_INC(rx->local->rx_handlers_drop_defrag);
 			__skb_queue_purge(&entry->skb_list);
 			return RX_DROP_UNUSABLE;
 		}
 	}
 	while ((skb = __skb_dequeue(&entry->skb_list))) {
 		memcpy(skb_put(rx->skb, skb->len), skb->data, skb->len);
 		dev_kfree_skb(skb);
 	}
 	/* Complete frame has been reassembled - process it now */
 	rx->flags |= IEEE80211_RX_FRAGMENTED;
  out:
 	if (rx->sta)
 		rx->sta->rx_packets++;
 	if (is_multicast_ether_addr(hdr->addr1))
 		rx->local->dot11MulticastReceivedFrameCount++;
 	else
 		ieee80211_led_rx(rx->local);
 	return RX_CONTINUE;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_ps_poll(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	__le16 fc = ((struct ieee80211_hdr *)rx->skb->data)->frame_control;
 	if (likely(!rx->sta || !ieee80211_is_pspoll(fc) ||
 		   !(rx->flags & IEEE80211_RX_RA_MATCH)))
 		return RX_CONTINUE;
 	if ((sdata->vif.type != NL80211_IFTYPE_AP) &&
 	    (sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
 		return RX_DROP_UNUSABLE;
 	if (!test_sta_flags(rx->sta, WLAN_STA_PS_DRIVER))
 		ieee80211_sta_ps_deliver_poll_response(rx->sta);
 	else
 		set_sta_flags(rx->sta, WLAN_STA_PSPOLL);
 	/* Free PS Poll skb here instead of returning RX_DROP that would
 	 * count as an dropped frame. */
 	dev_kfree_skb(rx->skb);
 	return RX_QUEUED;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_remove_qos_control(struct ieee80211_rx_data *rx)
 {
 	u8 *data = rx->skb->data;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)data;
 	if (!ieee80211_is_data_qos(hdr->frame_control))
 		return RX_CONTINUE;
 	/* remove the qos control field, update frame type and meta-data */
 	memmove(data + IEEE80211_QOS_CTL_LEN, data,
 		ieee80211_hdrlen(hdr->frame_control) - IEEE80211_QOS_CTL_LEN);
 	hdr = (struct ieee80211_hdr *)skb_pull(rx->skb, IEEE80211_QOS_CTL_LEN);
 	/* change frame type to non QOS */
 	hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
 	return RX_CONTINUE;
 }
 static int
 ieee80211_802_1x_port_control(struct ieee80211_rx_data *rx)
 {
 	if (unlikely(!rx->sta ||
 	    !test_sta_flags(rx->sta, WLAN_STA_AUTHORIZED)))
 		return -EACCES;
 	return 0;
 }
 static int
 ieee80211_drop_unencrypted(struct ieee80211_rx_data *rx, __le16 fc)
 {
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	/*
 	 * Pass through unencrypted frames if the hardware has
 	 * decrypted them already.
 	 */
 	if (status->flag & RX_FLAG_DECRYPTED)
 		return 0;
 	/* Drop unencrypted frames if key is set. */
 	if (unlikely(!ieee80211_has_protected(fc) &&
 		     !ieee80211_is_nullfunc(fc) &&
 		     ieee80211_is_data(fc) &&
 		     (rx->key || rx->sdata->drop_unencrypted)))
 		return -EACCES;
 	return 0;
 }
 static int
 ieee80211_drop_unencrypted_mgmt(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb);
 	__le16 fc = hdr->frame_control;
 	/*
 	 * Pass through unencrypted frames if the hardware has
 	 * decrypted them already.
 	 */
 	if (status->flag & RX_FLAG_DECRYPTED)
 		return 0;
 	if (rx->sta && test_sta_flags(rx->sta, WLAN_STA_MFP)) {
 		if (unlikely(!ieee80211_has_protected(fc) &&
 			     ieee80211_is_unicast_robust_mgmt_frame(rx->skb) &&
 			     rx->key))
 			return -EACCES;
 		/* BIP does not use Protected field, so need to check MMIE */
 		if (unlikely(ieee80211_is_multicast_robust_mgmt_frame(rx->skb) &&
 			     ieee80211_get_mmie_keyidx(rx->skb) < 0))
 			return -EACCES;
 		/*
 		 * When using MFP, Action frames are not allowed prior to
 		 * having configured keys.
 		 */
 		if (unlikely(ieee80211_is_action(fc) && !rx->key &&
 			     ieee80211_is_robust_mgmt_frame(
 				     (struct ieee80211_hdr *) rx->skb->data)))
 			return -EACCES;
 	}
 	return 0;
 }
 static int
 __ieee80211_data_to_8023(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	if (ieee80211_has_a4(hdr->frame_control) &&
 	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta)
 		return -1;
 	if (is_multicast_ether_addr(hdr->addr1) &&
 	    ((sdata->vif.type == NL80211_IFTYPE_AP_VLAN && sdata->u.vlan.sta) ||
 	     (sdata->vif.type == NL80211_IFTYPE_STATION && sdata->u.mgd.use_4addr)))
 		return -1;
 	return ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type);
 }
 /*
  * requires that rx->skb is a frame with ethernet header
  */
 static bool ieee80211_frame_allowed(struct ieee80211_rx_data *rx, __le16 fc)
 {
 	static const u8 pae_group_addr[ETH_ALEN] __aligned(2)
 		= { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x03 };
 	struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
 	/*
 	 * Allow EAPOL frames to us/the PAE group address regardless
 	 * of whether the frame was encrypted or not.
 	 */
 	if (ehdr->h_proto == htons(ETH_P_PAE) &&
 	    (compare_ether_addr(ehdr->h_dest, rx->sdata->vif.addr) == 0 ||
 	     compare_ether_addr(ehdr->h_dest, pae_group_addr) == 0))
 		return true;
 	if (ieee80211_802_1x_port_control(rx) ||
 	    ieee80211_drop_unencrypted(rx, fc))
 		return false;
 	return true;
 }
 /*
  * requires that rx->skb is a frame with ethernet header
  */
 static void
 ieee80211_deliver_skb(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	struct net_device *dev = sdata->dev;
 	struct sk_buff *skb, *xmit_skb;
 	struct ethhdr *ehdr = (struct ethhdr *) rx->skb->data;
 	struct sta_info *dsta;
 	skb = rx->skb;
 	xmit_skb = NULL;
 	if ((sdata->vif.type == NL80211_IFTYPE_AP ||
 	     sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
 	    !(sdata->flags & IEEE80211_SDATA_DONT_BRIDGE_PACKETS) &&
 	    (rx->flags & IEEE80211_RX_RA_MATCH) &&
 	    (sdata->vif.type != NL80211_IFTYPE_AP_VLAN || !sdata->u.vlan.sta)) {
 		if (is_multicast_ether_addr(ehdr->h_dest)) {
 			/*
 			 * send multicast frames both to higher layers in
 			 * local net stack and back to the wireless medium
 			 */
 			xmit_skb = skb_copy(skb, GFP_ATOMIC);
 			if (!xmit_skb && net_ratelimit())
 				printk(KERN_DEBUG "%s: failed to clone "
 				       "multicast frame\n", dev->name);
 		} else {
 			dsta = sta_info_get(sdata, skb->data);
 			if (dsta) {
 				/*
 				 * The destination station is associated to
 				 * this AP (in this VLAN), so send the frame
 				 * directly to it and do not pass it to local
 				 * net stack.
 				 */
 				xmit_skb = skb;
 				skb = NULL;
 			}
 		}
 	}
 	if (skb) {
 		int align __maybe_unused;
 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 		/*
 		 * 'align' will only take the values 0 or 2 here
 		 * since all frames are required to be aligned
 		 * to 2-byte boundaries when being passed to
 		 * mac80211. That also explains the __skb_push()
 		 * below.
 		 */
 		align = ((unsigned long)(skb->data + sizeof(struct ethhdr))) & 3;
 		if (align) {
 			if (WARN_ON(skb_headroom(skb) < 3)) {
 				dev_kfree_skb(skb);
 				skb = NULL;
 			} else {
 				u8 *data = skb->data;
 				size_t len = skb_headlen(skb);
 				skb->data -= align;
 				memmove(skb->data, data, len);
 				skb_set_tail_pointer(skb, len);
 			}
 		}
 #endif
 		if (skb) {
 			/* deliver to local stack */
 			skb->protocol = eth_type_trans(skb, dev);
 			memset(skb->cb, 0, sizeof(skb->cb));
 			netif_receive_skb(skb);
 		}
 	}
 	if (xmit_skb) {
 		/* send to wireless media */
 		xmit_skb->protocol = htons(ETH_P_802_3);
 		skb_reset_network_header(xmit_skb);
 		skb_reset_mac_header(xmit_skb);
 		dev_queue_xmit(xmit_skb);
 	}
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_amsdu(struct ieee80211_rx_data *rx)
 {
 	struct net_device *dev = rx->sdata->dev;
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
 	__le16 fc = hdr->frame_control;
 	struct sk_buff_head frame_list;
 	if (unlikely(!ieee80211_is_data(fc)))
 		return RX_CONTINUE;
 	if (unlikely(!ieee80211_is_data_present(fc)))
 		return RX_DROP_MONITOR;
 	if (!(rx->flags & IEEE80211_RX_AMSDU))
 		return RX_CONTINUE;
 	if (ieee80211_has_a4(hdr->frame_control) &&
 	    rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
 	    !rx->sdata->u.vlan.sta)
 		return RX_DROP_UNUSABLE;
 	if (is_multicast_ether_addr(hdr->addr1) &&
 	    ((rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
 	      rx->sdata->u.vlan.sta) ||
 	     (rx->sdata->vif.type == NL80211_IFTYPE_STATION &&
 	      rx->sdata->u.mgd.use_4addr)))
 		return RX_DROP_UNUSABLE;
 	skb->dev = dev;
 	__skb_queue_head_init(&frame_list);
 	if (skb_linearize(skb))
 		return RX_DROP_UNUSABLE;
 	ieee80211_amsdu_to_8023s(skb, &frame_list, dev->dev_addr,
 				 rx->sdata->vif.type,
 				 rx->local->hw.extra_tx_headroom);
 	while (!skb_queue_empty(&frame_list)) {
 		rx->skb = __skb_dequeue(&frame_list);
 		if (!ieee80211_frame_allowed(rx, fc)) {
 			dev_kfree_skb(rx->skb);
 			continue;
 		}
 		dev->stats.rx_packets++;
 		dev->stats.rx_bytes += rx->skb->len;
 		ieee80211_deliver_skb(rx);
 	}
 	return RX_QUEUED;
 }
 #ifdef CONFIG_MAC80211_MESH
 static ieee80211_rx_result
 ieee80211_rx_h_mesh_fwding(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_hdr *hdr;
 	struct ieee80211s_hdr *mesh_hdr;
 	unsigned int hdrlen;
 	struct sk_buff *skb = rx->skb, *fwd_skb;
 	struct ieee80211_local *local = rx->local;
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	hdr = (struct ieee80211_hdr *) skb->data;
 	hdrlen = ieee80211_hdrlen(hdr->frame_control);
 	mesh_hdr = (struct ieee80211s_hdr *) (skb->data + hdrlen);
 	if (!ieee80211_is_data(hdr->frame_control))
 		return RX_CONTINUE;
 	if (!mesh_hdr->ttl)
 		/* illegal frame */
 		return RX_DROP_MONITOR;
 	if (mesh_hdr->flags & MESH_FLAGS_AE) {
 		struct mesh_path *mppath;
 		char *proxied_addr;
 		char *mpp_addr;
 		if (is_multicast_ether_addr(hdr->addr1)) {
 			mpp_addr = hdr->addr3;
 			proxied_addr = mesh_hdr->eaddr1;
 		} else {
 			mpp_addr = hdr->addr4;
 			proxied_addr = mesh_hdr->eaddr2;
 		}
 		rcu_read_lock();
 		mppath = mpp_path_lookup(proxied_addr, sdata);
 		if (!mppath) {
 			mpp_path_add(proxied_addr, mpp_addr, sdata);
 		} else {
 			spin_lock_bh(&mppath->state_lock);
 			if (compare_ether_addr(mppath->mpp, mpp_addr) != 0)
 				memcpy(mppath->mpp, mpp_addr, ETH_ALEN);
 			spin_unlock_bh(&mppath->state_lock);
 		}
 		rcu_read_unlock();
 	}
 	/* Frame has reached destination.  Don't forward */
 	if (!is_multicast_ether_addr(hdr->addr1) &&
 	    compare_ether_addr(sdata->vif.addr, hdr->addr3) == 0)
 		return RX_CONTINUE;
 	mesh_hdr->ttl--;
 	if (rx->flags & IEEE80211_RX_RA_MATCH) {
 		if (!mesh_hdr->ttl)
 			IEEE80211_IFSTA_MESH_CTR_INC(&rx->sdata->u.mesh,
 						     dropped_frames_ttl);
 		else {
 			struct ieee80211_hdr *fwd_hdr;
 			struct ieee80211_tx_info *info;
 			fwd_skb = skb_copy(skb, GFP_ATOMIC);
 			if (!fwd_skb && net_ratelimit())
 				printk(KERN_DEBUG "%s: failed to clone mesh frame\n",
 						   sdata->name);
 			fwd_hdr =  (struct ieee80211_hdr *) fwd_skb->data;
 			memcpy(fwd_hdr->addr2, sdata->vif.addr, ETH_ALEN);
 			info = IEEE80211_SKB_CB(fwd_skb);
 			memset(info, 0, sizeof(*info));
 			info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
 			info->control.vif = &rx->sdata->vif;
 			skb_set_queue_mapping(skb,
 				ieee80211_select_queue(rx->sdata, fwd_skb));
 			ieee80211_set_qos_hdr(local, skb);
 			if (is_multicast_ether_addr(fwd_hdr->addr1))
 				IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
 								fwded_mcast);
 			else {
 				int err;
 				/*
 				 * Save TA to addr1 to send TA a path error if a
 				 * suitable next hop is not found
 				 */
 				memcpy(fwd_hdr->addr1, fwd_hdr->addr2,
 						ETH_ALEN);
 				err = mesh_nexthop_lookup(fwd_skb, sdata);
 				/* Failed to immediately resolve next hop:
 				 * fwded frame was dropped or will be added
 				 * later to the pending skb queue.  */
 				if (err)
 					return RX_DROP_MONITOR;
 				IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
 								fwded_unicast);
 			}
 			IEEE80211_IFSTA_MESH_CTR_INC(&sdata->u.mesh,
 						     fwded_frames);
 			ieee80211_add_pending_skb(local, fwd_skb);
 		}
 	}
 	if (is_multicast_ether_addr(hdr->addr1) ||
 	    sdata->dev->flags & IFF_PROMISC)
 		return RX_CONTINUE;
 	else
 		return RX_DROP_MONITOR;
 }
 #endif
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_data(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	struct ieee80211_local *local = rx->local;
 	struct net_device *dev = sdata->dev;
 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data;
 	__le16 fc = hdr->frame_control;
 	int err;
 	if (unlikely(!ieee80211_is_data(hdr->frame_control)))
 		return RX_CONTINUE;
 	if (unlikely(!ieee80211_is_data_present(hdr->frame_control)))
 		return RX_DROP_MONITOR;
 	/*
 	 * Allow the cooked monitor interface of an AP to see 4-addr frames so
 	 * that a 4-addr station can be detected and moved into a separate VLAN
 	 */
 	if (ieee80211_has_a4(hdr->frame_control) &&
 	    sdata->vif.type == NL80211_IFTYPE_AP)
 		return RX_DROP_MONITOR;
 	err = __ieee80211_data_to_8023(rx);
 	if (unlikely(err))
 		return RX_DROP_UNUSABLE;
 	if (!ieee80211_frame_allowed(rx, fc))
 		return RX_DROP_MONITOR;
 	rx->skb->dev = dev;
 	dev->stats.rx_packets++;
 	dev->stats.rx_bytes += rx->skb->len;
 	if (ieee80211_is_data(hdr->frame_control) &&
 	    !is_multicast_ether_addr(hdr->addr1) &&
 	    local->hw.conf.dynamic_ps_timeout > 0 && local->ps_sdata) {
 			mod_timer(&local->dynamic_ps_timer, jiffies +
 			 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
 	}
 	ieee80211_deliver_skb(rx);
 	return RX_QUEUED;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_ctrl(struct ieee80211_rx_data *rx, struct sk_buff_head *frames)
 {
 	struct ieee80211_local *local = rx->local;
 	struct ieee80211_hw *hw = &local->hw;
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_bar *bar = (struct ieee80211_bar *)skb->data;
 	struct tid_ampdu_rx *tid_agg_rx;
 	u16 start_seq_num;
 	u16 tid;
 	if (likely(!ieee80211_is_ctl(bar->frame_control)))
 		return RX_CONTINUE;
 	if (ieee80211_is_back_req(bar->frame_control)) {
 		struct {
 			__le16 control, start_seq_num;
 		} __packed bar_data;
 		if (!rx->sta)
 			return RX_DROP_MONITOR;
 		if (skb_copy_bits(skb, offsetof(struct ieee80211_bar, control),
 				  &bar_data, sizeof(bar_data)))
 			return RX_DROP_MONITOR;
 		tid = le16_to_cpu(bar_data.control) >> 12;
 		tid_agg_rx = rcu_dereference(rx->sta->ampdu_mlme.tid_rx[tid]);
 		if (!tid_agg_rx)
 			return RX_DROP_MONITOR;
 		start_seq_num = le16_to_cpu(bar_data.start_seq_num) >> 4;
 		/* reset session timer */
 		if (tid_agg_rx->timeout)
 			mod_timer(&tid_agg_rx->session_timer,
 				  TU_TO_EXP_TIME(tid_agg_rx->timeout));
 		/* release stored frames up to start of BAR */
 		ieee80211_release_reorder_frames(hw, tid_agg_rx, start_seq_num,
 						 frames);
 		kfree_skb(skb);
 		return RX_QUEUED;
 	}
 	/*
 	 * After this point, we only want management frames,
 	 * so we can drop all remaining control frames to
 	 * cooked monitor interfaces.
 	 */
 	return RX_DROP_MONITOR;
 }
 static void ieee80211_process_sa_query_req(struct ieee80211_sub_if_data *sdata,
 					   struct ieee80211_mgmt *mgmt,
 					   size_t len)
 {
 	struct ieee80211_local *local = sdata->local;
 	struct sk_buff *skb;
 	struct ieee80211_mgmt *resp;
 	if (compare_ether_addr(mgmt->da, sdata->vif.addr) != 0) {
 		/* Not to own unicast address */
 		return;
 	}
 	if (compare_ether_addr(mgmt->sa, sdata->u.mgd.bssid) != 0 ||
 	    compare_ether_addr(mgmt->bssid, sdata->u.mgd.bssid) != 0) {
 		/* Not from the current AP or not associated yet. */
 		return;
 	}
 	if (len < 24 + 1 + sizeof(resp->u.action.u.sa_query)) {
 		/* Too short SA Query request frame */
 		return;
 	}
 	skb = dev_alloc_skb(sizeof(*resp) + local->hw.extra_tx_headroom);
 	if (skb == NULL)
 		return;
 	skb_reserve(skb, local->hw.extra_tx_headroom);
 	resp = (struct ieee80211_mgmt *) skb_put(skb, 24);
 	memset(resp, 0, 24);
 	memcpy(resp->da, mgmt->sa, ETH_ALEN);
 	memcpy(resp->sa, sdata->vif.addr, ETH_ALEN);
 	memcpy(resp->bssid, sdata->u.mgd.bssid, ETH_ALEN);
 	resp->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 					  IEEE80211_STYPE_ACTION);
 	skb_put(skb, 1 + sizeof(resp->u.action.u.sa_query));
 	resp->u.action.category = WLAN_CATEGORY_SA_QUERY;
 	resp->u.action.u.sa_query.action = WLAN_ACTION_SA_QUERY_RESPONSE;
 	memcpy(resp->u.action.u.sa_query.trans_id,
 	       mgmt->u.action.u.sa_query.trans_id,
 	       WLAN_SA_QUERY_TR_ID_LEN);
 	ieee80211_tx_skb(sdata, skb);
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_action(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_local *local = rx->local;
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *) rx->skb->data;
 	struct sk_buff *nskb;
 	struct ieee80211_rx_status *status;
 	int len = rx->skb->len;
 	if (!ieee80211_is_action(mgmt->frame_control))
 		return RX_CONTINUE;
 	/* drop too small frames */
 	if (len < IEEE80211_MIN_ACTION_SIZE)
 		return RX_DROP_UNUSABLE;
 	if (!rx->sta && mgmt->u.action.category != WLAN_CATEGORY_PUBLIC)
 		return RX_DROP_UNUSABLE;
 	if (!(rx->flags & IEEE80211_RX_RA_MATCH))
 		return RX_DROP_UNUSABLE;
 	if (ieee80211_drop_unencrypted_mgmt(rx))
 		return RX_DROP_UNUSABLE;
 	switch (mgmt->u.action.category) {
 	case WLAN_CATEGORY_BACK:
 		/*
 		 * The aggregation code is not prepared to handle
 		 * anything but STA/AP due to the BSSID handling;
 		 * IBSS could work in the code but isn't supported
 		 * by drivers or the standard.
 		 */
 		if (sdata->vif.type != NL80211_IFTYPE_STATION &&
 		    sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
 		    sdata->vif.type != NL80211_IFTYPE_AP)
 			break;
 		/* verify action_code is present */
 		if (len < IEEE80211_MIN_ACTION_SIZE + 1)
 			break;
 		switch (mgmt->u.action.u.addba_req.action_code) {
 		case WLAN_ACTION_ADDBA_REQ:
 			if (len < (IEEE80211_MIN_ACTION_SIZE +
 				   sizeof(mgmt->u.action.u.addba_req)))
 				goto invalid;
 			break;
 		case WLAN_ACTION_ADDBA_RESP:
 			if (len < (IEEE80211_MIN_ACTION_SIZE +
 				   sizeof(mgmt->u.action.u.addba_resp)))
 				goto invalid;
 			break;
 		case WLAN_ACTION_DELBA:
 			if (len < (IEEE80211_MIN_ACTION_SIZE +
 				   sizeof(mgmt->u.action.u.delba)))
 				goto invalid;
 			break;
 		default:
 			goto invalid;
 		}
 		goto queue;
 	case WLAN_CATEGORY_SPECTRUM_MGMT:
 		if (local->hw.conf.channel->band != IEEE80211_BAND_5GHZ)
 			break;
 		if (sdata->vif.type != NL80211_IFTYPE_STATION)
 			break;
 		/* verify action_code is present */
 		if (len < IEEE80211_MIN_ACTION_SIZE + 1)
 			break;
 		switch (mgmt->u.action.u.measurement.action_code) {
 		case WLAN_ACTION_SPCT_MSR_REQ:
 			if (len < (IEEE80211_MIN_ACTION_SIZE +
 				   sizeof(mgmt->u.action.u.measurement)))
 				break;
 			ieee80211_process_measurement_req(sdata, mgmt, len);
 			goto handled;
 		case WLAN_ACTION_SPCT_CHL_SWITCH:
 			if (len < (IEEE80211_MIN_ACTION_SIZE +
 				   sizeof(mgmt->u.action.u.chan_switch)))
 				break;
 			if (sdata->vif.type != NL80211_IFTYPE_STATION)
 				break;
 			if (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN))
 				break;
 			goto queue;
 		}
 		break;
 	case WLAN_CATEGORY_SA_QUERY:
 		if (len < (IEEE80211_MIN_ACTION_SIZE +
 			   sizeof(mgmt->u.action.u.sa_query)))
 			break;
 		switch (mgmt->u.action.u.sa_query.action) {
 		case WLAN_ACTION_SA_QUERY_REQUEST:
 			if (sdata->vif.type != NL80211_IFTYPE_STATION)
 				break;
 			ieee80211_process_sa_query_req(sdata, mgmt, len);
 			goto handled;
 		}
 		break;
 	case WLAN_CATEGORY_MESH_PLINK:
 	case WLAN_CATEGORY_MESH_PATH_SEL:
 		if (!ieee80211_vif_is_mesh(&sdata->vif))
 			break;
 		goto queue;
 	}
  invalid:
 	/*
 	 * For AP mode, hostapd is responsible for handling any action
 	 * frames that we didn't handle, including returning unknown
 	 * ones. For all other modes we will return them to the sender,
 	 * setting the 0x80 bit in the action category, as required by
 	 * 802.11-2007 7.3.1.11.
 	 */
 	if (sdata->vif.type == NL80211_IFTYPE_AP ||
 	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 		return RX_DROP_MONITOR;
 	/*
 	 * Getting here means the kernel doesn't know how to handle
 	 * it, but maybe userspace does ... include returned frames
 	 * so userspace can register for those to know whether ones
 	 * it transmitted were processed or returned.
 	 */
 	status = IEEE80211_SKB_RXCB(rx->skb);
 	if (cfg80211_rx_action(rx->sdata->dev, status->freq,
 			       rx->skb->data, rx->skb->len,
 			       GFP_ATOMIC))
 		goto handled;
 	/* do not return rejected action frames */
 	if (mgmt->u.action.category & 0x80)
 		return RX_DROP_UNUSABLE;
 	nskb = skb_copy_expand(rx->skb, local->hw.extra_tx_headroom, 0,
 			       GFP_ATOMIC);
 	if (nskb) {
 		struct ieee80211_mgmt *nmgmt = (void *)nskb->data;
 		nmgmt->u.action.category |= 0x80;
 		memcpy(nmgmt->da, nmgmt->sa, ETH_ALEN);
 		memcpy(nmgmt->sa, rx->sdata->vif.addr, ETH_ALEN);
 		memset(nskb->cb, 0, sizeof(nskb->cb));
 		ieee80211_tx_skb(rx->sdata, nskb);
 	}
  handled:
 	if (rx->sta)
 		rx->sta->rx_packets++;
 	dev_kfree_skb(rx->skb);
 	return RX_QUEUED;
  queue:
 	rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
 	skb_queue_tail(&sdata->skb_queue, rx->skb);
 	ieee80211_queue_work(&local->hw, &sdata->work);
 	if (rx->sta)
 		rx->sta->rx_packets++;
 	return RX_QUEUED;
 }
 static ieee80211_rx_result debug_noinline
 ieee80211_rx_h_mgmt(struct ieee80211_rx_data *rx)
 {
 	struct ieee80211_sub_if_data *sdata = rx->sdata;
 	ieee80211_rx_result rxs;
 	struct ieee80211_mgmt *mgmt = (void *)rx->skb->data;
 	__le16 stype;
 	if (!(rx->flags & IEEE80211_RX_RA_MATCH))
 		return RX_DROP_MONITOR;
 	if (rx->skb->len < 24)
 		return RX_DROP_MONITOR;
 	if (ieee80211_drop_unencrypted_mgmt(rx))
 		return RX_DROP_UNUSABLE;
 	rxs = ieee80211_work_rx_mgmt(rx->sdata, rx->skb);
 	if (rxs != RX_CONTINUE)
 		return rxs;
 	stype = mgmt->frame_control & cpu_to_le16(IEEE80211_FCTL_STYPE);
 	if (!ieee80211_vif_is_mesh(&sdata->vif) &&
 	    sdata->vif.type != NL80211_IFTYPE_ADHOC &&
 	    sdata->vif.type != NL80211_IFTYPE_STATION)
 		return RX_DROP_MONITOR;
 	switch (stype) {
 	case cpu_to_le16(IEEE80211_STYPE_BEACON):
 	case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
 		/* process for all: mesh, mlme, ibss */
 		break;
 	case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
 	case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
 		/* process only for station */
 		if (sdata->vif.type != NL80211_IFTYPE_STATION)
 			return RX_DROP_MONITOR;
 		break;
 	case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
 	case cpu_to_le16(IEEE80211_STYPE_AUTH):
 		/* process only for ibss */
 		if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
 			return RX_DROP_MONITOR;
 		break;
 	default:
 		return RX_DROP_MONITOR;
 	}
 	/* queue up frame and kick off work to process it */
 	rx->skb->pkt_type = IEEE80211_SDATA_QUEUE_TYPE_FRAME;
 	skb_queue_tail(&sdata->skb_queue, rx->skb);
 	ieee80211_queue_work(&rx->local->hw, &sdata->work);
 	if (rx->sta)
 		rx->sta->rx_packets++;
 	return RX_QUEUED;
 }
 static void ieee80211_rx_michael_mic_report(struct ieee80211_hdr *hdr,
 					    struct ieee80211_rx_data *rx)
 {
 	int keyidx;
 	unsigned int hdrlen;
 	hdrlen = ieee80211_hdrlen(hdr->frame_control);
 	if (rx->skb->len >= hdrlen + 4)
 		keyidx = rx->skb->data[hdrlen + 3] >> 6;
 	else
 		keyidx = -1;
 	if (!rx->sta) {
 		/*
 		 * Some hardware seem to generate incorrect Michael MIC
 		 * reports; ignore them to avoid triggering countermeasures.
 		 */
 		return;
 	}
 	if (!ieee80211_has_protected(hdr->frame_control))
 		return;
 	if (rx->sdata->vif.type == NL80211_IFTYPE_AP && keyidx) {
 		/*
 		 * APs with pairwise keys should never receive Michael MIC
 		 * errors for non-zero keyidx because these are reserved for
 		 * group keys and only the AP is sending real multicast
 		 * frames in the BSS.
 		 */
 		return;
 	}
 	if (!ieee80211_is_data(hdr->frame_control) &&
 	    !ieee80211_is_auth(hdr->frame_control))
 		return;
 	mac80211_ev_michael_mic_failure(rx->sdata, keyidx, hdr, NULL,
 					GFP_ATOMIC);
 }
 /* TODO: use IEEE80211_RX_FRAGMENTED */
 static void ieee80211_rx_cooked_monitor(struct ieee80211_rx_data *rx,
 					struct ieee80211_rate *rate)
 {
 	struct ieee80211_sub_if_data *sdata;
 	struct ieee80211_local *local = rx->local;
 	struct ieee80211_rtap_hdr {
 		struct ieee80211_radiotap_header hdr;
 		u8 flags;
 		u8 rate_or_pad;
 		__le16 chan_freq;
 		__le16 chan_flags;
 	} __packed *rthdr;
 	struct sk_buff *skb = rx->skb, *skb2;
 	struct net_device *prev_dev = NULL;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
-	if (status->flag & RX_FLAG_INTERNAL_CMTR)
-		goto out_free_skb;
 	if (skb_headroom(skb) < sizeof(*rthdr) &&
 	    pskb_expand_head(skb, sizeof(*rthdr), 0, GFP_ATOMIC))
 		goto out_free_skb;
 	rthdr = (void *)skb_push(skb, sizeof(*rthdr));
 	memset(rthdr, 0, sizeof(*rthdr));
 	rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
 	rthdr->hdr.it_present =
 		cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 			    (1 << IEEE80211_RADIOTAP_CHANNEL));
 	if (rate) {
 		rthdr->rate_or_pad = rate->bitrate / 5;
 		rthdr->hdr.it_present |=
 			cpu_to_le32(1 << IEEE80211_RADIOTAP_RATE);
 	}
 	rthdr->chan_freq = cpu_to_le16(status->freq);
 	if (status->band == IEEE80211_BAND_5GHZ)
 		rthdr->chan_flags = cpu_to_le16(IEEE80211_CHAN_OFDM |
 						IEEE80211_CHAN_5GHZ);
 	else
 		rthdr->chan_flags = cpu_to_le16(IEEE80211_CHAN_DYN |
 						IEEE80211_CHAN_2GHZ);
 	skb_set_mac_header(skb, 0);
 	skb->ip_summed = CHECKSUM_UNNECESSARY;
 	skb->pkt_type = PACKET_OTHERHOST;
 	skb->protocol = htons(ETH_P_802_2);
 	list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 		if (!ieee80211_sdata_running(sdata))
 			continue;
 		if (sdata->vif.type != NL80211_IFTYPE_MONITOR ||
 		    !(sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
 			continue;
 		if (prev_dev) {
 			skb2 = skb_clone(skb, GFP_ATOMIC);
 			if (skb2) {
 				skb2->dev = prev_dev;
 				netif_receive_skb(skb2);
 			}
 		}
 		prev_dev = sdata->dev;
 		sdata->dev->stats.rx_packets++;
 		sdata->dev->stats.rx_bytes += skb->len;
 	}
 	if (prev_dev) {
 		skb->dev = prev_dev;
 		netif_receive_skb(skb);
 		skb = NULL;
 	} else
 		goto out_free_skb;
-	status->flag |= RX_FLAG_INTERNAL_CMTR;
 	return;
  out_free_skb:
 	dev_kfree_skb(skb);
 }
 static void ieee80211_invoke_rx_handlers(struct ieee80211_sub_if_data *sdata,
 					 struct ieee80211_rx_data *rx,
 					 struct sk_buff *skb,
 					 struct ieee80211_rate *rate)
 {
 	struct sk_buff_head reorder_release;
 	ieee80211_rx_result res = RX_DROP_MONITOR;
 	__skb_queue_head_init(&reorder_release);
 	rx->skb = skb;
 	rx->sdata = sdata;
 #define CALL_RXH(rxh)			\
 	do {				\
 		res = rxh(rx);		\
 		if (res != RX_CONTINUE)	\
 			goto rxh_next;  \
 	} while (0);
 	/*
 	 * NB: the rxh_next label works even if we jump
 	 *     to it from here because then the list will
 	 *     be empty, which is a trivial check
 	 */
 	CALL_RXH(ieee80211_rx_h_passive_scan)
 	CALL_RXH(ieee80211_rx_h_check)
 	ieee80211_rx_reorder_ampdu(rx, &reorder_release);
 	while ((skb = __skb_dequeue(&reorder_release))) {
 		/*
 		 * all the other fields are valid across frames
 		 * that belong to an aMPDU since they are on the
 		 * same TID from the same station
 		 */
 		rx->skb = skb;
 		CALL_RXH(ieee80211_rx_h_decrypt)
 		CALL_RXH(ieee80211_rx_h_check_more_data)
 		CALL_RXH(ieee80211_rx_h_sta_process)
 		CALL_RXH(ieee80211_rx_h_defragment)
 		CALL_RXH(ieee80211_rx_h_ps_poll)
 		CALL_RXH(ieee80211_rx_h_michael_mic_verify)
 		/* must be after MMIC verify so header is counted in MPDU mic */
 		CALL_RXH(ieee80211_rx_h_remove_qos_control)
 		CALL_RXH(ieee80211_rx_h_amsdu)
 #ifdef CONFIG_MAC80211_MESH
 		if (ieee80211_vif_is_mesh(&sdata->vif))
 			CALL_RXH(ieee80211_rx_h_mesh_fwding);
 #endif
 		CALL_RXH(ieee80211_rx_h_data)
 		/* special treatment -- needs the queue */
 		res = ieee80211_rx_h_ctrl(rx, &reorder_release);
 		if (res != RX_CONTINUE)
 			goto rxh_next;
 		CALL_RXH(ieee80211_rx_h_action)
 		CALL_RXH(ieee80211_rx_h_mgmt)
 #undef CALL_RXH
  rxh_next:
 		switch (res) {
 		case RX_DROP_MONITOR:
 			I802_DEBUG_INC(sdata->local->rx_handlers_drop);
 			if (rx->sta)
 				rx->sta->rx_dropped++;
 			/* fall through */
 		case RX_CONTINUE:
 			ieee80211_rx_cooked_monitor(rx, rate);
 			break;
 		case RX_DROP_UNUSABLE:
 			I802_DEBUG_INC(sdata->local->rx_handlers_drop);
 			if (rx->sta)
 				rx->sta->rx_dropped++;
 			dev_kfree_skb(rx->skb);
 			break;
 		case RX_QUEUED:
 			I802_DEBUG_INC(sdata->local->rx_handlers_queued);
 			break;
 		}
 	}
 }
 /* main receive path */
 static int prepare_for_handlers(struct ieee80211_sub_if_data *sdata,
 				struct ieee80211_rx_data *rx,
 				struct ieee80211_hdr *hdr)
 {
 	struct sk_buff *skb = rx->skb;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	u8 *bssid = ieee80211_get_bssid(hdr, skb->len, sdata->vif.type);
 	int multicast = is_multicast_ether_addr(hdr->addr1);
 	switch (sdata->vif.type) {
 	case NL80211_IFTYPE_STATION:
 		if (!bssid && !sdata->u.mgd.use_4addr)
 			return 0;
 		if (!multicast &&
 		    compare_ether_addr(sdata->vif.addr, hdr->addr1) != 0) {
 			if (!(sdata->dev->flags & IFF_PROMISC))
 				return 0;
 			rx->flags &= ~IEEE80211_RX_RA_MATCH;
 		}
 		break;
 	case NL80211_IFTYPE_ADHOC:
 		if (!bssid)
 			return 0;
 		if (ieee80211_is_beacon(hdr->frame_control)) {
 			return 1;
 		}
 		else if (!ieee80211_bssid_match(bssid, sdata->u.ibss.bssid)) {
 			if (!(rx->flags & IEEE80211_RX_IN_SCAN))
 				return 0;
 			rx->flags &= ~IEEE80211_RX_RA_MATCH;
 		} else if (!multicast &&
 			   compare_ether_addr(sdata->vif.addr,
 					      hdr->addr1) != 0) {
 			if (!(sdata->dev->flags & IFF_PROMISC))
 				return 0;
 			rx->flags &= ~IEEE80211_RX_RA_MATCH;
 		} else if (!rx->sta) {
 			int rate_idx;
 			if (status->flag & RX_FLAG_HT)
 				rate_idx = 0; /* TODO: HT rates */
 			else
 				rate_idx = status->rate_idx;
 			rx->sta = ieee80211_ibss_add_sta(sdata, bssid,
 					hdr->addr2, BIT(rate_idx), GFP_ATOMIC);
 		}
 		break;
 	case NL80211_IFTYPE_MESH_POINT:
 		if (!multicast &&
 		    compare_ether_addr(sdata->vif.addr,
 				       hdr->addr1) != 0) {
 			if (!(sdata->dev->flags & IFF_PROMISC))
 				return 0;
 			rx->flags &= ~IEEE80211_RX_RA_MATCH;
 		}
 		break;
 	case NL80211_IFTYPE_AP_VLAN:
 	case NL80211_IFTYPE_AP:
 		if (!bssid) {
 			if (compare_ether_addr(sdata->vif.addr,
 					       hdr->addr1))
 				return 0;
 		} else if (!ieee80211_bssid_match(bssid,
 					sdata->vif.addr)) {
 			if (!(rx->flags & IEEE80211_RX_IN_SCAN))
 				return 0;
 			rx->flags &= ~IEEE80211_RX_RA_MATCH;
 		}
 		break;
 	case NL80211_IFTYPE_WDS:
 		if (bssid || !ieee80211_is_data(hdr->frame_control))
 			return 0;
 		if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2))
 			return 0;
 		break;
 	case NL80211_IFTYPE_MONITOR:
 	case NL80211_IFTYPE_UNSPECIFIED:
 	case __NL80211_IFTYPE_AFTER_LAST:
 		/* should never get here */
 		WARN_ON(1);
 		break;
 	}
 	return 1;
 }
 /*
  * This is the actual Rx frames handler. as it blongs to Rx path it must
  * be called with rcu_read_lock protection.
  */
 static void __ieee80211_rx_handle_packet(struct ieee80211_hw *hw,
 					 struct sk_buff *skb,
 					 struct ieee80211_rate *rate)
 {
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	struct ieee80211_local *local = hw_to_local(hw);
 	struct ieee80211_sub_if_data *sdata;
 	struct ieee80211_hdr *hdr;
 	__le16 fc;
 	struct ieee80211_rx_data rx;
 	int prepares;
 	struct ieee80211_sub_if_data *prev = NULL;
 	struct sk_buff *skb_new;
 	struct sta_info *sta, *tmp;
 	bool found_sta = false;
 	int err = 0;
 	fc = ((struct ieee80211_hdr *)skb->data)->frame_control;
 	memset(&rx, 0, sizeof(rx));
 	rx.skb = skb;
 	rx.local = local;
 	if (ieee80211_is_data(fc) || ieee80211_is_mgmt(fc))
 		local->dot11ReceivedFragmentCount++;
 	if (unlikely(test_bit(SCAN_HW_SCANNING, &local->scanning) ||
 		     test_bit(SCAN_OFF_CHANNEL, &local->scanning)))
 		rx.flags |= IEEE80211_RX_IN_SCAN;
 	if (ieee80211_is_mgmt(fc))
 		err = skb_linearize(skb);
 	else
 		err = !pskb_may_pull(skb, ieee80211_hdrlen(fc));
 	if (err) {
 		dev_kfree_skb(skb);
 		return;
 	}
 	hdr = (struct ieee80211_hdr *)skb->data;
 	ieee80211_parse_qos(&rx);
 	ieee80211_verify_alignment(&rx);
 	if (ieee80211_is_data(fc)) {
 		for_each_sta_info(local, hdr->addr2, sta, tmp) {
 			rx.sta = sta;
 			found_sta = true;
 			rx.sdata = sta->sdata;
 			rx.flags |= IEEE80211_RX_RA_MATCH;
 			prepares = prepare_for_handlers(rx.sdata, &rx, hdr);
 			if (prepares) {
 				if (status->flag & RX_FLAG_MMIC_ERROR) {
 					if (rx.flags & IEEE80211_RX_RA_MATCH)
 						ieee80211_rx_michael_mic_report(hdr, &rx);
 				} else
 					prev = rx.sdata;
 			}
 		}
 	}
 	if (!found_sta) {
 		list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 			if (!ieee80211_sdata_running(sdata))
 				continue;
 			if (sdata->vif.type == NL80211_IFTYPE_MONITOR ||
 			    sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
 				continue;
 			/*
 			 * frame is destined for this interface, but if it's
 			 * not also for the previous one we handle that after
 			 * the loop to avoid copying the SKB once too much
 			 */
 			if (!prev) {
 				prev = sdata;
 				continue;
 			}
 			rx.sta = sta_info_get_bss(prev, hdr->addr2);
 			rx.flags |= IEEE80211_RX_RA_MATCH;
 			prepares = prepare_for_handlers(prev, &rx, hdr);
 			if (!prepares)
 				goto next;
 			if (status->flag & RX_FLAG_MMIC_ERROR) {
 				rx.sdata = prev;
 				if (rx.flags & IEEE80211_RX_RA_MATCH)
 					ieee80211_rx_michael_mic_report(hdr,
 									&rx);
 				goto next;
 			}
 			/*
 			 * frame was destined for the previous interface
 			 * so invoke RX handlers for it
 			 */
 			skb_new = skb_copy(skb, GFP_ATOMIC);
 			if (!skb_new) {
 				if (net_ratelimit())
 					printk(KERN_DEBUG "%s: failed to copy "
 					       "multicast frame for %s\n",
 					       wiphy_name(local->hw.wiphy),
 					       prev->name);
 				goto next;
 			}
 			ieee80211_invoke_rx_handlers(prev, &rx, skb_new, rate);
 next:
 			prev = sdata;
 		}
 		if (prev) {
 			rx.sta = sta_info_get_bss(prev, hdr->addr2);
 			rx.flags |= IEEE80211_RX_RA_MATCH;
 			prepares = prepare_for_handlers(prev, &rx, hdr);
 			if (!prepares)
 				prev = NULL;
 		}
 	}
 	if (prev)
 		ieee80211_invoke_rx_handlers(prev, &rx, skb, rate);
 	else
 		dev_kfree_skb(skb);
 }
 /*
  * This is the receive path handler. It is called by a low level driver when an
  * 802.11 MPDU is received from the hardware.
  */
 void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	struct ieee80211_rate *rate = NULL;
 	struct ieee80211_supported_band *sband;
 	struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
 	WARN_ON_ONCE(softirq_count() == 0);
 	if (WARN_ON(status->band < 0 ||
 		    status->band >= IEEE80211_NUM_BANDS))
 		goto drop;
 	sband = local->hw.wiphy->bands[status->band];
 	if (WARN_ON(!sband))
 		goto drop;
 	/*
 	 * If we're suspending, it is possible although not too likely
 	 * that we'd be receiving frames after having already partially
 	 * quiesced the stack. We can't process such frames then since
 	 * that might, for example, cause stations to be added or other
 	 * driver callbacks be invoked.
 	 */
 	if (unlikely(local->quiescing || local->suspended))
 		goto drop;
 	/*
 	 * The same happens when we're not even started,
 	 * but that's worth a warning.
 	 */
 	if (WARN_ON(!local->started))
 		goto drop;
 	if (status->flag & RX_FLAG_HT) {
 		/*
 		 * rate_idx is MCS index, which can be [0-76] as documented on:
 		 *
 		 * http://wireless.kernel.org/en/developers/Documentation/ieee80211/802.11n
 		 *
 		 * Anything else would be some sort of driver or hardware error.
 		 * The driver should catch hardware errors.
 		 */
 		if (WARN((status->rate_idx < 0 ||
 			 status->rate_idx > 76),
 			 "Rate marked as an HT rate but passed "
 			 "status->rate_idx is not "
 			 "an MCS index [0-76]: %d (0x%02x)\n",
 			 status->rate_idx,
 			 status->rate_idx))
 			goto drop;
 	} else {
 		if (WARN_ON(status->rate_idx < 0 ||
 			    status->rate_idx >= sband->n_bitrates))
 			goto drop;
 		rate = &sband->bitrates[status->rate_idx];
 	}
 	/*
 	 * key references and virtual interfaces are protected using RCU
 	 * and this requires that we are in a read-side RCU section during
 	 * receive processing
 	 */
 	rcu_read_lock();
 	/*
 	 * Frames with failed FCS/PLCP checksum are not returned,
 	 * all other frames are returned without radiotap header
 	 * if it was previously present.
 	 * Also, frames with less than 16 bytes are dropped.
 	 */
 	skb = ieee80211_rx_monitor(local, skb, rate);
 	if (!skb) {
 		rcu_read_unlock();
 		return;
 	}
 	__ieee80211_rx_handle_packet(hw, skb, rate);
 	rcu_read_unlock();
 	return;
  drop:
 	kfree_skb(skb);
 }
 EXPORT_SYMBOL(ieee80211_rx);
 /* This is a version of the rx handler that can be called from hard irq
  * context. Post the skb on the queue and schedule the tasklet */
 void ieee80211_rx_irqsafe(struct ieee80211_hw *hw, struct sk_buff *skb)
 {
 	struct ieee80211_local *local = hw_to_local(hw);
 	BUILD_BUG_ON(sizeof(struct ieee80211_rx_status) > sizeof(skb->cb));
 	skb->pkt_type = IEEE80211_RX_MSG;
 	skb_queue_tail(&local->skb_queue, skb);
 	tasklet_schedule(&local->tasklet);
 }
 EXPORT_SYMBOL(ieee80211_rx_irqsafe);

net/phonet/pep.c

Diff comments View file @ 4a73a43

 /*
  * File: pep.c
  *
  * Phonet pipe protocol end point socket
  *
  * Copyright (C) 2008 Nokia Corporation.
  *
  * Author: Rémi Denis-Courmont <remi.denis-courmont@nokia.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 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 St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  */
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/socket.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <asm/ioctls.h>
 #include <linux/phonet.h>
 #include <net/phonet/phonet.h>
 #include <net/phonet/pep.h>
 #include <net/phonet/gprs.h>
 /* sk_state values:
  * TCP_CLOSE		sock not in use yet
  * TCP_CLOSE_WAIT	disconnected pipe
  * TCP_LISTEN		listening pipe endpoint
  * TCP_SYN_RECV		connected pipe in disabled state
  * TCP_ESTABLISHED	connected pipe in enabled state
  *
  * pep_sock locking:
  *  - sk_state, ackq, hlist: sock lock needed
  *  - listener: read only
  *  - pipe_handle: read only
  */
 #define CREDITS_MAX	10
 #define CREDITS_THR	7
 static const struct sockaddr_pn pipe_srv = {
 	.spn_family = AF_PHONET,
 	.spn_resource = 0xD9, /* pipe service */
 };
 #define pep_sb_size(s) (((s) + 5) & ~3) /* 2-bytes head, 32-bits aligned */
 /* Get the next TLV sub-block. */
 static unsigned char *pep_get_sb(struct sk_buff *skb, u8 *ptype, u8 *plen,
 					void *buf)
 {
 	void *data = NULL;
 	struct {
 		u8 sb_type;
 		u8 sb_len;
 	} *ph, h;
 	int buflen = *plen;
 	ph = skb_header_pointer(skb, 0, 2, &h);
 	if (ph == NULL || ph->sb_len < 2 || !pskb_may_pull(skb, ph->sb_len))
 		return NULL;
 	ph->sb_len -= 2;
 	*ptype = ph->sb_type;
 	*plen = ph->sb_len;
 	if (buflen > ph->sb_len)
 		buflen = ph->sb_len;
 	data = skb_header_pointer(skb, 2, buflen, buf);
 	__skb_pull(skb, 2 + ph->sb_len);
 	return data;
 }
 static int pep_reply(struct sock *sk, struct sk_buff *oskb,
 			u8 code, const void *data, int len, gfp_t priority)
 {
 	const struct pnpipehdr *oph = pnp_hdr(oskb);
 	struct pnpipehdr *ph;
 	struct sk_buff *skb;
 	skb = alloc_skb(MAX_PNPIPE_HEADER + len, priority);
 	if (!skb)
 		return -ENOMEM;
 	skb_set_owner_w(skb, sk);
 	skb_reserve(skb, MAX_PNPIPE_HEADER);
 	__skb_put(skb, len);
 	skb_copy_to_linear_data(skb, data, len);
 	__skb_push(skb, sizeof(*ph));
 	skb_reset_transport_header(skb);
 	ph = pnp_hdr(skb);
 	ph->utid = oph->utid;
 	ph->message_id = oph->message_id + 1; /* REQ -> RESP */
 	ph->pipe_handle = oph->pipe_handle;
 	ph->error_code = code;
 	return pn_skb_send(sk, skb, &pipe_srv);
 }
 #define PAD 0x00
 static int pep_accept_conn(struct sock *sk, struct sk_buff *skb)
 {
 	static const u8 data[20] = {
 		PAD, PAD, PAD, 2 /* sub-blocks */,
 		PN_PIPE_SB_REQUIRED_FC_TX, pep_sb_size(5), 3, PAD,
 			PN_MULTI_CREDIT_FLOW_CONTROL,
 			PN_ONE_CREDIT_FLOW_CONTROL,
 			PN_LEGACY_FLOW_CONTROL,
 			PAD,
 		PN_PIPE_SB_PREFERRED_FC_RX, pep_sb_size(5), 3, PAD,
 			PN_MULTI_CREDIT_FLOW_CONTROL,
 			PN_ONE_CREDIT_FLOW_CONTROL,
 			PN_LEGACY_FLOW_CONTROL,
 			PAD,
 	};
 	might_sleep();
 	return pep_reply(sk, skb, PN_PIPE_NO_ERROR, data, sizeof(data),
 				GFP_KERNEL);
 }
 static int pep_reject_conn(struct sock *sk, struct sk_buff *skb, u8 code)
 {
 	static const u8 data[4] = { PAD, PAD, PAD, 0 /* sub-blocks */ };
 	WARN_ON(code == PN_PIPE_NO_ERROR);
 	return pep_reply(sk, skb, code, data, sizeof(data), GFP_ATOMIC);
 }
 /* Control requests are not sent by the pipe service and have a specific
  * message format. */
 static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
 				gfp_t priority)
 {
 	const struct pnpipehdr *oph = pnp_hdr(oskb);
 	struct sk_buff *skb;
 	struct pnpipehdr *ph;
 	struct sockaddr_pn dst;
 	skb = alloc_skb(MAX_PNPIPE_HEADER + 4, priority);
 	if (!skb)
 		return -ENOMEM;
 	skb_set_owner_w(skb, sk);
 	skb_reserve(skb, MAX_PHONET_HEADER);
 	ph = (struct pnpipehdr *)skb_put(skb, sizeof(*ph) + 4);
 	ph->utid = oph->utid;
 	ph->message_id = PNS_PEP_CTRL_RESP;
 	ph->pipe_handle = oph->pipe_handle;
 	ph->data[0] = oph->data[1]; /* CTRL id */
 	ph->data[1] = oph->data[0]; /* PEP type */
 	ph->data[2] = code; /* error code, at an usual offset */
 	ph->data[3] = PAD;
 	ph->data[4] = PAD;
 	pn_skb_get_src_sockaddr(oskb, &dst);
 	return pn_skb_send(sk, skb, &dst);
 }
 static int pipe_snd_status(struct sock *sk, u8 type, u8 status, gfp_t priority)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct pnpipehdr *ph;
 	struct sk_buff *skb;
 	skb = alloc_skb(MAX_PNPIPE_HEADER + 4, priority);
 	if (!skb)
 		return -ENOMEM;
 	skb_set_owner_w(skb, sk);
 	skb_reserve(skb, MAX_PNPIPE_HEADER + 4);
 	__skb_push(skb, sizeof(*ph) + 4);
 	skb_reset_transport_header(skb);
 	ph = pnp_hdr(skb);
 	ph->utid = 0;
 	ph->message_id = PNS_PEP_STATUS_IND;
 	ph->pipe_handle = pn->pipe_handle;
 	ph->pep_type = PN_PEP_TYPE_COMMON;
 	ph->data[1] = type;
 	ph->data[2] = PAD;
 	ph->data[3] = PAD;
 	ph->data[4] = status;
 	return pn_skb_send(sk, skb, &pipe_srv);
 }
 /* Send our RX flow control information to the sender.
  * Socket must be locked. */
 static void pipe_grant_credits(struct sock *sk)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	BUG_ON(sk->sk_state != TCP_ESTABLISHED);
 	switch (pn->rx_fc) {
 	case PN_LEGACY_FLOW_CONTROL: /* TODO */
 		break;
 	case PN_ONE_CREDIT_FLOW_CONTROL:
 		pipe_snd_status(sk, PN_PEP_IND_FLOW_CONTROL,
 				PEP_IND_READY, GFP_ATOMIC);
 		pn->rx_credits = 1;
 		break;
 	case PN_MULTI_CREDIT_FLOW_CONTROL:
 		if ((pn->rx_credits + CREDITS_THR) > CREDITS_MAX)
 			break;
 		if (pipe_snd_status(sk, PN_PEP_IND_ID_MCFC_GRANT_CREDITS,
 					CREDITS_MAX - pn->rx_credits,
 					GFP_ATOMIC) == 0)
 			pn->rx_credits = CREDITS_MAX;
 		break;
 	}
 }
 static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
 {
 	struct pep_sock *pn = pep_sk(sk);
-	struct pnpipehdr *hdr = pnp_hdr(skb);
+	struct pnpipehdr *hdr;
 	int wake = 0;
 	if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
 		return -EINVAL;
+	hdr = pnp_hdr(skb);
 	if (hdr->data[0] != PN_PEP_TYPE_COMMON) {
 		LIMIT_NETDEBUG(KERN_DEBUG"Phonet unknown PEP type: %u\n",
 				(unsigned)hdr->data[0]);
 		return -EOPNOTSUPP;
 	}
 	switch (hdr->data[1]) {
 	case PN_PEP_IND_FLOW_CONTROL:
 		switch (pn->tx_fc) {
 		case PN_LEGACY_FLOW_CONTROL:
 			switch (hdr->data[4]) {
 			case PEP_IND_BUSY:
 				atomic_set(&pn->tx_credits, 0);
 				break;
 			case PEP_IND_READY:
 				atomic_set(&pn->tx_credits, wake = 1);
 				break;
 			}
 			break;
 		case PN_ONE_CREDIT_FLOW_CONTROL:
 			if (hdr->data[4] == PEP_IND_READY)
 				atomic_set(&pn->tx_credits, wake = 1);
 			break;
 		}
 		break;
 	case PN_PEP_IND_ID_MCFC_GRANT_CREDITS:
 		if (pn->tx_fc != PN_MULTI_CREDIT_FLOW_CONTROL)
 			break;
 		atomic_add(wake = hdr->data[4], &pn->tx_credits);
 		break;
 	default:
 		LIMIT_NETDEBUG(KERN_DEBUG"Phonet unknown PEP indication: %u\n",
 				(unsigned)hdr->data[1]);
 		return -EOPNOTSUPP;
 	}
 	if (wake)
 		sk->sk_write_space(sk);
 	return 0;
 }
 static int pipe_rcv_created(struct sock *sk, struct sk_buff *skb)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct pnpipehdr *hdr = pnp_hdr(skb);
 	u8 n_sb = hdr->data[0];
 	pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
 	__skb_pull(skb, sizeof(*hdr));
 	while (n_sb > 0) {
 		u8 type, buf[2], len = sizeof(buf);
 		u8 *data = pep_get_sb(skb, &type, &len, buf);
 		if (data == NULL)
 			return -EINVAL;
 		switch (type) {
 		case PN_PIPE_SB_NEGOTIATED_FC:
 			if (len < 2 || (data[0] | data[1]) > 3)
 				break;
 			pn->tx_fc = data[0] & 3;
 			pn->rx_fc = data[1] & 3;
 			break;
 		}
 		n_sb--;
 	}
 	return 0;
 }
 /* Queue an skb to a connected sock.
  * Socket lock must be held. */
 static int pipe_do_rcv(struct sock *sk, struct sk_buff *skb)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct pnpipehdr *hdr = pnp_hdr(skb);
 	struct sk_buff_head *queue;
 	int err = 0;
 	BUG_ON(sk->sk_state == TCP_CLOSE_WAIT);
 	switch (hdr->message_id) {
 	case PNS_PEP_CONNECT_REQ:
 		pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE);
 		break;
 	case PNS_PEP_DISCONNECT_REQ:
 		pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
 		sk->sk_state = TCP_CLOSE_WAIT;
 		if (!sock_flag(sk, SOCK_DEAD))
 			sk->sk_state_change(sk);
 		break;
 	case PNS_PEP_ENABLE_REQ:
 		/* Wait for PNS_PIPE_(ENABLED|REDIRECTED)_IND */
 		pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
 		break;
 	case PNS_PEP_RESET_REQ:
 		switch (hdr->state_after_reset) {
 		case PN_PIPE_DISABLE:
 			pn->init_enable = 0;
 			break;
 		case PN_PIPE_ENABLE:
 			pn->init_enable = 1;
 			break;
 		default: /* not allowed to send an error here!? */
 			err = -EINVAL;
 			goto out;
 		}
 		/* fall through */
 	case PNS_PEP_DISABLE_REQ:
 		atomic_set(&pn->tx_credits, 0);
 		pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
 		break;
 	case PNS_PEP_CTRL_REQ:
 		if (skb_queue_len(&pn->ctrlreq_queue) >= PNPIPE_CTRLREQ_MAX) {
 			atomic_inc(&sk->sk_drops);
 			break;
 		}
 		__skb_pull(skb, 4);
 		queue = &pn->ctrlreq_queue;
 		goto queue;
 	case PNS_PIPE_ALIGNED_DATA:
 		__skb_pull(skb, 1);
 		/* fall through */
 	case PNS_PIPE_DATA:
 		__skb_pull(skb, 3); /* Pipe data header */
 		if (!pn_flow_safe(pn->rx_fc)) {
 			err = sock_queue_rcv_skb(sk, skb);
 			if (!err)
 				return 0;
 			break;
 		}
 		if (pn->rx_credits == 0) {
 			atomic_inc(&sk->sk_drops);
 			err = -ENOBUFS;
 			break;
 		}
 		pn->rx_credits--;
 		queue = &sk->sk_receive_queue;
 		goto queue;
 	case PNS_PEP_STATUS_IND:
 		pipe_rcv_status(sk, skb);
 		break;
 	case PNS_PIPE_REDIRECTED_IND:
 		err = pipe_rcv_created(sk, skb);
 		break;
 	case PNS_PIPE_CREATED_IND:
 		err = pipe_rcv_created(sk, skb);
 		if (err)
 			break;
 		/* fall through */
 	case PNS_PIPE_RESET_IND:
 		if (!pn->init_enable)
 			break;
 		/* fall through */
 	case PNS_PIPE_ENABLED_IND:
 		if (!pn_flow_safe(pn->tx_fc)) {
 			atomic_set(&pn->tx_credits, 1);
 			sk->sk_write_space(sk);
 		}
 		if (sk->sk_state == TCP_ESTABLISHED)
 			break; /* Nothing to do */
 		sk->sk_state = TCP_ESTABLISHED;
 		pipe_grant_credits(sk);
 		break;
 	case PNS_PIPE_DISABLED_IND:
 		sk->sk_state = TCP_SYN_RECV;
 		pn->rx_credits = 0;
 		break;
 	default:
 		LIMIT_NETDEBUG(KERN_DEBUG"Phonet unknown PEP message: %u\n",
 				hdr->message_id);
 		err = -EINVAL;
 	}
 out:
 	kfree_skb(skb);
 	return err;
 queue:
 	skb->dev = NULL;
 	skb_set_owner_r(skb, sk);
 	err = skb->len;
 	skb_queue_tail(queue, skb);
 	if (!sock_flag(sk, SOCK_DEAD))
 		sk->sk_data_ready(sk, err);
 	return 0;
 }
 /* Destroy connected sock. */
 static void pipe_destruct(struct sock *sk)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	skb_queue_purge(&sk->sk_receive_queue);
 	skb_queue_purge(&pn->ctrlreq_queue);
 }
 static int pep_connreq_rcv(struct sock *sk, struct sk_buff *skb)
 {
 	struct sock *newsk;
 	struct pep_sock *newpn, *pn = pep_sk(sk);
 	struct pnpipehdr *hdr;
 	struct sockaddr_pn dst;
 	u16 peer_type;
 	u8 pipe_handle, enabled, n_sb;
 	u8 aligned = 0;
 	if (!pskb_pull(skb, sizeof(*hdr) + 4))
 		return -EINVAL;
 	hdr = pnp_hdr(skb);
 	pipe_handle = hdr->pipe_handle;
 	switch (hdr->state_after_connect) {
 	case PN_PIPE_DISABLE:
 		enabled = 0;
 		break;
 	case PN_PIPE_ENABLE:
 		enabled = 1;
 		break;
 	default:
 		pep_reject_conn(sk, skb, PN_PIPE_ERR_INVALID_PARAM);
 		return -EINVAL;
 	}
 	peer_type = hdr->other_pep_type << 8;
 	if (unlikely(sk->sk_state != TCP_LISTEN) || sk_acceptq_is_full(sk)) {
 		pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE);
 		return -ENOBUFS;
 	}
 	/* Parse sub-blocks (options) */
 	n_sb = hdr->data[4];
 	while (n_sb > 0) {
 		u8 type, buf[1], len = sizeof(buf);
 		const u8 *data = pep_get_sb(skb, &type, &len, buf);
 		if (data == NULL)
 			return -EINVAL;
 		switch (type) {
 		case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE:
 			if (len < 1)
 				return -EINVAL;
 			peer_type = (peer_type & 0xff00) | data[0];
 			break;
 		case PN_PIPE_SB_ALIGNED_DATA:
 			aligned = data[0] != 0;
 			break;
 		}
 		n_sb--;
 	}
 	skb = skb_clone(skb, GFP_ATOMIC);
 	if (!skb)
 		return -ENOMEM;
 	/* Create a new to-be-accepted sock */
 	newsk = sk_alloc(sock_net(sk), PF_PHONET, GFP_ATOMIC, sk->sk_prot);
 	if (!newsk) {
 		kfree_skb(skb);
 		return -ENOMEM;
 	}
 	sock_init_data(NULL, newsk);
 	newsk->sk_state = TCP_SYN_RECV;
 	newsk->sk_backlog_rcv = pipe_do_rcv;
 	newsk->sk_protocol = sk->sk_protocol;
 	newsk->sk_destruct = pipe_destruct;
 	newpn = pep_sk(newsk);
 	pn_skb_get_dst_sockaddr(skb, &dst);
 	newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);
 	newpn->pn_sk.resource = pn->pn_sk.resource;
 	skb_queue_head_init(&newpn->ctrlreq_queue);
 	newpn->pipe_handle = pipe_handle;
 	atomic_set(&newpn->tx_credits, 0);
 	newpn->peer_type = peer_type;
 	newpn->rx_credits = 0;
 	newpn->rx_fc = newpn->tx_fc = PN_LEGACY_FLOW_CONTROL;
 	newpn->init_enable = enabled;
 	newpn->aligned = aligned;
 	BUG_ON(!skb_queue_empty(&newsk->sk_receive_queue));
 	skb_queue_head(&newsk->sk_receive_queue, skb);
 	if (!sock_flag(sk, SOCK_DEAD))
 		sk->sk_data_ready(sk, 0);
 	sk_acceptq_added(sk);
 	sk_add_node(newsk, &pn->ackq);
 	return 0;
 }
 /* Listening sock must be locked */
 static struct sock *pep_find_pipe(const struct hlist_head *hlist,
 					const struct sockaddr_pn *dst,
 					u8 pipe_handle)
 {
 	struct hlist_node *node;
 	struct sock *sknode;
 	u16 dobj = pn_sockaddr_get_object(dst);
 	sk_for_each(sknode, node, hlist) {
 		struct pep_sock *pnnode = pep_sk(sknode);
 		/* Ports match, but addresses might not: */
 		if (pnnode->pn_sk.sobject != dobj)
 			continue;
 		if (pnnode->pipe_handle != pipe_handle)
 			continue;
 		if (sknode->sk_state == TCP_CLOSE_WAIT)
 			continue;
 		sock_hold(sknode);
 		return sknode;
 	}
 	return NULL;
 }
 /*
  * Deliver an skb to a listening sock.
  * Socket lock must be held.
  * We then queue the skb to the right connected sock (if any).
  */
 static int pep_do_rcv(struct sock *sk, struct sk_buff *skb)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct sock *sknode;
 	struct pnpipehdr *hdr;
 	struct sockaddr_pn dst;
 	int err = NET_RX_SUCCESS;
 	u8 pipe_handle;
 	if (!pskb_may_pull(skb, sizeof(*hdr)))
 		goto drop;
 	hdr = pnp_hdr(skb);
 	pipe_handle = hdr->pipe_handle;
 	if (pipe_handle == PN_PIPE_INVALID_HANDLE)
 		goto drop;
 	pn_skb_get_dst_sockaddr(skb, &dst);
 	/* Look for an existing pipe handle */
 	sknode = pep_find_pipe(&pn->hlist, &dst, pipe_handle);
 	if (sknode)
 		return sk_receive_skb(sknode, skb, 1);
 	/* Look for a pipe handle pending accept */
 	sknode = pep_find_pipe(&pn->ackq, &dst, pipe_handle);
 	if (sknode) {
 		sock_put(sknode);
 		if (net_ratelimit())
 			printk(KERN_WARNING"Phonet unconnected PEP ignored");
 		err = NET_RX_DROP;
 		goto drop;
 	}
 	switch (hdr->message_id) {
 	case PNS_PEP_CONNECT_REQ:
 		err = pep_connreq_rcv(sk, skb);
 		break;
 	case PNS_PEP_DISCONNECT_REQ:
 		pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
 		break;
 	case PNS_PEP_CTRL_REQ:
 		pep_ctrlreq_error(sk, skb, PN_PIPE_INVALID_HANDLE, GFP_ATOMIC);
 		break;
 	case PNS_PEP_RESET_REQ:
 	case PNS_PEP_ENABLE_REQ:
 	case PNS_PEP_DISABLE_REQ:
 		/* invalid handle is not even allowed here! */
 	default:
 		err = NET_RX_DROP;
 	}
 drop:
 	kfree_skb(skb);
 	return err;
 }
 /* associated socket ceases to exist */
 static void pep_sock_close(struct sock *sk, long timeout)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	int ifindex = 0;
 	sock_hold(sk); /* keep a reference after sk_common_release() */
 	sk_common_release(sk);
 	lock_sock(sk);
 	if (sk->sk_state == TCP_LISTEN) {
 		/* Destroy the listen queue */
 		struct sock *sknode;
 		struct hlist_node *p, *n;
 		sk_for_each_safe(sknode, p, n, &pn->ackq)
 			sk_del_node_init(sknode);
 		sk->sk_state = TCP_CLOSE;
 	}
 	ifindex = pn->ifindex;
 	pn->ifindex = 0;
 	release_sock(sk);
 	if (ifindex)
 		gprs_detach(sk);
 	sock_put(sk);
 }
 static int pep_wait_connreq(struct sock *sk, int noblock)
 {
 	struct task_struct *tsk = current;
 	struct pep_sock *pn = pep_sk(sk);
 	long timeo = sock_rcvtimeo(sk, noblock);
 	for (;;) {
 		DEFINE_WAIT(wait);
 		if (sk->sk_state != TCP_LISTEN)
 			return -EINVAL;
 		if (!hlist_empty(&pn->ackq))
 			break;
 		if (!timeo)
 			return -EWOULDBLOCK;
 		if (signal_pending(tsk))
 			return sock_intr_errno(timeo);
 		prepare_to_wait_exclusive(sk_sleep(sk), &wait,
 						TASK_INTERRUPTIBLE);
 		release_sock(sk);
 		timeo = schedule_timeout(timeo);
 		lock_sock(sk);
 		finish_wait(sk_sleep(sk), &wait);
 	}
 	return 0;
 }
 static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct sock *newsk = NULL;
 	struct sk_buff *oskb;
 	int err;
 	lock_sock(sk);
 	err = pep_wait_connreq(sk, flags & O_NONBLOCK);
 	if (err)
 		goto out;
 	newsk = __sk_head(&pn->ackq);
 	oskb = skb_dequeue(&newsk->sk_receive_queue);
 	err = pep_accept_conn(newsk, oskb);
 	if (err) {
 		skb_queue_head(&newsk->sk_receive_queue, oskb);
 		newsk = NULL;
 		goto out;
 	}
 	kfree_skb(oskb);
 	sock_hold(sk);
 	pep_sk(newsk)->listener = sk;
 	sock_hold(newsk);
 	sk_del_node_init(newsk);
 	sk_acceptq_removed(sk);
 	sk_add_node(newsk, &pn->hlist);
 	__sock_put(newsk);
 out:
 	release_sock(sk);
 	*errp = err;
 	return newsk;
 }
 static int pep_ioctl(struct sock *sk, int cmd, unsigned long arg)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	int answ;
 	switch (cmd) {
 	case SIOCINQ:
 		if (sk->sk_state == TCP_LISTEN)
 			return -EINVAL;
 		lock_sock(sk);
 		if (sock_flag(sk, SOCK_URGINLINE) &&
 		    !skb_queue_empty(&pn->ctrlreq_queue))
 			answ = skb_peek(&pn->ctrlreq_queue)->len;
 		else if (!skb_queue_empty(&sk->sk_receive_queue))
 			answ = skb_peek(&sk->sk_receive_queue)->len;
 		else
 			answ = 0;
 		release_sock(sk);
 		return put_user(answ, (int __user *)arg);
 	}
 	return -ENOIOCTLCMD;
 }
 static int pep_init(struct sock *sk)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	INIT_HLIST_HEAD(&pn->ackq);
 	INIT_HLIST_HEAD(&pn->hlist);
 	skb_queue_head_init(&pn->ctrlreq_queue);
 	pn->pipe_handle = PN_PIPE_INVALID_HANDLE;
 	return 0;
 }
 static int pep_setsockopt(struct sock *sk, int level, int optname,
 				char __user *optval, unsigned int optlen)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	int val = 0, err = 0;
 	if (level != SOL_PNPIPE)
 		return -ENOPROTOOPT;
 	if (optlen >= sizeof(int)) {
 		if (get_user(val, (int __user *) optval))
 			return -EFAULT;
 	}
 	lock_sock(sk);
 	switch (optname) {
 	case PNPIPE_ENCAP:
 		if (val && val != PNPIPE_ENCAP_IP) {
 			err = -EINVAL;
 			break;
 		}
 		if (!pn->ifindex == !val)
 			break; /* Nothing to do! */
 		if (!capable(CAP_NET_ADMIN)) {
 			err = -EPERM;
 			break;
 		}
 		if (val) {
 			release_sock(sk);
 			err = gprs_attach(sk);
 			if (err > 0) {
 				pn->ifindex = err;
 				err = 0;
 			}
 		} else {
 			pn->ifindex = 0;
 			release_sock(sk);
 			gprs_detach(sk);
 			err = 0;
 		}
 		goto out_norel;
 	default:
 		err = -ENOPROTOOPT;
 	}
 	release_sock(sk);
 out_norel:
 	return err;
 }
 static int pep_getsockopt(struct sock *sk, int level, int optname,
 				char __user *optval, int __user *optlen)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	int len, val;
 	if (level != SOL_PNPIPE)
 		return -ENOPROTOOPT;
 	if (get_user(len, optlen))
 		return -EFAULT;
 	switch (optname) {
 	case PNPIPE_ENCAP:
 		val = pn->ifindex ? PNPIPE_ENCAP_IP : PNPIPE_ENCAP_NONE;
 		break;
 	case PNPIPE_IFINDEX:
 		val = pn->ifindex;
 		break;
 	default:
 		return -ENOPROTOOPT;
 	}
 	len = min_t(unsigned int, sizeof(int), len);
 	if (put_user(len, optlen))
 		return -EFAULT;
 	if (put_user(val, (int __user *) optval))
 		return -EFAULT;
 	return 0;
 }
 static int pipe_skb_send(struct sock *sk, struct sk_buff *skb)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct pnpipehdr *ph;
 	if (pn_flow_safe(pn->tx_fc) &&
 	    !atomic_add_unless(&pn->tx_credits, -1, 0)) {
 		kfree_skb(skb);
 		return -ENOBUFS;
 	}
 	skb_push(skb, 3 + pn->aligned);
 	skb_reset_transport_header(skb);
 	ph = pnp_hdr(skb);
 	ph->utid = 0;
 	if (pn->aligned) {
 		ph->message_id = PNS_PIPE_ALIGNED_DATA;
 		ph->data[0] = 0; /* padding */
 	} else
 		ph->message_id = PNS_PIPE_DATA;
 	ph->pipe_handle = pn->pipe_handle;
 	return pn_skb_send(sk, skb, &pipe_srv);
 }
 static int pep_sendmsg(struct kiocb *iocb, struct sock *sk,
 			struct msghdr *msg, size_t len)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct sk_buff *skb;
 	long timeo;
 	int flags = msg->msg_flags;
 	int err, done;
 	if ((msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|
 				MSG_CMSG_COMPAT)) ||
 			!(msg->msg_flags & MSG_EOR))
 		return -EOPNOTSUPP;
 	skb = sock_alloc_send_skb(sk, MAX_PNPIPE_HEADER + len,
 					flags & MSG_DONTWAIT, &err);
 	if (!skb)
 		return -ENOBUFS;
 	skb_reserve(skb, MAX_PHONET_HEADER + 3);
 	err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
 	if (err < 0)
 		goto outfree;
 	lock_sock(sk);
 	timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
 	if ((1 << sk->sk_state) & (TCPF_LISTEN|TCPF_CLOSE)) {
 		err = -ENOTCONN;
 		goto out;
 	}
 	if (sk->sk_state != TCP_ESTABLISHED) {
 		/* Wait until the pipe gets to enabled state */
 disabled:
 		err = sk_stream_wait_connect(sk, &timeo);
 		if (err)
 			goto out;
 		if (sk->sk_state == TCP_CLOSE_WAIT) {
 			err = -ECONNRESET;
 			goto out;
 		}
 	}
 	BUG_ON(sk->sk_state != TCP_ESTABLISHED);
 	/* Wait until flow control allows TX */
 	done = atomic_read(&pn->tx_credits);
 	while (!done) {
 		DEFINE_WAIT(wait);
 		if (!timeo) {
 			err = -EAGAIN;
 			goto out;
 		}
 		if (signal_pending(current)) {
 			err = sock_intr_errno(timeo);
 			goto out;
 		}
 		prepare_to_wait(sk_sleep(sk), &wait,
 				TASK_INTERRUPTIBLE);
 		done = sk_wait_event(sk, &timeo, atomic_read(&pn->tx_credits));
 		finish_wait(sk_sleep(sk), &wait);
 		if (sk->sk_state != TCP_ESTABLISHED)
 			goto disabled;
 	}
 	err = pipe_skb_send(sk, skb);
 	if (err >= 0)
 		err = len; /* success! */
 	skb = NULL;
 out:
 	release_sock(sk);
 outfree:
 	kfree_skb(skb);
 	return err;
 }
 int pep_writeable(struct sock *sk)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	return atomic_read(&pn->tx_credits);
 }
 int pep_write(struct sock *sk, struct sk_buff *skb)
 {
 	struct sk_buff *rskb, *fs;
 	int flen = 0;
 	if (pep_sk(sk)->aligned)
 		return pipe_skb_send(sk, skb);
 	rskb = alloc_skb(MAX_PNPIPE_HEADER, GFP_ATOMIC);
 	if (!rskb) {
 		kfree_skb(skb);
 		return -ENOMEM;
 	}
 	skb_shinfo(rskb)->frag_list = skb;
 	rskb->len += skb->len;
 	rskb->data_len += rskb->len;
 	rskb->truesize += rskb->len;
 	/* Avoid nested fragments */
 	skb_walk_frags(skb, fs)
 		flen += fs->len;
 	skb->next = skb_shinfo(skb)->frag_list;
 	skb_frag_list_init(skb);
 	skb->len -= flen;
 	skb->data_len -= flen;
 	skb->truesize -= flen;
 	skb_reserve(rskb, MAX_PHONET_HEADER + 3);
 	return pipe_skb_send(sk, rskb);
 }
 struct sk_buff *pep_read(struct sock *sk)
 {
 	struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
 	if (sk->sk_state == TCP_ESTABLISHED)
 		pipe_grant_credits(sk);
 	return skb;
 }
 static int pep_recvmsg(struct kiocb *iocb, struct sock *sk,
 			struct msghdr *msg, size_t len, int noblock,
 			int flags, int *addr_len)
 {
 	struct sk_buff *skb;
 	int err;
 	if (flags & ~(MSG_OOB|MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_WAITALL|
 			MSG_NOSIGNAL|MSG_CMSG_COMPAT))
 		return -EOPNOTSUPP;
 	if (unlikely(1 << sk->sk_state & (TCPF_LISTEN | TCPF_CLOSE)))
 		return -ENOTCONN;
 	if ((flags & MSG_OOB) || sock_flag(sk, SOCK_URGINLINE)) {
 		/* Dequeue and acknowledge control request */
 		struct pep_sock *pn = pep_sk(sk);
 		if (flags & MSG_PEEK)
 			return -EOPNOTSUPP;
 		skb = skb_dequeue(&pn->ctrlreq_queue);
 		if (skb) {
 			pep_ctrlreq_error(sk, skb, PN_PIPE_NO_ERROR,
 						GFP_KERNEL);
 			msg->msg_flags |= MSG_OOB;
 			goto copy;
 		}
 		if (flags & MSG_OOB)
 			return -EINVAL;
 	}
 	skb = skb_recv_datagram(sk, flags, noblock, &err);
 	lock_sock(sk);
 	if (skb == NULL) {
 		if (err == -ENOTCONN && sk->sk_state == TCP_CLOSE_WAIT)
 			err = -ECONNRESET;
 		release_sock(sk);
 		return err;
 	}
 	if (sk->sk_state == TCP_ESTABLISHED)
 		pipe_grant_credits(sk);
 	release_sock(sk);
 copy:
 	msg->msg_flags |= MSG_EOR;
 	if (skb->len > len)
 		msg->msg_flags |= MSG_TRUNC;
 	else
 		len = skb->len;
 	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, len);
 	if (!err)
 		err = (flags & MSG_TRUNC) ? skb->len : len;
 	skb_free_datagram(sk, skb);
 	return err;
 }
 static void pep_sock_unhash(struct sock *sk)
 {
 	struct pep_sock *pn = pep_sk(sk);
 	struct sock *skparent = NULL;
 	lock_sock(sk);
 	if ((1 << sk->sk_state) & ~(TCPF_CLOSE|TCPF_LISTEN)) {
 		skparent = pn->listener;
 		release_sock(sk);
 		pn = pep_sk(skparent);
 		lock_sock(skparent);
 		sk_del_node_init(sk);
 		sk = skparent;
 	}
 	/* Unhash a listening sock only when it is closed
 	 * and all of its active connected pipes are closed. */
 	if (hlist_empty(&pn->hlist))
 		pn_sock_unhash(&pn->pn_sk.sk);
 	release_sock(sk);
 	if (skparent)
 		sock_put(skparent);
 }
 static struct proto pep_proto = {
 	.close		= pep_sock_close,
 	.accept		= pep_sock_accept,
 	.ioctl		= pep_ioctl,
 	.init		= pep_init,
 	.setsockopt	= pep_setsockopt,
 	.getsockopt	= pep_getsockopt,
 	.sendmsg	= pep_sendmsg,
 	.recvmsg	= pep_recvmsg,
 	.backlog_rcv	= pep_do_rcv,
 	.hash		= pn_sock_hash,
 	.unhash		= pep_sock_unhash,
 	.get_port	= pn_sock_get_port,
 	.obj_size	= sizeof(struct pep_sock),
 	.owner		= THIS_MODULE,
 	.name		= "PNPIPE",
 };
 static struct phonet_protocol pep_pn_proto = {
 	.ops		= &phonet_stream_ops,
 	.prot		= &pep_proto,
 	.sock_type	= SOCK_SEQPACKET,
 };
 static int __init pep_register(void)
 {
 	return phonet_proto_register(PN_PROTO_PIPE, &pep_pn_proto);
 }
 static void __exit pep_unregister(void)
 {
 	phonet_proto_unregister(PN_PROTO_PIPE, &pep_pn_proto);
 }
 module_init(pep_register);
 module_exit(pep_unregister);
 MODULE_AUTHOR("Remi Denis-Courmont, Nokia");
 MODULE_DESCRIPTION("Phonet pipe protocol");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_NET_PF_PROTO(PF_PHONET, PN_PROTO_PIPE);

1	/******************************************************************************	1	/******************************************************************************
2	*	2	*
3	* GPL LICENSE SUMMARY	3	* GPL LICENSE SUMMARY
4	*	4	*
5	* Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.	5	* Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
6	*	6	*
7	* This program is free software; you can redistribute it and/or modify	7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of version 2 of the GNU General Public License as	8	* it under the terms of version 2 of the GNU General Public License as
9	* published by the Free Software Foundation.	9	* published by the Free Software Foundation.
10	*	10	*
11	* This program is distributed in the hope that it will be useful, but	11	* This program is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* General Public License for more details.	14	* General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
19	* USA	19	* USA
20	*	20	*
21	* The full GNU General Public License is included in this distribution	21	* The full GNU General Public License is included in this distribution
22	* in the file called LICENSE.GPL.	22	* in the file called LICENSE.GPL.
23	*	23	*
24	* Contact Information:	24	* Contact Information:
25	* Intel Linux Wireless <ilw@linux.intel.com>	25	* Intel Linux Wireless <ilw@linux.intel.com>
26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497	26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27	*	27	*
28	*****************************************************************************/	28	*****************************************************************************/
29	#include <linux/etherdevice.h>	29	#include <linux/etherdevice.h>
30	#include <linux/kernel.h>	30	#include <linux/kernel.h>
31	#include <linux/module.h>	31	#include <linux/module.h>
32	#include <linux/init.h>	32	#include <linux/init.h>
33	#include <linux/sched.h>	33	#include <linux/sched.h>
34		34
35	#include "iwl-dev.h"	35	#include "iwl-dev.h"
36	#include "iwl-core.h"	36	#include "iwl-core.h"
37	#include "iwl-io.h"	37	#include "iwl-io.h"
38	#include "iwl-helpers.h"	38	#include "iwl-helpers.h"
39	#include "iwl-agn-hw.h"	39	#include "iwl-agn-hw.h"
40	#include "iwl-agn.h"	40	#include "iwl-agn.h"

1	/******************************************************************************	1	/******************************************************************************
2	*	2	*
3	* Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved.	3	* Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved.
4	*	4	*
5	* Portions of this file are derived from the ipw3945 project, as well	5	* Portions of this file are derived from the ipw3945 project, as well
6	* as portions of the ieee80211 subsystem header files.	6	* as portions of the ieee80211 subsystem header files.
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify it	8	* This program is free software; you can redistribute it and/or modify it
9	* under the terms of version 2 of the GNU General Public License as	9	* under the terms of version 2 of the GNU General Public License as
10	* published by the Free Software Foundation.	10	* published by the Free Software Foundation.
11	*	11	*
12	* This program is distributed in the hope that it will be useful, but WITHOUT	12	* This program is distributed in the hope that it will be useful, but WITHOUT
13	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or	13	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for	14	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15	* more details.	15	* more details.
16	*	16	*
17	* You should have received a copy of the GNU General Public License along with	17	* You should have received a copy of the GNU General Public License along with
18	* this program; if not, write to the Free Software Foundation, Inc.,	18	* this program; if not, write to the Free Software Foundation, Inc.,
19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20	*	20	*
21	* The full GNU General Public License is included in this distribution in the	21	* The full GNU General Public License is included in this distribution in the
22	* file called LICENSE.	22	* file called LICENSE.
23	*	23	*
24	* Contact Information:	24	* Contact Information:
25	* Intel Linux Wireless <ilw@linux.intel.com>	25	* Intel Linux Wireless <ilw@linux.intel.com>
26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497	26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27	*	27	*
28	*****************************************************************************/	28	*****************************************************************************/
29		29
30	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt	30	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31		31
32	#include <linux/kernel.h>	32	#include <linux/kernel.h>
33	#include <linux/module.h>	33	#include <linux/module.h>
34	#include <linux/init.h>	34	#include <linux/init.h>
35	#include <linux/pci.h>	35	#include <linux/pci.h>
36	#include <linux/slab.h>	36	#include <linux/slab.h>
37	#include <linux/dma-mapping.h>	37	#include <linux/dma-mapping.h>
38	#include <linux/delay.h>	38	#include <linux/delay.h>
39	#include <linux/sched.h>	39	#include <linux/sched.h>
40	#include <linux/skbuff.h>	40	#include <linux/skbuff.h>