43 files changed, 367 insertions, 78 deletions

diff --git a/net/atm/Makefile b/net/atm/Makefile
index d5818751f6ba..89656d6c0b90 100644
--- a/net/atm/Makefile
+++ b/net/atm/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the ATM Protocol Families.
 #
 
-atm-y           := addr.o pvc.o signaling.o svc.o ioctl.o common.o atm_misc.o raw.o resources.o
+atm-y           := addr.o pvc.o signaling.o svc.o ioctl.o common.o atm_misc.o raw.o resources.o atm_sysfs.o
 mpoa-objs       := mpc.o mpoa_caches.o mpoa_proc.o
 
 obj-$(CONFIG_ATM) += atm.o
diff --git a/net/atm/atm_sysfs.c b/net/atm/atm_sysfs.c
new file mode 100644
index 000000000000..5df4b9a068bb
--- /dev/null
+++ b/net/atm/atm_sysfs.c
@@ -0,0 +1,176 @@
+/* ATM driver model support. */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/kobject.h>
+#include <linux/atmdev.h>
+#include "common.h"
+#include "resources.h"
+
+#define to_atm_dev(cldev) container_of(cldev, struct atm_dev, class_dev)
+
+static ssize_t show_type(struct class_device *cdev, char *buf)
+{
+        struct atm_dev *adev = to_atm_dev(cdev);
+        return sprintf(buf, "%s\n", adev->type);
+}
+
+static ssize_t show_address(struct class_device *cdev, char *buf)
+{
+        char *pos = buf;
+        struct atm_dev *adev = to_atm_dev(cdev);
+        int i;
+
+        for (i = 0; i < (ESI_LEN - 1); i++)
+                pos += sprintf(pos, "%02x:", adev->esi[i]);
+        pos += sprintf(pos, "%02x\n", adev->esi[i]);
+
+        return pos - buf;
+}
+
+static ssize_t show_atmaddress(struct class_device *cdev, char *buf)
+{
+        unsigned long flags;
+        char *pos = buf;
+        struct atm_dev *adev = to_atm_dev(cdev);
+        struct atm_dev_addr *aaddr;
+        int bin[] = { 1, 2, 10, 6, 1 }, *fmt = bin;
+        int i, j;
+
+        spin_lock_irqsave(&adev->lock, flags);
+        list_for_each_entry(aaddr, &adev->local, entry) {
+                for(i = 0, j = 0; i < ATM_ESA_LEN; ++i, ++j) {
+                        if (j == *fmt) {
+                                pos += sprintf(pos, ".");
+                                ++fmt;
+                                j = 0;
+                        }
+                        pos += sprintf(pos, "%02x", aaddr->addr.sas_addr.prv[i]);
+                }
+                pos += sprintf(pos, "\n");
+        }
+        spin_unlock_irqrestore(&adev->lock, flags);
+
+        return pos - buf;
+}
+
+static ssize_t show_carrier(struct class_device *cdev, char *buf)
+{
+        char *pos = buf;
+        struct atm_dev *adev = to_atm_dev(cdev);
+
+        pos += sprintf(pos, "%d\n",
+                       adev->signal == ATM_PHY_SIG_LOST ? 0 : 1);
+                
+        return pos - buf;
+}
+
+static ssize_t show_link_rate(struct class_device *cdev, char *buf)
+{
+        char *pos = buf;
+        struct atm_dev *adev = to_atm_dev(cdev);
+        int link_rate;
+
+        /* show the link rate, not the data rate */
+        switch (adev->link_rate) {
+                case ATM_OC3_PCR:
+                        link_rate = 155520000;
+                        break;
+                case ATM_OC12_PCR:
+                        link_rate = 622080000;
+                        break;
+                case ATM_25_PCR:
+                        link_rate = 25600000;
+                        break;
+                default:
+                        link_rate = adev->link_rate * 8 * 53;
+        }
+        pos += sprintf(pos, "%d\n", link_rate);
+                
+        return pos - buf;
+}
+
+static CLASS_DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
+static CLASS_DEVICE_ATTR(atmaddress, S_IRUGO, show_atmaddress, NULL);
+static CLASS_DEVICE_ATTR(carrier, S_IRUGO, show_carrier, NULL);
+static CLASS_DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
+static CLASS_DEVICE_ATTR(link_rate, S_IRUGO, show_link_rate, NULL);
+
+static struct class_device_attribute *atm_attrs[] = {
+        &class_device_attr_atmaddress,
+        &class_device_attr_address,
+        &class_device_attr_carrier,
+        &class_device_attr_type,
+        &class_device_attr_link_rate,
+        NULL
+};
+
+static int atm_uevent(struct class_device *cdev, char **envp, int num_envp, char *buf, int size)
+{
+        struct atm_dev *adev;
+        int i = 0, len = 0;
+
+        if (!cdev)
+                return -ENODEV;
+
+        adev = to_atm_dev(cdev);
+        if (!adev)
+                return -ENODEV;
+
+        if (add_uevent_var(envp, num_envp, &i, buf, size, &len,
+                           "NAME=%s%d", adev->type, adev->number))
+                return -ENOMEM;
+
+        envp[i] = NULL;
+        return 0;
+}
+
+static void atm_release(struct class_device *cdev)
+{
+        struct atm_dev *adev = to_atm_dev(cdev);
+
+        kfree(adev);
+}
+
+static struct class atm_class = {
+        .name           = "atm",
+        .release        = atm_release,
+        .uevent         = atm_uevent,
+};
+
+int atm_register_sysfs(struct atm_dev *adev)
+{
+        struct class_device *cdev = &adev->class_dev;
+        int i, err;
+
+        cdev->class = &atm_class;
+        class_set_devdata(cdev, adev);
+
+        snprintf(cdev->class_id, BUS_ID_SIZE, "%s%d", adev->type, adev->number);
+        err = class_device_register(cdev);
+        if (err < 0)
+                return err;
+
+        for (i = 0; atm_attrs[i]; i++)
+                class_device_create_file(cdev, atm_attrs[i]);
+
+        return 0;
+}
+
+void atm_unregister_sysfs(struct atm_dev *adev)
+{
+        struct class_device *cdev = &adev->class_dev;
+
+        class_device_del(cdev);
+}
+
+int __init atm_sysfs_init(void)
+{
+        return class_register(&atm_class);
+}
+
+void __exit atm_sysfs_exit(void)
+{
+        class_unregister(&atm_class);
+}
diff --git a/net/atm/common.c b/net/atm/common.c
index ae002220fa99..35ab1a61e831 100644
--- a/net/atm/common.c
+++ b/net/atm/common.c
@@ -791,8 +791,14 @@ static int __init atm_init(void)
                 printk(KERN_ERR "atm_proc_init() failed with %d\n",error);
                 goto out_atmsvc_exit;
         }
+        if ((error = atm_sysfs_init()) < 0) {
+                printk(KERN_ERR "atm_sysfs_init() failed with %d\n",error);
+                goto out_atmproc_exit;
+        }
 out:
         return error;
+out_atmproc_exit:
+        atm_proc_exit();
 out_atmsvc_exit:
         atmsvc_exit();
 out_atmpvc_exit:
@@ -805,6 +811,7 @@ out_unregister_vcc_proto:
 static void __exit atm_exit(void)
 {
         atm_proc_exit();
+        atm_sysfs_exit();
         atmsvc_exit();
         atmpvc_exit();
         proto_unregister(&vcc_proto);
diff --git a/net/atm/common.h b/net/atm/common.h
index 4887c317cefe..a422da7788fb 100644
--- a/net/atm/common.h
+++ b/net/atm/common.h
@@ -28,6 +28,8 @@ int atmpvc_init(void);
 void atmpvc_exit(void);
 int atmsvc_init(void);
 void atmsvc_exit(void);
+int atm_sysfs_init(void);
+void atm_sysfs_exit(void);
 
 #ifdef CONFIG_PROC_FS
 int atm_proc_init(void);
diff --git a/net/atm/resources.c b/net/atm/resources.c
index 18ac80698f83..534baf704056 100644
--- a/net/atm/resources.c
+++ b/net/atm/resources.c
@@ -114,14 +114,27 @@ struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops,
                 printk(KERN_ERR "atm_dev_register: "
                        "atm_proc_dev_register failed for dev %s\n",
                        type);
-                mutex_unlock(&atm_dev_mutex);
-                kfree(dev);
-                return NULL;
+                goto out_fail;
+        }
+
+        if (atm_register_sysfs(dev) < 0) {
+                printk(KERN_ERR "atm_dev_register: "
+                       "atm_register_sysfs failed for dev %s\n",
+                       type);
+                atm_proc_dev_deregister(dev);
+                goto out_fail;
         }
+
         list_add_tail(&dev->dev_list, &atm_devs);
-        mutex_unlock(&atm_dev_mutex);
 
+out:
+        mutex_unlock(&atm_dev_mutex);
         return dev;
+
+out_fail:
+        kfree(dev);
+        dev = NULL;
+        goto out;
 }
 
 
@@ -140,6 +153,7 @@ void atm_dev_deregister(struct atm_dev *dev)
         mutex_unlock(&atm_dev_mutex);
 
         atm_dev_release_vccs(dev);
+        atm_unregister_sysfs(dev);
         atm_proc_dev_deregister(dev);
 
         atm_dev_put(dev);
diff --git a/net/atm/resources.h b/net/atm/resources.h
index ac7222fee7a8..644989980c37 100644
--- a/net/atm/resources.h
+++ b/net/atm/resources.h
@@ -43,4 +43,6 @@ static inline void atm_proc_dev_deregister(struct atm_dev *dev)
 
 #endif /* CONFIG_PROC_FS */
 
+int atm_register_sysfs(struct atm_dev *adev);
+void atm_unregister_sysfs(struct atm_dev *adev);
 #endif
diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c
index 2afdc7c0736c..f8dbcee80eba 100644
--- a/net/bridge/br_device.c
+++ b/net/bridge/br_device.c
@@ -184,6 +184,6 @@ void br_dev_setup(struct net_device *dev)
         dev->set_mac_address = br_set_mac_address;
         dev->priv_flags = IFF_EBRIDGE;
 
-        dev->features = NETIF_F_SG | NETIF_F_FRAGLIST
-                | NETIF_F_HIGHDMA | NETIF_F_TSO | NETIF_F_NO_CSUM;
+        dev->features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
+                        NETIF_F_TSO | NETIF_F_NO_CSUM | NETIF_F_GSO_ROBUST;
 }
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index 07956ecf545e..f55ef682ef84 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -392,7 +392,8 @@ void br_features_recompute(struct net_bridge *br)
                 features &= feature;
         }
 
-        br->dev->features = features | checksum | NETIF_F_LLTX;
+        br->dev->features = features | checksum | NETIF_F_LLTX |
+                            NETIF_F_GSO_ROBUST;
 }
 
 /* called with RTNL */
diff --git a/net/core/dev.c b/net/core/dev.c
index f1c52cbd6ef7..08976b08df5b 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1190,11 +1190,14 @@ out:
 /**
  *      skb_gso_segment - Perform segmentation on skb.
  *      @skb: buffer to segment
- *      @sg: whether scatter-gather is supported on the target.
+ *      @features: features for the output path (see dev->features)
  *
  *      This function segments the given skb and returns a list of segments.
+ *
+ *      It may return NULL if the skb requires no segmentation.  This is
+ *      only possible when GSO is used for verifying header integrity.
  */
-struct sk_buff *skb_gso_segment(struct sk_buff *skb, int sg)
+struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
 {
         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
         struct packet_type *ptype;
@@ -1210,12 +1213,14 @@ struct sk_buff *skb_gso_segment(struct sk_buff *skb, int sg)
         rcu_read_lock();
         list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & 15], list) {
                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
-                        segs = ptype->gso_segment(skb, sg);
+                        segs = ptype->gso_segment(skb, features);
                         break;
                 }
         }
         rcu_read_unlock();
 
+        __skb_push(skb, skb->data - skb->mac.raw);
+
         return segs;
 }
 
@@ -1234,7 +1239,6 @@ void netdev_rx_csum_fault(struct net_device *dev)
 EXPORT_SYMBOL(netdev_rx_csum_fault);
 #endif
 
-#ifdef CONFIG_HIGHMEM
 /* Actually, we should eliminate this check as soon as we know, that:
  * 1. IOMMU is present and allows to map all the memory.
  * 2. No high memory really exists on this machine.
@@ -1242,6 +1246,7 @@ EXPORT_SYMBOL(netdev_rx_csum_fault);
 
 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
 {
+#ifdef CONFIG_HIGHMEM
         int i;
 
         if (dev->features & NETIF_F_HIGHDMA)
@@ -1251,11 +1256,9 @@ static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
                         return 1;
 
+#endif
         return 0;
 }
-#else
-#define illegal_highdma(dev, skb)       (0)
-#endif
 
 struct dev_gso_cb {
         void (*destructor)(struct sk_buff *skb);
@@ -1291,9 +1294,15 @@ static int dev_gso_segment(struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
         struct sk_buff *segs;
+        int features = dev->features & ~(illegal_highdma(dev, skb) ?
+                                         NETIF_F_SG : 0);
+
+        segs = skb_gso_segment(skb, features);
+
+        /* Verifying header integrity only. */
+        if (!segs)
+                return 0;
 
-        segs = skb_gso_segment(skb, dev->features & NETIF_F_SG &&
-                                    !illegal_highdma(dev, skb));
         if (unlikely(IS_ERR(segs)))
                 return PTR_ERR(segs);
 
@@ -1310,13 +1319,17 @@ int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (netdev_nit)
                         dev_queue_xmit_nit(skb, dev);
 
-                if (!netif_needs_gso(dev, skb))
-                        return dev->hard_start_xmit(skb, dev);
+                if (netif_needs_gso(dev, skb)) {
+                        if (unlikely(dev_gso_segment(skb)))
+                                goto out_kfree_skb;
+                        if (skb->next)
+                                goto gso;
+                }
 
-                if (unlikely(dev_gso_segment(skb)))
-                        goto out_kfree_skb;
+                return dev->hard_start_xmit(skb, dev);
         }
 
+gso:
         do {
                 struct sk_buff *nskb = skb->next;
                 int rc;
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 3fcfa9c59e1f..f25aac17497a 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -663,7 +663,7 @@ rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp)
         sz_idx = type>>2;
         kind = type&3;
 
-        if (kind != 2 && security_netlink_recv(skb)) {
+        if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN)) {
                 *errp = -EPERM;
                 return -1;
         }
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 6edbb90cbcec..a1c9ecf4f1e0 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -272,7 +272,7 @@ static void skb_clone_fraglist(struct sk_buff *skb)
                 skb_get(list);
 }
 
-void skb_release_data(struct sk_buff *skb)
+static void skb_release_data(struct sk_buff *skb)
 {
         if (!skb->cloned ||
             !atomic_sub_return(skb->nohdr ? (1 << SKB_DATAREF_SHIFT) + 1 : 1,
@@ -1848,13 +1848,13 @@ EXPORT_SYMBOL_GPL(skb_pull_rcsum);
 /**
  *      skb_segment - Perform protocol segmentation on skb.
  *      @skb: buffer to segment
- *      @sg: whether scatter-gather can be used for generated segments
+ *      @features: features for the output path (see dev->features)
  *
  *      This function performs segmentation on the given skb.  It returns
  *      the segment at the given position.  It returns NULL if there are
  *      no more segments to generate, or when an error is encountered.
  */
-struct sk_buff *skb_segment(struct sk_buff *skb, int sg)
+struct sk_buff *skb_segment(struct sk_buff *skb, int features)
 {
         struct sk_buff *segs = NULL;
         struct sk_buff *tail = NULL;
@@ -1863,6 +1863,7 @@ struct sk_buff *skb_segment(struct sk_buff *skb, int sg)
         unsigned int offset = doffset;
         unsigned int headroom;
         unsigned int len;
+        int sg = features & NETIF_F_SG;
         int nfrags = skb_shinfo(skb)->nr_frags;
         int err = -ENOMEM;
         int i = 0;
diff --git a/net/core/sock.c b/net/core/sock.c
index 5d820c376653..204a8dec65cc 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -565,6 +565,13 @@ set_rcvbuf:
                         ret = -ENONET;
                         break;
 
+                case SO_PASSSEC:
+                        if (valbool)
+                                set_bit(SOCK_PASSSEC, &sock->flags);
+                        else
+                                clear_bit(SOCK_PASSSEC, &sock->flags);
+                        break;
+
                 /* We implement the SO_SNDLOWAT etc to
                    not be settable (1003.1g 5.3) */
                 default:
@@ -723,6 +730,10 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
                         v.val = sk->sk_state == TCP_LISTEN;
                         break;
 
+                case SO_PASSSEC:
+                        v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
+                        break;
+
                 case SO_PEERSEC:
                         return security_socket_getpeersec_stream(sock, optval, optlen, len);
 
diff --git a/net/decnet/netfilter/dn_rtmsg.c b/net/decnet/netfilter/dn_rtmsg.c
index 74133ecd7700..8b99bd33540d 100644
--- a/net/decnet/netfilter/dn_rtmsg.c
+++ b/net/decnet/netfilter/dn_rtmsg.c
@@ -107,7 +107,7 @@ static inline void dnrmg_receive_user_skb(struct sk_buff *skb)
         if (nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len)
                 return;
 
-        if (!cap_raised(NETLINK_CB(skb).eff_cap, CAP_NET_ADMIN))
+        if (security_netlink_recv(skb, CAP_NET_ADMIN))
                 RCV_SKB_FAIL(-EPERM);
 
         /* Eventually we might send routing messages too */
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 461216b47948..8d157157bf8e 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1097,7 +1097,7 @@ int inet_sk_rebuild_header(struct sock *sk)
 
 EXPORT_SYMBOL(inet_sk_rebuild_header);
 
-static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int sg)
+static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int features)
 {
         struct sk_buff *segs = ERR_PTR(-EINVAL);
         struct iphdr *iph;
@@ -1126,10 +1126,10 @@ static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int sg)
         rcu_read_lock();
         ops = rcu_dereference(inet_protos[proto]);
         if (ops && ops->gso_segment)
-                segs = ops->gso_segment(skb, sg);
+                segs = ops->gso_segment(skb, features);
         rcu_read_unlock();
 
-        if (IS_ERR(segs))
+        if (!segs || unlikely(IS_ERR(segs)))
                 goto out;
 
         skb = segs;
diff --git a/net/ipv4/netfilter/Kconfig b/net/ipv4/netfilter/Kconfig
index e1d7f5fbc526..ef0b5aac5838 100644
--- a/net/ipv4/netfilter/Kconfig
+++ b/net/ipv4/netfilter/Kconfig
@@ -332,7 +332,7 @@ config IP_NF_MATCH_HASHLIMIT
         help
           This option adds a new iptables `hashlimit' match.  
 
-          As opposed to `limit', this match dynamically crates a hash table
+          As opposed to `limit', this match dynamically creates a hash table
           of limit buckets, based on your selection of source/destination
           ip addresses and/or ports.
 
diff --git a/net/ipv4/netfilter/arp_tables.c b/net/ipv4/netfilter/arp_tables.c
index d0d19192026d..ad39bf640567 100644
--- a/net/ipv4/netfilter/arp_tables.c
+++ b/net/ipv4/netfilter/arp_tables.c
@@ -1120,7 +1120,8 @@ int arpt_register_table(struct arpt_table *table,
                 return ret;
         }
 
-        if (xt_register_table(table, &bootstrap, newinfo) != 0) {
+        ret = xt_register_table(table, &bootstrap, newinfo);
+        if (ret != 0) {
                 xt_free_table_info(newinfo);
                 return ret;
         }
diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index b93f0494362f..198ac36db861 100644
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -457,11 +457,19 @@ dev_cmp(struct ipq_queue_entry *entry, unsigned long ifindex)
         if (entry->info->indev)
                 if (entry->info->indev->ifindex == ifindex)
                         return 1;
-                        
         if (entry->info->outdev)
                 if (entry->info->outdev->ifindex == ifindex)
                         return 1;
-
+#ifdef CONFIG_BRIDGE_NETFILTER
+        if (entry->skb->nf_bridge) {
+                if (entry->skb->nf_bridge->physindev &&
+                    entry->skb->nf_bridge->physindev->ifindex == ifindex)
+                        return 1;
+                if (entry->skb->nf_bridge->physoutdev &&
+                    entry->skb->nf_bridge->physoutdev->ifindex == ifindex)
+                        return 1;
+        }
+#endif
         return 0;
 }
 
@@ -507,7 +515,7 @@ ipq_rcv_skb(struct sk_buff *skb)
         if (type <= IPQM_BASE)
                 return;
                 
-        if (security_netlink_recv(skb))
+        if (security_netlink_recv(skb, CAP_NET_ADMIN))
                 RCV_SKB_FAIL(-EPERM);
         
         write_lock_bh(&queue_lock);
diff --git a/net/ipv4/netfilter/ip_tables.c b/net/ipv4/netfilter/ip_tables.c
index 706c0025ec5e..7aaaf92efb59 100644
--- a/net/ipv4/netfilter/ip_tables.c
+++ b/net/ipv4/netfilter/ip_tables.c
@@ -2113,7 +2113,8 @@ int ipt_register_table(struct xt_table *table, const struct ipt_replace *repl)
                 return ret;
         }
 
-        if (xt_register_table(table, &bootstrap, newinfo) != 0) {
+        ret = xt_register_table(table, &bootstrap, newinfo);
+        if (ret != 0) {
                 xt_free_table_info(newinfo);
                 return ret;
         }
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index c04176be7ed1..0336422c88a0 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -2145,7 +2145,7 @@ int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
 EXPORT_SYMBOL(compat_tcp_getsockopt);
 #endif
 
-struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int sg)
+struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int features)
 {
         struct sk_buff *segs = ERR_PTR(-EINVAL);
         struct tcphdr *th;
@@ -2166,10 +2166,14 @@ struct sk_buff *tcp_tso_segment(struct sk_buff *skb, int sg)
         if (!pskb_may_pull(skb, thlen))
                 goto out;
 
+        segs = NULL;
+        if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST))
+                goto out;
+
         oldlen = (u16)~skb->len;
         __skb_pull(skb, thlen);
 
-        segs = skb_segment(skb, sg);
+        segs = skb_segment(skb, features);
         if (IS_ERR(segs))
                 goto out;
 
diff --git a/net/ipv4/tcp_diag.c b/net/ipv4/tcp_diag.c
index c148c1081880..b56399c7cc12 100644
--- a/net/ipv4/tcp_diag.c
+++ b/net/ipv4/tcp_diag.c
@@ -26,7 +26,10 @@ static void tcp_diag_get_info(struct sock *sk, struct inet_diag_msg *r,
         const struct tcp_sock *tp = tcp_sk(sk);
         struct tcp_info *info = _info;
 
-        r->idiag_rqueue = tp->rcv_nxt - tp->copied_seq;
+        if (sk->sk_state == TCP_LISTEN)
+                r->idiag_rqueue = sk->sk_ack_backlog;
+        else
+                r->idiag_rqueue = tp->rcv_nxt - tp->copied_seq;
         r->idiag_wqueue = tp->write_seq - tp->snd_una;
         if (info != NULL)
                 tcp_get_info(sk, info);
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 94fe5b1f9dcb..7fa0b4a8a389 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -4178,8 +4178,6 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
                  */
 
                 TCP_ECN_rcv_synack(tp, th);
-                if (tp->ecn_flags&TCP_ECN_OK)
-                        sock_set_flag(sk, SOCK_NO_LARGESEND);
 
                 tp->snd_wl1 = TCP_SKB_CB(skb)->seq;
                 tcp_ack(sk, skb, FLAG_SLOWPATH);
@@ -4322,8 +4320,6 @@ discard:
                 tp->max_window = tp->snd_wnd;
 
                 TCP_ECN_rcv_syn(tp, th);
-                if (tp->ecn_flags&TCP_ECN_OK)
-                        sock_set_flag(sk, SOCK_NO_LARGESEND);
 
                 tcp_mtup_init(sk);
                 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 25ecc6e2478b..4c6ef47eb1c3 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1726,7 +1726,8 @@ static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
                         "%08X %5d %8d %lu %d %p %u %u %u %u %d",
                 i, src, srcp, dest, destp, sp->sk_state,
-                tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
+                tp->write_seq - tp->snd_una,
+                (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
                 timer_active,
                 jiffies_to_clock_t(timer_expires - jiffies),
                 icsk->icsk_retransmits,
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 2b9b7f6c7f7c..54b2ef7d3efe 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -440,8 +440,6 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
                         newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len;
                 newtp->rx_opt.mss_clamp = req->mss;
                 TCP_ECN_openreq_child(newtp, req);
-                if (newtp->ecn_flags&TCP_ECN_OK)
-                        sock_set_flag(newsk, SOCK_NO_LARGESEND);
 
                 TCP_INC_STATS_BH(TCP_MIB_PASSIVEOPENS);
         }
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index bdd71db8bf90..5a7cb4a9c867 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2044,8 +2044,6 @@ struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
         memset(th, 0, sizeof(struct tcphdr));
         th->syn = 1;
         th->ack = 1;
-        if (dst->dev->features&NETIF_F_TSO)
-                ireq->ecn_ok = 0;
         TCP_ECN_make_synack(req, th);
         th->source = inet_sk(sk)->sport;
         th->dest = ireq->rmt_port;
diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index b4b7d441af25..968a14be0d05 100644
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -505,7 +505,7 @@ ipq_rcv_skb(struct sk_buff *skb)
         if (type <= IPQM_BASE)
                 return;
         
-        if (security_netlink_recv(skb))
+        if (security_netlink_recv(skb, CAP_NET_ADMIN))
                 RCV_SKB_FAIL(-EPERM);   
 
         write_lock_bh(&queue_lock);
diff --git a/net/ipv6/netfilter/ip6_tables.c b/net/ipv6/netfilter/ip6_tables.c
index 2e72f89a7019..0b5bd5587a3e 100644
--- a/net/ipv6/netfilter/ip6_tables.c
+++ b/net/ipv6/netfilter/ip6_tables.c
@@ -1281,7 +1281,8 @@ int ip6t_register_table(struct xt_table *table,
                 return ret;
         }
 
-        if (xt_register_table(table, &bootstrap, newinfo) != 0) {
+        ret = xt_register_table(table, &bootstrap, newinfo);
+        if (ret != 0) {
                 xt_free_table_info(newinfo);
                 return ret;
         }
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index a50eb306e9e2..b36d5b2e7c30 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1469,7 +1469,8 @@ static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
                    dest->s6_addr32[0], dest->s6_addr32[1],
                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
                    sp->sk_state, 
-                   tp->write_seq-tp->snd_una, tp->rcv_nxt-tp->copied_seq,
+                   tp->write_seq-tp->snd_una,
+                   (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
                    timer_active,
                    jiffies_to_clock_t(timer_expires - jiffies),
                    icsk->icsk_retransmits,
diff --git a/net/irda/irlan/irlan_client.c b/net/irda/irlan/irlan_client.c
index f8e6cb0db04b..95cf1234ea17 100644
--- a/net/irda/irlan/irlan_client.c
+++ b/net/irda/irlan/irlan_client.c
@@ -173,13 +173,14 @@ void irlan_client_discovery_indication(discinfo_t *discovery,
         rcu_read_lock();
         self = irlan_get_any();
         if (self) {
-                IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+                IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;);
 
                 IRDA_DEBUG(1, "%s(), Found instance (%08x)!\n", __FUNCTION__ ,
                       daddr);
                 
                 irlan_client_wakeup(self, saddr, daddr);
         }
+IRDA_ASSERT_LABEL(out:)
         rcu_read_unlock();
 }
         
diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index b1622b7de1cf..42a178aa30f9 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -411,7 +411,10 @@ config NETFILTER_XT_MATCH_STATISTIC
         tristate '"statistic" match support'
         depends on NETFILTER_XTABLES
         help
-          statistic module
+          This option adds a `statistic' match, which allows you to match
+          on packets periodically or randomly with a given percentage.
+
+          To compile it as a module, choose M here.  If unsure, say N.
 
 config NETFILTER_XT_MATCH_STRING
         tristate  '"string" match support'
diff --git a/net/netfilter/nf_conntrack_netlink.c b/net/netfilter/nf_conntrack_netlink.c
index b8c7c567c9df..af4845971f70 100644
--- a/net/netfilter/nf_conntrack_netlink.c
+++ b/net/netfilter/nf_conntrack_netlink.c
@@ -29,6 +29,7 @@
 #include <linux/errno.h>
 #include <linux/netlink.h>
 #include <linux/spinlock.h>
+#include <linux/interrupt.h>
 #include <linux/notifier.h>
 
 #include <linux/netfilter.h>
diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
index 0c6da496cfa9..0839b701b930 100644
--- a/net/netfilter/nf_conntrack_proto_sctp.c
+++ b/net/netfilter/nf_conntrack_proto_sctp.c
@@ -28,6 +28,8 @@
 #include <linux/sctp.h>
 #include <linux/string.h>
 #include <linux/seq_file.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
 
 #include <net/netfilter/nf_conntrack.h>
 #include <net/netfilter/nf_conntrack_protocol.h>
diff --git a/net/netfilter/nfnetlink.c b/net/netfilter/nfnetlink.c
index b88e82a1a987..ec9f0efea6bb 100644
--- a/net/netfilter/nfnetlink.c
+++ b/net/netfilter/nfnetlink.c
@@ -229,7 +229,7 @@ static int nfnetlink_rcv_msg(struct sk_buff *skb,
                  NFNL_SUBSYS_ID(nlh->nlmsg_type),
                  NFNL_MSG_TYPE(nlh->nlmsg_type));
 
-        if (!cap_raised(NETLINK_CB(skb).eff_cap, CAP_NET_ADMIN)) {
+        if (security_netlink_recv(skb, CAP_NET_ADMIN)) {
                 DEBUGP("missing CAP_NET_ADMIN\n");
                 *errp = -EPERM;
                 return -1;
diff --git a/net/netfilter/nfnetlink_queue.c b/net/netfilter/nfnetlink_queue.c
index 86a4ac33de34..49ef41e34c48 100644
--- a/net/netfilter/nfnetlink_queue.c
+++ b/net/netfilter/nfnetlink_queue.c
@@ -680,11 +680,19 @@ dev_cmp(struct nfqnl_queue_entry *entry, unsigned long ifindex)
         if (entinf->indev)
                 if (entinf->indev->ifindex == ifindex)
                         return 1;
-                        
         if (entinf->outdev)
                 if (entinf->outdev->ifindex == ifindex)
                         return 1;
-
+#ifdef CONFIG_BRIDGE_NETFILTER
+        if (entry->skb->nf_bridge) {
+                if (entry->skb->nf_bridge->physindev &&
+                    entry->skb->nf_bridge->physindev->ifindex == ifindex)
+                        return 1;
+                if (entry->skb->nf_bridge->physoutdev &&
+                    entry->skb->nf_bridge->physoutdev->ifindex == ifindex)
+                        return 1;
+        }
+#endif
         return 0;
 }
 
diff --git a/net/netfilter/xt_sctp.c b/net/netfilter/xt_sctp.c
index 9316c753692f..843383e01d41 100644
--- a/net/netfilter/xt_sctp.c
+++ b/net/netfilter/xt_sctp.c
@@ -151,7 +151,7 @@ match(const struct sk_buff *skb,
                 && SCCHECK(((ntohs(sh->dest) >= info->dpts[0]) 
                         && (ntohs(sh->dest) <= info->dpts[1])), 
                         XT_SCTP_DEST_PORTS, info->flags, info->invflags)
-                && SCCHECK(match_packet(skb, protoff,
+                && SCCHECK(match_packet(skb, protoff + sizeof (sctp_sctphdr_t),
                                         info->chunkmap, info->chunk_match_type,
                                         info->flag_info, info->flag_count, 
                                         hotdrop),
diff --git a/net/netfilter/xt_tcpudp.c b/net/netfilter/xt_tcpudp.c
index 1b61dac9c873..a9a63aa68936 100644
--- a/net/netfilter/xt_tcpudp.c
+++ b/net/netfilter/xt_tcpudp.c
@@ -260,7 +260,7 @@ static int __init xt_tcpudp_init(void)
         return ret;
 
 out_unreg_udp:
-        xt_unregister_match(&tcp_matchstruct);
+        xt_unregister_match(&udp_matchstruct);
 out_unreg_tcp6:
         xt_unregister_match(&tcp6_matchstruct);
 out_unreg_tcp:
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index f329b72578f5..edf084becd5e 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -320,7 +320,7 @@ static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
                 goto errout;
         }
 
-        if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb)) {
+        if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb, CAP_NET_ADMIN)) {
                 err = -EPERM;
                 goto errout;
         }
diff --git a/net/tipc/core.c b/net/tipc/core.c
index 5003acb15919..0539a8362858 100644
--- a/net/tipc/core.c
+++ b/net/tipc/core.c
@@ -191,7 +191,8 @@ static int __init tipc_init(void)
         int res;
 
         tipc_log_reinit(CONFIG_TIPC_LOG);
-        info("Activated (compiled " __DATE__ " " __TIME__ ")\n");
+        info("Activated (version " TIPC_MOD_VER 
+             " compiled " __DATE__ " " __TIME__ ")\n");
 
         tipc_own_addr = 0;
         tipc_remote_management = 1;
diff --git a/net/tipc/link.c b/net/tipc/link.c
index d64658053746..c6831c75cfa4 100644
--- a/net/tipc/link.c
+++ b/net/tipc/link.c
@@ -2,7 +2,7 @@
  * net/tipc/link.c: TIPC link code
  * 
  * Copyright (c) 1996-2006, Ericsson AB
- * Copyright (c) 2004-2005, Wind River Systems
+ * Copyright (c) 2004-2006, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -988,17 +988,18 @@ static int link_bundle_buf(struct link *l_ptr,
         struct tipc_msg *bundler_msg = buf_msg(bundler);
         struct tipc_msg *msg = buf_msg(buf);
         u32 size = msg_size(msg);
-        u32 to_pos = align(msg_size(bundler_msg));
-        u32 rest = link_max_pkt(l_ptr) - to_pos;
+        u32 bundle_size = msg_size(bundler_msg);
+        u32 to_pos = align(bundle_size);
+        u32 pad = to_pos - bundle_size;
 
         if (msg_user(bundler_msg) != MSG_BUNDLER)
                 return 0;
         if (msg_type(bundler_msg) != OPEN_MSG)
                 return 0;
-        if (rest < align(size))
+        if (skb_tailroom(bundler) < (pad + size))
                 return 0;
 
-        skb_put(bundler, (to_pos - msg_size(bundler_msg)) + size);
+        skb_put(bundler, pad + size);
         memcpy(bundler->data + to_pos, buf->data, size);
         msg_set_size(bundler_msg, to_pos + size);
         msg_set_msgcnt(bundler_msg, msg_msgcnt(bundler_msg) + 1);
diff --git a/net/tipc/node.c b/net/tipc/node.c
index 861322b935da..fc6d09630ccd 100644
--- a/net/tipc/node.c
+++ b/net/tipc/node.c
@@ -2,7 +2,7 @@
  * net/tipc/node.c: TIPC node management routines
  * 
  * Copyright (c) 2000-2006, Ericsson AB
- * Copyright (c) 2005, Wind River Systems
+ * Copyright (c) 2005-2006, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -592,6 +592,7 @@ struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
         struct sk_buff *buf;
         struct node *n_ptr;
         struct tipc_node_info node_info;
+        u32 payload_size;
 
         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
@@ -608,8 +609,11 @@ struct sk_buff *tipc_node_get_nodes(const void *req_tlv_area, int req_tlv_space)
         /* For now, get space for all other nodes 
            (will need to modify this when slave nodes are supported */
 
-        buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(node_info)) *
-                                   (tipc_max_nodes - 1));
+        payload_size = TLV_SPACE(sizeof(node_info)) * (tipc_max_nodes - 1);
+        if (payload_size > 32768u)
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                                                   " (too many nodes)");
+        buf = tipc_cfg_reply_alloc(payload_size);
         if (!buf)
                 return NULL;
 
@@ -633,6 +637,7 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
         struct sk_buff *buf;
         struct node *n_ptr;
         struct tipc_link_info link_info;
+        u32 payload_size;
 
         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
                 return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
@@ -645,12 +650,15 @@ struct sk_buff *tipc_node_get_links(const void *req_tlv_area, int req_tlv_space)
 
         if (!tipc_nodes)
                 return tipc_cfg_reply_none();
-
-        /* For now, get space for 2 links to all other nodes + bcast link 
-           (will need to modify this when slave nodes are supported */
-
-        buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(link_info)) *
-                                   (2 * (tipc_max_nodes - 1) + 1));
+        
+        /* Get space for all unicast links + multicast link */
+
+        payload_size = TLV_SPACE(sizeof(link_info)) *
+                (tipc_net.zones[tipc_zone(tipc_own_addr)]->links + 1);
+        if (payload_size > 32768u)
+                return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
+                                                   " (too many links)");
+        buf = tipc_cfg_reply_alloc(payload_size);
         if (!buf)
                 return NULL;
 
diff --git a/net/tipc/zone.h b/net/tipc/zone.h
index 267999c5a240..5ab3d08602e2 100644
--- a/net/tipc/zone.h
+++ b/net/tipc/zone.h
@@ -2,7 +2,7 @@
  * net/tipc/zone.h: Include file for TIPC zone management routines
  * 
  * Copyright (c) 2000-2006, Ericsson AB
- * Copyright (c) 2005, Wind River Systems
+ * Copyright (c) 2005-2006, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -45,7 +45,7 @@
  * struct _zone - TIPC zone structure
  * @addr: network address of zone
  * @clusters: array of pointers to all clusters within zone
- * @links: (used for inter-zone communication)
+ * @links: number of (unicast) links to zone
  */
  
 struct _zone {
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index d901465ce013..fd11d4048b52 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -128,6 +128,30 @@ static atomic_t unix_nr_socks = ATOMIC_INIT(0);
 
 #define UNIX_ABSTRACT(sk)       (unix_sk(sk)->addr->hash != UNIX_HASH_SIZE)
 
+#ifdef CONFIG_SECURITY_NETWORK
+static void unix_get_peersec_dgram(struct sk_buff *skb)
+{
+        int err;
+
+        err = security_socket_getpeersec_dgram(skb, UNIXSECDATA(skb),
+                                               UNIXSECLEN(skb));
+        if (err)
+                *(UNIXSECDATA(skb)) = NULL;
+}
+
+static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
+{
+        scm->secdata = *UNIXSECDATA(skb);
+        scm->seclen = *UNIXSECLEN(skb);
+}
+#else
+static void unix_get_peersec_dgram(struct sk_buff *skb)
+{ }
+
+static inline void unix_set_secdata(struct scm_cookie *scm, struct sk_buff *skb)
+{ }
+#endif /* CONFIG_SECURITY_NETWORK */
+
 /*
  *  SMP locking strategy:
  *    hash table is protected with spinlock unix_table_lock
@@ -1291,6 +1315,8 @@ static int unix_dgram_sendmsg(struct kiocb *kiocb, struct socket *sock,
         if (siocb->scm->fp)
                 unix_attach_fds(siocb->scm, skb);
 
+        unix_get_peersec_dgram(skb);
+
         skb->h.raw = skb->data;
         err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
         if (err)
@@ -1570,6 +1596,7 @@ static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
                 memset(&tmp_scm, 0, sizeof(tmp_scm));
         }
         siocb->scm->creds = *UNIXCREDS(skb);
+        unix_set_secdata(siocb->scm, skb);
 
         if (!(flags & MSG_PEEK))
         {
diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 17b29ec3c417..43f00fc28a3d 100644
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -1164,8 +1164,6 @@ int xfrm_state_mtu(struct xfrm_state *x, int mtu)
         return res;
 }
 
-EXPORT_SYMBOL(xfrm_state_mtu);
-
 int xfrm_init_state(struct xfrm_state *x)
 {
         struct xfrm_state_afinfo *afinfo;
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index c21dc26141ea..3e6a722d072e 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -1435,7 +1435,7 @@ static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *err
         link = &xfrm_dispatch[type];
 
         /* All operations require privileges, even GET */
-        if (security_netlink_recv(skb)) {
+        if (security_netlink_recv(skb, CAP_NET_ADMIN)) {
                 *errp = -EPERM;
                 return -1;
         }