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: (56 commits)
  l2tp: Fix possible oops if transmitting or receiving when tunnel goes down
  tcp: Fix for race due to temporary drop of the socket lock in skb_splice_bits.
  tcp: Increment OUTRSTS in tcp_send_active_reset()
  raw: Raw socket leak.
  lt2p: Fix possible WARN_ON from socket code when UDP socket is closed
  USB ID for Philips CPWUA054/00 Wireless USB Adapter 11g
  ssb: Fix context assertion in ssb_pcicore_dev_irqvecs_enable
  libertas: fix command size for CMD_802_11_SUBSCRIBE_EVENT
  ipw2200: expire and use oldest BSS on adhoc create
  airo warning fix
  b43legacy: Fix controller restart crash
  sctp: Fix ECN markings for IPv6
  sctp: Flush the queue only once during fast retransmit.
  sctp: Start T3-RTX timer when fast retransmitting lowest TSN
  sctp: Correctly implement Fast Recovery cwnd manipulations.
  sctp: Move sctp_v4_dst_saddr out of loop
  sctp: retran_path update bug fix
  tcp: fix skb vs fack_count out-of-sync condition
  sunhme: Cleanup use of deprecated calls to save_and_cli and restore_flags.
  xfrm: xfrm_algo: correct usage of RIPEMD-160
  ...

40 files changed, 376 insertions, 233 deletions

diff --git a/net/ax25/ax25_subr.c b/net/ax25/ax25_subr.c
index d8f215733175..034aa10a5198 100644
--- a/net/ax25/ax25_subr.c
+++ b/net/ax25/ax25_subr.c
@@ -64,20 +64,15 @@ void ax25_frames_acked(ax25_cb *ax25, unsigned short nr)
 
 void ax25_requeue_frames(ax25_cb *ax25)
 {
-        struct sk_buff *skb, *skb_prev = NULL;
+        struct sk_buff *skb;
 
         /*
          * Requeue all the un-ack-ed frames on the output queue to be picked
          * up by ax25_kick called from the timer. This arrangement handles the
          * possibility of an empty output queue.
          */
-        while ((skb = skb_dequeue(&ax25->ack_queue)) != NULL) {
-                if (skb_prev == NULL)
-                        skb_queue_head(&ax25->write_queue, skb);
-                else
-                        skb_append(skb_prev, skb, &ax25->write_queue);
-                skb_prev = skb;
-        }
+        while ((skb = skb_dequeue_tail(&ax25->ack_queue)) != NULL)
+                skb_queue_head(&ax25->write_queue, skb);
 }
 
 /*
diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
index c3f749abb2d0..c9191871c1e0 100644
--- a/net/bluetooth/rfcomm/tty.c
+++ b/net/bluetooth/rfcomm/tty.c
@@ -566,11 +566,22 @@ static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
         if (dlc->state == BT_CLOSED) {
                 if (!dev->tty) {
                         if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
-                                if (rfcomm_dev_get(dev->id) == NULL)
+                                /* Drop DLC lock here to avoid deadlock
+                                 * 1. rfcomm_dev_get will take rfcomm_dev_lock
+                                 *    but in rfcomm_dev_add there's lock order:
+                                 *    rfcomm_dev_lock -> dlc lock
+                                 * 2. rfcomm_dev_put will deadlock if it's
+                                 *    the last reference
+                                 */
+                                rfcomm_dlc_unlock(dlc);
+                                if (rfcomm_dev_get(dev->id) == NULL) {
+                                        rfcomm_dlc_lock(dlc);
                                         return;
+                                }
 
                                 rfcomm_dev_del(dev);
                                 rfcomm_dev_put(dev);
+                                rfcomm_dlc_lock(dlc);
                         }
                 } else
                         tty_hangup(dev->tty);
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 5d9d7130bd6e..65f01f71b3f3 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1714,7 +1714,8 @@ static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
         return nla_nest_end(skb, nest);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, nest);
+        nla_nest_cancel(skb, nest);
+        return -EMSGSIZE;
 }
 
 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
@@ -2057,9 +2058,9 @@ static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
                 goto nla_put_failure;
         }
 
-        ci.ndm_used      = now - neigh->used;
-        ci.ndm_confirmed = now - neigh->confirmed;
-        ci.ndm_updated   = now - neigh->updated;
+        ci.ndm_used      = jiffies_to_clock_t(now - neigh->used);
+        ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
+        ci.ndm_updated   = jiffies_to_clock_t(now - neigh->updated);
         ci.ndm_refcnt    = atomic_read(&neigh->refcnt) - 1;
         read_unlock_bh(&neigh->lock);
 
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index cf857c4dc7b1..a9a77216310e 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -498,7 +498,8 @@ int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
         return nla_nest_end(skb, mx);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, mx);
+        nla_nest_cancel(skb, mx);
+        return -EMSGSIZE;
 }
 
 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index 5c459f2b7985..1e556d312117 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -1445,6 +1445,7 @@ done:
 
         if (spd.nr_pages) {
                 int ret;
+                struct sock *sk = __skb->sk;
 
                 /*
                  * Drop the socket lock, otherwise we have reverse
@@ -1455,9 +1456,9 @@ done:
                  * we call into ->sendpage() with the i_mutex lock held
                  * and networking will grab the socket lock.
                  */
-                release_sock(__skb->sk);
+                release_sock(sk);
                 ret = splice_to_pipe(pipe, &spd);
-                lock_sock(__skb->sk);
+                lock_sock(sk);
                 return ret;
         }
 
diff --git a/net/core/user_dma.c b/net/core/user_dma.c
index 0ad1cd57bc39..c77aff9c6eb3 100644
--- a/net/core/user_dma.c
+++ b/net/core/user_dma.c
@@ -75,7 +75,7 @@ int dma_skb_copy_datagram_iovec(struct dma_chan *chan,
 
                 end = start + skb_shinfo(skb)->frags[i].size;
                 copy = end - offset;
-                if ((copy = end - offset) > 0) {
+                if (copy > 0) {
                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
                         struct page *page = frag->page;
 
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 6848e4760f34..79a7ef6209ff 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -90,7 +90,6 @@ static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
         [IFA_LOCAL]             = { .type = NLA_U32 },
         [IFA_ADDRESS]           = { .type = NLA_U32 },
         [IFA_BROADCAST]         = { .type = NLA_U32 },
-        [IFA_ANYCAST]           = { .type = NLA_U32 },
         [IFA_LABEL]             = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
 };
 
@@ -536,9 +535,6 @@ static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
         if (tb[IFA_BROADCAST])
                 ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
 
-        if (tb[IFA_ANYCAST])
-                ifa->ifa_anycast = nla_get_be32(tb[IFA_ANYCAST]);
-
         if (tb[IFA_LABEL])
                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
         else
@@ -745,7 +741,6 @@ int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
                                 break;
                         inet_del_ifa(in_dev, ifap, 0);
                         ifa->ifa_broadcast = 0;
-                        ifa->ifa_anycast = 0;
                         ifa->ifa_scope = 0;
                 }
 
@@ -1113,7 +1108,6 @@ static inline size_t inet_nlmsg_size(void)
                + nla_total_size(4) /* IFA_ADDRESS */
                + nla_total_size(4) /* IFA_LOCAL */
                + nla_total_size(4) /* IFA_BROADCAST */
-               + nla_total_size(4) /* IFA_ANYCAST */
                + nla_total_size(IFNAMSIZ); /* IFA_LABEL */
 }
 
@@ -1143,9 +1137,6 @@ static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
         if (ifa->ifa_broadcast)
                 NLA_PUT_BE32(skb, IFA_BROADCAST, ifa->ifa_broadcast);
 
-        if (ifa->ifa_anycast)
-                NLA_PUT_BE32(skb, IFA_ANYCAST, ifa->ifa_anycast);
-
         if (ifa->ifa_label[0])
                 NLA_PUT_STRING(skb, IFA_LABEL, ifa->ifa_label);
 
diff --git a/net/ipv4/fib_frontend.c b/net/ipv4/fib_frontend.c
index 0f1557a4ac7a..0b2ac6a3d903 100644
--- a/net/ipv4/fib_frontend.c
+++ b/net/ipv4/fib_frontend.c
@@ -506,7 +506,6 @@ const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
         [RTA_PREFSRC]           = { .type = NLA_U32 },
         [RTA_METRICS]           = { .type = NLA_NESTED },
         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
-        [RTA_PROTOINFO]         = { .type = NLA_U32 },
         [RTA_FLOW]              = { .type = NLA_U32 },
 };
 
diff --git a/net/ipv4/raw.c b/net/ipv4/raw.c
index fead049daf43..e7e091d365ff 100644
--- a/net/ipv4/raw.c
+++ b/net/ipv4/raw.c
@@ -608,6 +608,14 @@ static void raw_close(struct sock *sk, long timeout)
         sk_common_release(sk);
 }
 
+static int raw_destroy(struct sock *sk)
+{
+        lock_sock(sk);
+        ip_flush_pending_frames(sk);
+        release_sock(sk);
+        return 0;
+}
+
 /* This gets rid of all the nasties in af_inet. -DaveM */
 static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 {
@@ -820,6 +828,7 @@ struct proto raw_prot = {
         .name              = "RAW",
         .owner             = THIS_MODULE,
         .close             = raw_close,
+        .destroy           = raw_destroy,
         .connect           = ip4_datagram_connect,
         .disconnect        = udp_disconnect,
         .ioctl             = raw_ioctl,
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index df41026b60db..96be336064fb 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1792,7 +1792,7 @@ static int __mkroute_input(struct sk_buff *skb,
         if (err)
                 flags |= RTCF_DIRECTSRC;
 
-        if (out_dev == in_dev && err && !(flags & RTCF_MASQ) &&
+        if (out_dev == in_dev && err &&
             (IN_DEV_SHARED_MEDIA(out_dev) ||
              inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
                 flags |= RTCF_DOREDIRECT;
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index f88653138621..ab66683b8043 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -1227,7 +1227,14 @@ int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
                                 copied += used;
                                 offset += used;
                         }
-                        if (offset != skb->len)
+                        /*
+                         * If recv_actor drops the lock (e.g. TCP splice
+                         * receive) the skb pointer might be invalid when
+                         * getting here: tcp_collapse might have deleted it
+                         * while aggregating skbs from the socket queue.
+                         */
+                        skb = tcp_recv_skb(sk, seq-1, &offset);
+                        if (!skb || (offset+1 != skb->len))
                                 break;
                 }
                 if (tcp_hdr(skb)->fin) {
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index b54d9d37b636..eba873e9b560 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -1392,9 +1392,9 @@ static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
 
         if (before(next_dup->start_seq, skip_to_seq)) {
                 skb = tcp_sacktag_skip(skb, sk, next_dup->start_seq, fack_count);
-                tcp_sacktag_walk(skb, sk, NULL,
-                                 next_dup->start_seq, next_dup->end_seq,
-                                 1, fack_count, reord, flag);
+                skb = tcp_sacktag_walk(skb, sk, NULL,
+                                     next_dup->start_seq, next_dup->end_seq,
+                                     1, fack_count, reord, flag);
         }
 
         return skb;
@@ -2483,6 +2483,20 @@ static inline void tcp_complete_cwr(struct sock *sk)
         tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
 }
 
+static void tcp_try_keep_open(struct sock *sk)
+{
+        struct tcp_sock *tp = tcp_sk(sk);
+        int state = TCP_CA_Open;
+
+        if (tcp_left_out(tp) || tp->retrans_out || tp->undo_marker)
+                state = TCP_CA_Disorder;
+
+        if (inet_csk(sk)->icsk_ca_state != state) {
+                tcp_set_ca_state(sk, state);
+                tp->high_seq = tp->snd_nxt;
+        }
+}
+
 static void tcp_try_to_open(struct sock *sk, int flag)
 {
         struct tcp_sock *tp = tcp_sk(sk);
@@ -2496,15 +2510,7 @@ static void tcp_try_to_open(struct sock *sk, int flag)
                 tcp_enter_cwr(sk, 1);
 
         if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
-                int state = TCP_CA_Open;
-
-                if (tcp_left_out(tp) || tp->retrans_out || tp->undo_marker)
-                        state = TCP_CA_Disorder;
-
-                if (inet_csk(sk)->icsk_ca_state != state) {
-                        tcp_set_ca_state(sk, state);
-                        tp->high_seq = tp->snd_nxt;
-                }
+                tcp_try_keep_open(sk);
                 tcp_moderate_cwnd(tp);
         } else {
                 tcp_cwnd_down(sk, flag);
@@ -3310,8 +3316,11 @@ no_queue:
         return 1;
 
 old_ack:
-        if (TCP_SKB_CB(skb)->sacked)
+        if (TCP_SKB_CB(skb)->sacked) {
                 tcp_sacktag_write_queue(sk, skb, prior_snd_una);
+                if (icsk->icsk_ca_state == TCP_CA_Open)
+                        tcp_try_keep_open(sk);
+        }
 
 uninteresting_ack:
         SOCK_DEBUG(sk, "Ack %u out of %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index e399bde7813a..ad993ecb4810 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2131,6 +2131,8 @@ void tcp_send_active_reset(struct sock *sk, gfp_t priority)
         TCP_SKB_CB(skb)->when = tcp_time_stamp;
         if (tcp_transmit_skb(sk, skb, 0, priority))
                 NET_INC_STATS(LINUX_MIB_TCPABORTFAILED);
+
+        TCP_INC_STATS(TCP_MIB_OUTRSTS);
 }
 
 /* WARNING: This routine must only be called when we have already sent
diff --git a/net/ipv4/tunnel4.c b/net/ipv4/tunnel4.c
index d3b709a6f264..cb1f0e83830b 100644
--- a/net/ipv4/tunnel4.c
+++ b/net/ipv4/tunnel4.c
@@ -97,7 +97,7 @@ static int tunnel64_rcv(struct sk_buff *skb)
 {
         struct xfrm_tunnel *handler;
 
-        if (!pskb_may_pull(skb, sizeof(struct iphdr)))
+        if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
                 goto drop;
 
         for (handler = tunnel64_handlers; handler; handler = handler->next)
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index db1cb7c96d63..56fcda3694ba 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -420,7 +420,7 @@ void udp_err(struct sk_buff *skb, u32 info)
 /*
  * Throw away all pending data and cancel the corking. Socket is locked.
  */
-static void udp_flush_pending_frames(struct sock *sk)
+void udp_flush_pending_frames(struct sock *sk)
 {
         struct udp_sock *up = udp_sk(sk);
 
@@ -430,6 +430,7 @@ static void udp_flush_pending_frames(struct sock *sk)
                 ip_flush_pending_frames(sk);
         }
 }
+EXPORT_SYMBOL(udp_flush_pending_frames);
 
 /**
  *      udp4_hwcsum_outgoing  -  handle outgoing HW checksumming
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 3a835578fd1c..147588f4c7c0 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -731,8 +731,13 @@ static void ipv6_del_addr(struct inet6_ifaddr *ifp)
                                                 onlink = -1;
 
                                         spin_lock(&ifa->lock);
-                                        lifetime = min_t(unsigned long,
-                                                         ifa->valid_lft, 0x7fffffffUL/HZ);
+
+                                        lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
+                                        /*
+                                         * Note: Because this address is
+                                         * not permanent, lifetime <
+                                         * LONG_MAX / HZ here.
+                                         */
                                         if (time_before(expires,
                                                         ifa->tstamp + lifetime * HZ))
                                                 expires = ifa->tstamp + lifetime * HZ;
@@ -1722,7 +1727,6 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
         __u32 valid_lft;
         __u32 prefered_lft;
         int addr_type;
-        unsigned long rt_expires;
         struct inet6_dev *in6_dev;
 
         pinfo = (struct prefix_info *) opt;
@@ -1764,28 +1768,23 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
          *      2) Configure prefixes with the auto flag set
          */
 
-        if (valid_lft == INFINITY_LIFE_TIME)
-                rt_expires = ~0UL;
-        else if (valid_lft >= 0x7FFFFFFF/HZ) {
+        if (pinfo->onlink) {
+                struct rt6_info *rt;
+                unsigned long rt_expires;
+
                 /* Avoid arithmetic overflow. Really, we could
                  * save rt_expires in seconds, likely valid_lft,
                  * but it would require division in fib gc, that it
                  * not good.
                  */
-                rt_expires = 0x7FFFFFFF - (0x7FFFFFFF % HZ);
-        } else
-                rt_expires = valid_lft * HZ;
+                if (HZ > USER_HZ)
+                        rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
+                else
+                        rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
 
-        /*
-         * We convert this (in jiffies) to clock_t later.
-         * Avoid arithmetic overflow there as well.
-         * Overflow can happen only if HZ < USER_HZ.
-         */
-        if (HZ < USER_HZ && ~rt_expires && rt_expires > 0x7FFFFFFF / USER_HZ)
-                rt_expires = 0x7FFFFFFF / USER_HZ;
+                if (addrconf_finite_timeout(rt_expires))
+                        rt_expires *= HZ;
 
-        if (pinfo->onlink) {
-                struct rt6_info *rt;
                 rt = rt6_lookup(dev_net(dev), &pinfo->prefix, NULL,
                                 dev->ifindex, 1);
 
@@ -1794,7 +1793,7 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
                         if (valid_lft == 0) {
                                 ip6_del_rt(rt);
                                 rt = NULL;
-                        } else if (~rt_expires) {
+                        } else if (addrconf_finite_timeout(rt_expires)) {
                                 /* not infinity */
                                 rt->rt6i_expires = jiffies + rt_expires;
                                 rt->rt6i_flags |= RTF_EXPIRES;
@@ -1803,9 +1802,9 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len)
                                 rt->rt6i_expires = 0;
                         }
                 } else if (valid_lft) {
-                        int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
                         clock_t expires = 0;
-                        if (~rt_expires) {
+                        int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
+                        if (addrconf_finite_timeout(rt_expires)) {
                                 /* not infinity */
                                 flags |= RTF_EXPIRES;
                                 expires = jiffies_to_clock_t(rt_expires);
@@ -2027,7 +2026,7 @@ err_exit:
  *      Manual configuration of address on an interface
  */
 static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
-                          int plen, __u8 ifa_flags, __u32 prefered_lft,
+                          unsigned int plen, __u8 ifa_flags, __u32 prefered_lft,
                           __u32 valid_lft)
 {
         struct inet6_ifaddr *ifp;
@@ -2036,9 +2035,13 @@ static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
         int scope;
         u32 flags;
         clock_t expires;
+        unsigned long timeout;
 
         ASSERT_RTNL();
 
+        if (plen > 128)
+                return -EINVAL;
+
         /* check the lifetime */
         if (!valid_lft || prefered_lft > valid_lft)
                 return -EINVAL;
@@ -2052,22 +2055,23 @@ static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
 
         scope = ipv6_addr_scope(pfx);
 
-        if (valid_lft == INFINITY_LIFE_TIME) {
-                ifa_flags |= IFA_F_PERMANENT;
-                flags = 0;
-                expires = 0;
-        } else {
-                if (valid_lft >= 0x7FFFFFFF/HZ)
-                        valid_lft = 0x7FFFFFFF/HZ;
+        timeout = addrconf_timeout_fixup(valid_lft, HZ);
+        if (addrconf_finite_timeout(timeout)) {
+                expires = jiffies_to_clock_t(timeout * HZ);
+                valid_lft = timeout;
                 flags = RTF_EXPIRES;
-                expires = jiffies_to_clock_t(valid_lft * HZ);
+        } else {
+                expires = 0;
+                flags = 0;
+                ifa_flags |= IFA_F_PERMANENT;
         }
 
-        if (prefered_lft == 0)
-                ifa_flags |= IFA_F_DEPRECATED;
-        else if ((prefered_lft >= 0x7FFFFFFF/HZ) &&
-                 (prefered_lft != INFINITY_LIFE_TIME))
-                prefered_lft = 0x7FFFFFFF/HZ;
+        timeout = addrconf_timeout_fixup(prefered_lft, HZ);
+        if (addrconf_finite_timeout(timeout)) {
+                if (timeout == 0)
+                        ifa_flags |= IFA_F_DEPRECATED;
+                prefered_lft = timeout;
+        }
 
         ifp = ipv6_add_addr(idev, pfx, plen, scope, ifa_flags);
 
@@ -2095,12 +2099,15 @@ static int inet6_addr_add(struct net *net, int ifindex, struct in6_addr *pfx,
 }
 
 static int inet6_addr_del(struct net *net, int ifindex, struct in6_addr *pfx,
-                          int plen)
+                          unsigned int plen)
 {
         struct inet6_ifaddr *ifp;
         struct inet6_dev *idev;
         struct net_device *dev;
 
+        if (plen > 128)
+                return -EINVAL;
+
         dev = __dev_get_by_index(net, ifindex);
         if (!dev)
                 return -ENODEV;
@@ -3169,26 +3176,28 @@ static int inet6_addr_modify(struct inet6_ifaddr *ifp, u8 ifa_flags,
 {
         u32 flags;
         clock_t expires;
+        unsigned long timeout;
 
         if (!valid_lft || (prefered_lft > valid_lft))
                 return -EINVAL;
 
-        if (valid_lft == INFINITY_LIFE_TIME) {
-                ifa_flags |= IFA_F_PERMANENT;
-                flags = 0;
-                expires = 0;
-        } else {
-                if (valid_lft >= 0x7FFFFFFF/HZ)
-                        valid_lft = 0x7FFFFFFF/HZ;
+        timeout = addrconf_timeout_fixup(valid_lft, HZ);
+        if (addrconf_finite_timeout(timeout)) {
+                expires = jiffies_to_clock_t(timeout * HZ);
+                valid_lft = timeout;
                 flags = RTF_EXPIRES;
-                expires = jiffies_to_clock_t(valid_lft * HZ);
+        } else {
+                expires = 0;
+                flags = 0;
+                ifa_flags |= IFA_F_PERMANENT;
         }
 
-        if (prefered_lft == 0)
-                ifa_flags |= IFA_F_DEPRECATED;
-        else if ((prefered_lft >= 0x7FFFFFFF/HZ) &&
-                 (prefered_lft != INFINITY_LIFE_TIME))
-                prefered_lft = 0x7FFFFFFF/HZ;
+        timeout = addrconf_timeout_fixup(prefered_lft, HZ);
+        if (addrconf_finite_timeout(timeout)) {
+                if (timeout == 0)
+                        ifa_flags |= IFA_F_DEPRECATED;
+                prefered_lft = timeout;
+        }
 
         spin_lock_bh(&ifp->lock);
         ifp->flags = (ifp->flags & ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | IFA_F_HOMEADDRESS)) | ifa_flags;
diff --git a/net/ipv6/datagram.c b/net/ipv6/datagram.c
index 94fa6ae77cfe..b9c2de84a8a2 100644
--- a/net/ipv6/datagram.c
+++ b/net/ipv6/datagram.c
@@ -496,7 +496,8 @@ int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
         return 0;
 }
 
-int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
+int datagram_send_ctl(struct net *net,
+                      struct msghdr *msg, struct flowi *fl,
                       struct ipv6_txoptions *opt,
                       int *hlimit, int *tclass)
 {
@@ -509,7 +510,6 @@ int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
 
         for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
                 int addr_type;
-                struct net_device *dev = NULL;
 
                 if (!CMSG_OK(msg, cmsg)) {
                         err = -EINVAL;
@@ -522,6 +522,9 @@ int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
                 switch (cmsg->cmsg_type) {
                 case IPV6_PKTINFO:
                 case IPV6_2292PKTINFO:
+                    {
+                        struct net_device *dev = NULL;
+
                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
                                 err = -EINVAL;
                                 goto exit_f;
@@ -535,32 +538,32 @@ int datagram_send_ctl(struct msghdr *msg, struct flowi *fl,
                                 fl->oif = src_info->ipi6_ifindex;
                         }
 
-                        addr_type = ipv6_addr_type(&src_info->ipi6_addr);
+                        addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
 
-                        if (addr_type == IPV6_ADDR_ANY)
-                                break;
+                        if (fl->oif) {
+                                dev = dev_get_by_index(net, fl->oif);
+                                if (!dev)
+                                        return -ENODEV;
+                        } else if (addr_type & IPV6_ADDR_LINKLOCAL)
+                                return -EINVAL;
 
-                        if (addr_type & IPV6_ADDR_LINKLOCAL) {
-                                if (!src_info->ipi6_ifindex)
-                                        return -EINVAL;
-                                else {
-                                        dev = dev_get_by_index(&init_net, src_info->ipi6_ifindex);
-                                        if (!dev)
-                                                return -ENODEV;
-                                }
-                        }
-                        if (!ipv6_chk_addr(&init_net, &src_info->ipi6_addr,
-                                           dev, 0)) {
-                                if (dev)
-                                        dev_put(dev);
-                                err = -EINVAL;
-                                goto exit_f;
+                        if (addr_type != IPV6_ADDR_ANY) {
+                                int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
+                                if (!ipv6_chk_addr(net, &src_info->ipi6_addr,
+                                                   strict ? dev : NULL, 0))
+                                        err = -EINVAL;
+                                else
+                                        ipv6_addr_copy(&fl->fl6_src, &src_info->ipi6_addr);
                         }
+
                         if (dev)
                                 dev_put(dev);
 
-                        ipv6_addr_copy(&fl->fl6_src, &src_info->ipi6_addr);
+                        if (err)
+                                goto exit_f;
+
                         break;
+                    }
 
                 case IPV6_FLOWINFO:
                         if (cmsg->cmsg_len < CMSG_LEN(4)) {
diff --git a/net/ipv6/ip6_flowlabel.c b/net/ipv6/ip6_flowlabel.c
index eb7a940310f4..37a4e777e347 100644
--- a/net/ipv6/ip6_flowlabel.c
+++ b/net/ipv6/ip6_flowlabel.c
@@ -354,7 +354,7 @@ fl_create(struct net *net, struct in6_flowlabel_req *freq, char __user *optval,
                 msg.msg_control = (void*)(fl->opt+1);
                 flowi.oif = 0;
 
-                err = datagram_send_ctl(&msg, &flowi, fl->opt, &junk, &junk);
+                err = datagram_send_ctl(net, &msg, &flowi, fl->opt, &junk, &junk);
                 if (err)
                         goto done;
                 err = -EINVAL;
diff --git a/net/ipv6/ipv6_sockglue.c b/net/ipv6/ipv6_sockglue.c
index 56d55fecf8ec..26b83e512a09 100644
--- a/net/ipv6/ipv6_sockglue.c
+++ b/net/ipv6/ipv6_sockglue.c
@@ -161,9 +161,17 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
                         struct ipv6_txoptions *opt;
                         struct sk_buff *pktopt;
 
-                        if (sk->sk_protocol != IPPROTO_UDP &&
-                            sk->sk_protocol != IPPROTO_UDPLITE &&
-                            sk->sk_protocol != IPPROTO_TCP)
+                        if (sk->sk_type == SOCK_RAW)
+                                break;
+
+                        if (sk->sk_protocol == IPPROTO_UDP ||
+                            sk->sk_protocol == IPPROTO_UDPLITE) {
+                                struct udp_sock *up = udp_sk(sk);
+                                if (up->pending == AF_INET6) {
+                                        retv = -EBUSY;
+                                        break;
+                                }
+                        } else if (sk->sk_protocol != IPPROTO_TCP)
                                 break;
 
                         if (sk->sk_state != TCP_ESTABLISHED) {
@@ -416,7 +424,7 @@ sticky_done:
                 msg.msg_controllen = optlen;
                 msg.msg_control = (void*)(opt+1);
 
-                retv = datagram_send_ctl(&msg, &fl, opt, &junk, &junk);
+                retv = datagram_send_ctl(net, &msg, &fl, opt, &junk, &junk);
                 if (retv)
                         goto done;
 update:
@@ -832,7 +840,7 @@ static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
         len = min_t(unsigned int, len, ipv6_optlen(hdr));
         if (copy_to_user(optval, hdr, len))
                 return -EFAULT;
-        return ipv6_optlen(hdr);
+        return len;
 }
 
 static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
@@ -975,6 +983,9 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
                 len = ipv6_getsockopt_sticky(sk, np->opt,
                                              optname, optval, len);
                 release_sock(sk);
+                /* check if ipv6_getsockopt_sticky() returns err code */
+                if (len < 0)
+                        return len;
                 return put_user(len, optlen);
         }
 
diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
index 2dccad48058c..e65e26e210ee 100644
--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
+++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
@@ -209,7 +209,9 @@ fq_find(__be32 id, struct in6_addr *src, struct in6_addr *dst)
         arg.dst = dst;
         hash = ip6qhashfn(id, src, dst);
 
+        local_bh_disable();
         q = inet_frag_find(&nf_init_frags, &nf_frags, &arg, hash);
+        local_bh_enable();
         if (q == NULL)
                 goto oom;
 
@@ -638,10 +640,10 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
                 goto ret_orig;
         }
 
-        spin_lock(&fq->q.lock);
+        spin_lock_bh(&fq->q.lock);
 
         if (nf_ct_frag6_queue(fq, clone, fhdr, nhoff) < 0) {
-                spin_unlock(&fq->q.lock);
+                spin_unlock_bh(&fq->q.lock);
                 pr_debug("Can't insert skb to queue\n");
                 fq_put(fq);
                 goto ret_orig;
@@ -653,7 +655,7 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb)
                 if (ret_skb == NULL)
                         pr_debug("Can't reassemble fragmented packets\n");
         }
-        spin_unlock(&fq->q.lock);
+        spin_unlock_bh(&fq->q.lock);
 
         fq_put(fq);
         return ret_skb;
diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
index 232e0dc45bf5..8fee9a15b2d3 100644
--- a/net/ipv6/raw.c
+++ b/net/ipv6/raw.c
@@ -813,7 +813,7 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,
                 memset(opt, 0, sizeof(struct ipv6_txoptions));
                 opt->tot_len = sizeof(struct ipv6_txoptions);
 
-                err = datagram_send_ctl(msg, &fl, opt, &hlimit, &tclass);
+                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit, &tclass);
                 if (err < 0) {
                         fl6_sock_release(flowlabel);
                         return err;
@@ -1164,6 +1164,14 @@ static void rawv6_close(struct sock *sk, long timeout)
         sk_common_release(sk);
 }
 
+static int raw6_destroy(struct sock *sk)
+{
+        lock_sock(sk);
+        ip6_flush_pending_frames(sk);
+        release_sock(sk);
+        return 0;
+}
+
 static int rawv6_init_sk(struct sock *sk)
 {
         struct raw6_sock *rp = raw6_sk(sk);
@@ -1187,6 +1195,7 @@ struct proto rawv6_prot = {
         .name              = "RAWv6",
         .owner             = THIS_MODULE,
         .close             = rawv6_close,
+        .destroy           = raw6_destroy,
         .connect           = ip6_datagram_connect,
         .disconnect        = udp_disconnect,
         .ioctl             = rawv6_ioctl,
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 48534c6c0735..220cffe9e63b 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -446,7 +446,7 @@ int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
         struct route_info *rinfo = (struct route_info *) opt;
         struct in6_addr prefix_buf, *prefix;
         unsigned int pref;
-        u32 lifetime;
+        unsigned long lifetime;
         struct rt6_info *rt;
 
         if (len < sizeof(struct route_info)) {
@@ -472,13 +472,7 @@ int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
         if (pref == ICMPV6_ROUTER_PREF_INVALID)
                 pref = ICMPV6_ROUTER_PREF_MEDIUM;
 
-        lifetime = ntohl(rinfo->lifetime);
-        if (lifetime == 0xffffffff) {
-                /* infinity */
-        } else if (lifetime > 0x7fffffff/HZ - 1) {
-                /* Avoid arithmetic overflow */
-                lifetime = 0x7fffffff/HZ - 1;
-        }
+        lifetime = addrconf_timeout_fixup(ntohl(rinfo->lifetime), HZ);
 
         if (rinfo->length == 3)
                 prefix = (struct in6_addr *)rinfo->prefix;
@@ -506,7 +500,7 @@ int rt6_route_rcv(struct net_device *dev, u8 *opt, int len,
                                  (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
 
         if (rt) {
-                if (lifetime == 0xffffffff) {
+                if (!addrconf_finite_timeout(lifetime)) {
                         rt->rt6i_flags &= ~RTF_EXPIRES;
                 } else {
                         rt->rt6i_expires = jiffies + HZ * lifetime;
diff --git a/net/ipv6/tunnel6.c b/net/ipv6/tunnel6.c
index 6323921b40be..669f280989c3 100644
--- a/net/ipv6/tunnel6.c
+++ b/net/ipv6/tunnel6.c
@@ -109,7 +109,7 @@ static int tunnel46_rcv(struct sk_buff *skb)
 {
         struct xfrm6_tunnel *handler;
 
-        if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
+        if (!pskb_may_pull(skb, sizeof(struct iphdr)))
                 goto drop;
 
         for (handler = tunnel46_handlers; handler; handler = handler->next)
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index 1fd784f3e2ec..dd309626ae9a 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -534,7 +534,9 @@ static void udp_v6_flush_pending_frames(struct sock *sk)
 {
         struct udp_sock *up = udp_sk(sk);
 
-        if (up->pending) {
+        if (up->pending == AF_INET)
+                udp_flush_pending_frames(sk);
+        else if (up->pending) {
                 up->len = 0;
                 up->pending = 0;
                 ip6_flush_pending_frames(sk);
@@ -731,7 +733,7 @@ do_udp_sendmsg:
                 memset(opt, 0, sizeof(struct ipv6_txoptions));
                 opt->tot_len = sizeof(*opt);
 
-                err = datagram_send_ctl(msg, &fl, opt, &hlimit, &tclass);
+                err = datagram_send_ctl(sock_net(sk), msg, &fl, opt, &hlimit, &tclass);
                 if (err < 0) {
                         fl6_sock_release(flowlabel);
                         return err;
@@ -848,12 +850,14 @@ do_append_data:
                 } else {
                         dst_release(dst);
                 }
+                dst = NULL;
         }
 
         if (err > 0)
                 err = np->recverr ? net_xmit_errno(err) : 0;
         release_sock(sk);
 out:
+        dst_release(dst);
         fl6_sock_release(flowlabel);
         if (!err)
                 return len;
diff --git a/net/irda/af_irda.c b/net/irda/af_irda.c
index ae54b20d0470..3eb5bcc75f99 100644
--- a/net/irda/af_irda.c
+++ b/net/irda/af_irda.c
@@ -1093,11 +1093,6 @@ static int irda_create(struct net *net, struct socket *sock, int protocol)
 
         init_waitqueue_head(&self->query_wait);
 
-        /* Initialise networking socket struct */
-        sock_init_data(sock, sk);       /* Note : set sk->sk_refcnt to 1 */
-        sk->sk_family = PF_IRDA;
-        sk->sk_protocol = protocol;
-
         switch (sock->type) {
         case SOCK_STREAM:
                 sock->ops = &irda_stream_ops;
@@ -1124,13 +1119,20 @@ static int irda_create(struct net *net, struct socket *sock, int protocol)
                         self->max_sdu_size_rx = TTP_SAR_UNBOUND;
                         break;
                 default:
+                        sk_free(sk);
                         return -ESOCKTNOSUPPORT;
                 }
                 break;
         default:
+                sk_free(sk);
                 return -ESOCKTNOSUPPORT;
         }
 
+        /* Initialise networking socket struct */
+        sock_init_data(sock, sk);       /* Note : set sk->sk_refcnt to 1 */
+        sk->sk_family = PF_IRDA;
+        sk->sk_protocol = protocol;
+
         /* Register as a client with IrLMP */
         self->ckey = irlmp_register_client(0, NULL, NULL, NULL);
         self->mask.word = 0xffff;
diff --git a/net/netfilter/xt_connlimit.c b/net/netfilter/xt_connlimit.c
index 2e89a00df92c..70907f6baac3 100644
--- a/net/netfilter/xt_connlimit.c
+++ b/net/netfilter/xt_connlimit.c
@@ -73,7 +73,8 @@ connlimit_iphash6(const union nf_inet_addr *addr,
 static inline bool already_closed(const struct nf_conn *conn)
 {
         if (nf_ct_protonum(conn) == IPPROTO_TCP)
-                return conn->proto.tcp.state == TCP_CONNTRACK_TIME_WAIT;
+                return conn->proto.tcp.state == TCP_CONNTRACK_TIME_WAIT ||
+                       conn->proto.tcp.state == TCP_CONNTRACK_CLOSE;
         else
                 return 0;
 }
diff --git a/net/netlink/attr.c b/net/netlink/attr.c
index feb326f4a752..47bbf45ae5d7 100644
--- a/net/netlink/attr.c
+++ b/net/netlink/attr.c
@@ -400,13 +400,13 @@ void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
  * @attrlen: length of attribute payload
  * @data: head of attribute payload
  *
- * Returns -1 if the tailroom of the skb is insufficient to store
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
  * the attribute header and payload.
  */
 int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
 {
         if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
-                return -1;
+                return -EMSGSIZE;
 
         __nla_put(skb, attrtype, attrlen, data);
         return 0;
@@ -418,13 +418,13 @@ int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
  * @attrlen: length of attribute payload
  * @data: head of attribute payload
  *
- * Returns -1 if the tailroom of the skb is insufficient to store
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
  * the attribute payload.
  */
 int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
 {
         if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
-                return -1;
+                return -EMSGSIZE;
 
         __nla_put_nohdr(skb, attrlen, data);
         return 0;
@@ -436,13 +436,13 @@ int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
  * @attrlen: length of attribute payload
  * @data: head of attribute payload
  *
- * Returns -1 if the tailroom of the skb is insufficient to store
+ * Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
  * the attribute payload.
  */
 int nla_append(struct sk_buff *skb, int attrlen, const void *data)
 {
         if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
-                return -1;
+                return -EMSGSIZE;
 
         memcpy(skb_put(skb, attrlen), data, attrlen);
         return 0;
diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index d16929c9b4bc..f5aa23c3e886 100644
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -554,7 +554,8 @@ static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
         return genlmsg_end(skb, hdr);
 
 nla_put_failure:
-        return genlmsg_cancel(skb, hdr);
+        genlmsg_cancel(skb, hdr);
+        return -EMSGSIZE;
 }
 
 static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
@@ -590,7 +591,8 @@ static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
         return genlmsg_end(skb, hdr);
 
 nla_put_failure:
-        return genlmsg_cancel(skb, hdr);
+        genlmsg_cancel(skb, hdr);
+        return -EMSGSIZE;
 }
 
 static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
diff --git a/net/sched/sch_dsmark.c b/net/sched/sch_dsmark.c
index 0df911fd67b1..64465bacbe79 100644
--- a/net/sched/sch_dsmark.c
+++ b/net/sched/sch_dsmark.c
@@ -444,7 +444,8 @@ static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,
         return nla_nest_end(skb, opts);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, opts);
+        nla_nest_cancel(skb, opts);
+        return -EMSGSIZE;
 }
 
 static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
@@ -466,7 +467,8 @@ static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
         return nla_nest_end(skb, opts);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, opts);
+        nla_nest_cancel(skb, opts);
+        return -EMSGSIZE;
 }
 
 static const struct Qdisc_class_ops dsmark_class_ops = {
diff --git a/net/sched/sch_gred.c b/net/sched/sch_gred.c
index 3a9d226ff1e4..c89fba56db56 100644
--- a/net/sched/sch_gred.c
+++ b/net/sched/sch_gred.c
@@ -582,7 +582,8 @@ append_opt:
         return nla_nest_end(skb, opts);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, opts);
+        nla_nest_cancel(skb, opts);
+        return -EMSGSIZE;
 }
 
 static void gred_destroy(struct Qdisc *sch)
diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 87293d0db1d7..fdfaa3fcc16d 100644
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -1360,7 +1360,7 @@ hfsc_dump_class(struct Qdisc *sch, unsigned long arg, struct sk_buff *skb,
 
  nla_put_failure:
         nla_nest_cancel(skb, nest);
-        return -1;
+        return -EMSGSIZE;
 }
 
 static int
diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index 3dcd493f4f4a..5c569853b9c0 100644
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -281,7 +281,8 @@ static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
         return nla_nest_end(skb, opts);
 
 nla_put_failure:
-        return nla_nest_cancel(skb, opts);
+        nla_nest_cancel(skb, opts);
+        return -EMSGSIZE;
 }
 
 static int red_dump_stats(struct Qdisc *sch, struct gnet_dump *d)
diff --git a/net/sctp/associola.c b/net/sctp/associola.c
index b4cd2b71953f..532634861db1 100644
--- a/net/sctp/associola.c
+++ b/net/sctp/associola.c
@@ -1203,6 +1203,9 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc)
         struct list_head *head = &asoc->peer.transport_addr_list;
         struct list_head *pos;
 
+        if (asoc->peer.transport_count == 1)
+                return;
+
         /* Find the next transport in a round-robin fashion. */
         t = asoc->peer.retran_path;
         pos = &t->transports;
@@ -1217,6 +1220,15 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc)
 
                 t = list_entry(pos, struct sctp_transport, transports);
 
+                /* We have exhausted the list, but didn't find any
+                 * other active transports.  If so, use the next
+                 * transport.
+                 */
+                if (t == asoc->peer.retran_path) {
+                        t = next;
+                        break;
+                }
+
                 /* Try to find an active transport. */
 
                 if ((t->state == SCTP_ACTIVE) ||
@@ -1229,15 +1241,6 @@ void sctp_assoc_update_retran_path(struct sctp_association *asoc)
                         if (!next)
                                 next = t;
                 }
-
-                /* We have exhausted the list, but didn't find any
-                 * other active transports.  If so, use the next
-                 * transport.
-                 */
-                if (t == asoc->peer.retran_path) {
-                        t = next;
-                        break;
-                }
         }
 
         asoc->peer.retran_path = t;
diff --git a/net/sctp/ipv6.c b/net/sctp/ipv6.c
index e45e44c60635..a2f4d4d51593 100644
--- a/net/sctp/ipv6.c
+++ b/net/sctp/ipv6.c
@@ -299,7 +299,8 @@ static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
 /* Fills in the source address(saddr) based on the destination address(daddr)
  * and asoc's bind address list.
  */
-static void sctp_v6_get_saddr(struct sctp_association *asoc,
+static void sctp_v6_get_saddr(struct sctp_sock *sk,
+                              struct sctp_association *asoc,
                               struct dst_entry *dst,
                               union sctp_addr *daddr,
                               union sctp_addr *saddr)
@@ -318,7 +319,7 @@ static void sctp_v6_get_saddr(struct sctp_association *asoc,
         if (!asoc) {
                 ipv6_dev_get_saddr(dst ? ip6_dst_idev(dst)->dev : NULL,
                                    &daddr->v6.sin6_addr,
-                                   inet6_sk(asoc->base.sk)->srcprefs,
+                                   inet6_sk(&sk->inet.sk)->srcprefs,
                                    &saddr->v6.sin6_addr);
                 SCTP_DEBUG_PRINTK("saddr from ipv6_get_saddr: " NIP6_FMT "\n",
                                   NIP6(saddr->v6.sin6_addr));
@@ -726,6 +727,11 @@ static void sctp_v6_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
         seq_printf(seq, NIP6_FMT " ", NIP6(addr->v6.sin6_addr));
 }
 
+static void sctp_v6_ecn_capable(struct sock *sk)
+{
+        inet6_sk(sk)->tclass |= INET_ECN_ECT_0;
+}
+
 /* Initialize a PF_INET6 socket msg_name. */
 static void sctp_inet6_msgname(char *msgname, int *addr_len)
 {
@@ -996,6 +1002,7 @@ static struct sctp_af sctp_af_inet6 = {
         .skb_iif           = sctp_v6_skb_iif,
         .is_ce             = sctp_v6_is_ce,
         .seq_dump_addr     = sctp_v6_seq_dump_addr,
+        .ecn_capable       = sctp_v6_ecn_capable,
         .net_header_len    = sizeof(struct ipv6hdr),
         .sockaddr_len      = sizeof(struct sockaddr_in6),
 #ifdef CONFIG_COMPAT
diff --git a/net/sctp/output.c b/net/sctp/output.c
index cf4f9fb6819d..6d45bae93b46 100644
--- a/net/sctp/output.c
+++ b/net/sctp/output.c
@@ -548,7 +548,7 @@ int sctp_packet_transmit(struct sctp_packet *packet)
          * Note: The works for IPv6 layer checks this bit too later
          * in transmission.  See IP6_ECN_flow_xmit().
          */
-        INET_ECN_xmit(nskb->sk);
+        (*tp->af_specific->ecn_capable)(nskb->sk);
 
         /* Set up the IP options.  */
         /* BUG: not implemented
diff --git a/net/sctp/outqueue.c b/net/sctp/outqueue.c
index 59edfd25a19c..ace6770e9048 100644
--- a/net/sctp/outqueue.c
+++ b/net/sctp/outqueue.c
@@ -208,6 +208,7 @@ void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
         INIT_LIST_HEAD(&q->sacked);
         INIT_LIST_HEAD(&q->abandoned);
 
+        q->fast_rtx = 0;
         q->outstanding_bytes = 0;
         q->empty = 1;
         q->cork  = 0;
@@ -500,6 +501,7 @@ void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
         case SCTP_RTXR_FAST_RTX:
                 SCTP_INC_STATS(SCTP_MIB_FAST_RETRANSMITS);
                 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
+                q->fast_rtx = 1;
                 break;
         case SCTP_RTXR_PMTUD:
                 SCTP_INC_STATS(SCTP_MIB_PMTUD_RETRANSMITS);
@@ -518,9 +520,15 @@ void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
          * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by
          * following the procedures outlined in C1 - C5.
          */
-        sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
+        if (reason == SCTP_RTXR_T3_RTX)
+                sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
 
-        error = sctp_outq_flush(q, /* rtx_timeout */ 1);
+        /* Flush the queues only on timeout, since fast_rtx is only
+         * triggered during sack processing and the queue
+         * will be flushed at the end.
+         */
+        if (reason != SCTP_RTXR_FAST_RTX)
+                error = sctp_outq_flush(q, /* rtx_timeout */ 1);
 
         if (error)
                 q->asoc->base.sk->sk_err = -error;
@@ -538,17 +546,23 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
                                int rtx_timeout, int *start_timer)
 {
         struct list_head *lqueue;
-        struct list_head *lchunk;
         struct sctp_transport *transport = pkt->transport;
         sctp_xmit_t status;
         struct sctp_chunk *chunk, *chunk1;
         struct sctp_association *asoc;
+        int fast_rtx;
         int error = 0;
+        int timer = 0;
+        int done = 0;
 
         asoc = q->asoc;
         lqueue = &q->retransmit;
+        fast_rtx = q->fast_rtx;
 
-        /* RFC 2960 6.3.3 Handle T3-rtx Expiration
+        /* This loop handles time-out retransmissions, fast retransmissions,
+         * and retransmissions due to opening of whindow.
+         *
+         * RFC 2960 6.3.3 Handle T3-rtx Expiration
          *
          * E3) Determine how many of the earliest (i.e., lowest TSN)
          * outstanding DATA chunks for the address for which the
@@ -563,12 +577,12 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
          * [Just to be painfully clear, if we are retransmitting
          * because a timeout just happened, we should send only ONE
          * packet of retransmitted data.]
+         *
+         * For fast retransmissions we also send only ONE packet.  However,
+         * if we are just flushing the queue due to open window, we'll
+         * try to send as much as possible.
          */
-        lchunk = sctp_list_dequeue(lqueue);
-
-        while (lchunk) {
-                chunk = list_entry(lchunk, struct sctp_chunk,
-                                   transmitted_list);
+        list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
 
                 /* Make sure that Gap Acked TSNs are not retransmitted.  A
                  * simple approach is just to move such TSNs out of the
@@ -576,58 +590,60 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
                  * next chunk.
                  */
                 if (chunk->tsn_gap_acked) {
-                        list_add_tail(lchunk, &transport->transmitted);
-                        lchunk = sctp_list_dequeue(lqueue);
+                        list_del(&chunk->transmitted_list);
+                        list_add_tail(&chunk->transmitted_list,
+                                        &transport->transmitted);
                         continue;
                 }
 
+                /* If we are doing fast retransmit, ignore non-fast_rtransmit
+                 * chunks
+                 */
+                if (fast_rtx && !chunk->fast_retransmit)
+                        continue;
+
                 /* Attempt to append this chunk to the packet. */
                 status = sctp_packet_append_chunk(pkt, chunk);
 
                 switch (status) {
                 case SCTP_XMIT_PMTU_FULL:
                         /* Send this packet.  */
-                        if ((error = sctp_packet_transmit(pkt)) == 0)
-                                *start_timer = 1;
+                        error = sctp_packet_transmit(pkt);
 
                         /* If we are retransmitting, we should only
                          * send a single packet.
                          */
-                        if (rtx_timeout) {
-                                list_add(lchunk, lqueue);
-                                lchunk = NULL;
-                        }
+                        if (rtx_timeout || fast_rtx)
+                                done = 1;
 
-                        /* Bundle lchunk in the next round.  */
+                        /* Bundle next chunk in the next round.  */
                         break;
 
                 case SCTP_XMIT_RWND_FULL:
                         /* Send this packet. */
-                        if ((error = sctp_packet_transmit(pkt)) == 0)
-                                *start_timer = 1;
+                        error = sctp_packet_transmit(pkt);
 
                         /* Stop sending DATA as there is no more room
                          * at the receiver.
                          */
-                        list_add(lchunk, lqueue);
-                        lchunk = NULL;
+                        done = 1;
                         break;
 
                 case SCTP_XMIT_NAGLE_DELAY:
                         /* Send this packet. */
-                        if ((error = sctp_packet_transmit(pkt)) == 0)
-                                *start_timer = 1;
+                        error = sctp_packet_transmit(pkt);
 
                         /* Stop sending DATA because of nagle delay. */
-                        list_add(lchunk, lqueue);
-                        lchunk = NULL;
+                        done = 1;
                         break;
 
                 default:
                         /* The append was successful, so add this chunk to
                          * the transmitted list.
                          */
-                        list_add_tail(lchunk, &transport->transmitted);
+                        list_del(&chunk->transmitted_list);
+                        list_add_tail(&chunk->transmitted_list,
+                                        &transport->transmitted);
 
                         /* Mark the chunk as ineligible for fast retransmit
                          * after it is retransmitted.
@@ -635,27 +651,44 @@ static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
                         if (chunk->fast_retransmit > 0)
                                 chunk->fast_retransmit = -1;
 
-                        *start_timer = 1;
-                        q->empty = 0;
+                        /* Force start T3-rtx timer when fast retransmitting
+                         * the earliest outstanding TSN
+                         */
+                        if (!timer && fast_rtx &&
+                            ntohl(chunk->subh.data_hdr->tsn) ==
+                                             asoc->ctsn_ack_point + 1)
+                                timer = 2;
 
-                        /* Retrieve a new chunk to bundle. */
-                        lchunk = sctp_list_dequeue(lqueue);
+                        q->empty = 0;
                         break;
                 }
 
-                /* If we are here due to a retransmit timeout or a fast
-                 * retransmit and if there are any chunks left in the retransmit
-                 * queue that could not fit in the PMTU sized packet, they need
-                 * to be marked as ineligible for a subsequent fast retransmit.
-                 */
-                if (rtx_timeout && !lchunk) {
-                        list_for_each_entry(chunk1, lqueue, transmitted_list) {
-                                if (chunk1->fast_retransmit > 0)
-                                        chunk1->fast_retransmit = -1;
-                        }
+                /* Set the timer if there were no errors */
+                if (!error && !timer)
+                        timer = 1;
+
+                if (done)
+                        break;
+        }
+
+        /* If we are here due to a retransmit timeout or a fast
+         * retransmit and if there are any chunks left in the retransmit
+         * queue that could not fit in the PMTU sized packet, they need
+         * to be marked as ineligible for a subsequent fast retransmit.
+         */
+        if (rtx_timeout || fast_rtx) {
+                list_for_each_entry(chunk1, lqueue, transmitted_list) {
+                        if (chunk1->fast_retransmit > 0)
+                                chunk1->fast_retransmit = -1;
                 }
         }
 
+        *start_timer = timer;
+
+        /* Clear fast retransmit hint */
+        if (fast_rtx)
+                q->fast_rtx = 0;
+
         return error;
 }
 
@@ -862,7 +895,8 @@ int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                                                     rtx_timeout, &start_timer);
 
                         if (start_timer)
-                                sctp_transport_reset_timers(transport);
+                                sctp_transport_reset_timers(transport,
+                                                            start_timer-1);
 
                         /* This can happen on COOKIE-ECHO resend.  Only
                          * one chunk can get bundled with a COOKIE-ECHO.
@@ -977,7 +1011,7 @@ int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
                         list_add_tail(&chunk->transmitted_list,
                                       &transport->transmitted);
 
-                        sctp_transport_reset_timers(transport);
+                        sctp_transport_reset_timers(transport, start_timer-1);
 
                         q->empty = 0;
 
diff --git a/net/sctp/protocol.c b/net/sctp/protocol.c
index 0ec234b762c2..b435a193c5df 100644
--- a/net/sctp/protocol.c
+++ b/net/sctp/protocol.c
@@ -470,11 +470,11 @@ static struct dst_entry *sctp_v4_get_dst(struct sctp_association *asoc,
                 /* Walk through the bind address list and look for a bind
                  * address that matches the source address of the returned dst.
                  */
+                sctp_v4_dst_saddr(&dst_saddr, dst, htons(bp->port));
                 rcu_read_lock();
                 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
                         if (!laddr->valid || (laddr->state != SCTP_ADDR_SRC))
                                 continue;
-                        sctp_v4_dst_saddr(&dst_saddr, dst, htons(bp->port));
                         if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
                                 goto out_unlock;
                 }
@@ -519,7 +519,8 @@ out:
 /* For v4, the source address is cached in the route entry(dst). So no need
  * to cache it separately and hence this is an empty routine.
  */
-static void sctp_v4_get_saddr(struct sctp_association *asoc,
+static void sctp_v4_get_saddr(struct sctp_sock *sk,
+                              struct sctp_association *asoc,
                               struct dst_entry *dst,
                               union sctp_addr *daddr,
                               union sctp_addr *saddr)
@@ -616,6 +617,11 @@ static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
         seq_printf(seq, "%d.%d.%d.%d ", NIPQUAD(addr->v4.sin_addr));
 }
 
+static void sctp_v4_ecn_capable(struct sock *sk)
+{
+        INET_ECN_xmit(sk);
+}
+
 /* Event handler for inet address addition/deletion events.
  * The sctp_local_addr_list needs to be protocted by a spin lock since
  * multiple notifiers (say IPv4 and IPv6) may be running at the same
@@ -934,6 +940,7 @@ static struct sctp_af sctp_af_inet = {
         .skb_iif           = sctp_v4_skb_iif,
         .is_ce             = sctp_v4_is_ce,
         .seq_dump_addr     = sctp_v4_seq_dump_addr,
+        .ecn_capable       = sctp_v4_ecn_capable,
         .net_header_len    = sizeof(struct iphdr),
         .sockaddr_len      = sizeof(struct sockaddr_in),
 #ifdef CONFIG_COMPAT
diff --git a/net/sctp/transport.c b/net/sctp/transport.c
index f4938f6c5abe..3f34f61221ec 100644
--- a/net/sctp/transport.c
+++ b/net/sctp/transport.c
@@ -79,6 +79,7 @@ static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer,
         peer->rttvar = 0;
         peer->srtt = 0;
         peer->rto_pending = 0;
+        peer->fast_recovery = 0;
 
         peer->last_time_heard = jiffies;
         peer->last_time_used = jiffies;
@@ -190,7 +191,7 @@ static void sctp_transport_destroy(struct sctp_transport *transport)
 /* Start T3_rtx timer if it is not already running and update the heartbeat
  * timer.  This routine is called every time a DATA chunk is sent.
  */
-void sctp_transport_reset_timers(struct sctp_transport *transport)
+void sctp_transport_reset_timers(struct sctp_transport *transport, int force)
 {
         /* RFC 2960 6.3.2 Retransmission Timer Rules
          *
@@ -200,7 +201,7 @@ void sctp_transport_reset_timers(struct sctp_transport *transport)
          * address.
          */
 
-        if (!timer_pending(&transport->T3_rtx_timer))
+        if (force || !timer_pending(&transport->T3_rtx_timer))
                 if (!mod_timer(&transport->T3_rtx_timer,
                                jiffies + transport->rto))
                         sctp_transport_hold(transport);
@@ -291,7 +292,7 @@ void sctp_transport_route(struct sctp_transport *transport,
         if (saddr)
                 memcpy(&transport->saddr, saddr, sizeof(union sctp_addr));
         else
-                af->get_saddr(asoc, dst, daddr, &transport->saddr);
+                af->get_saddr(opt, asoc, dst, daddr, &transport->saddr);
 
         transport->dst = dst;
         if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) {
@@ -403,11 +404,16 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport,
         cwnd = transport->cwnd;
         flight_size = transport->flight_size;
 
+        /* See if we need to exit Fast Recovery first */
+        if (transport->fast_recovery &&
+            TSN_lte(transport->fast_recovery_exit, sack_ctsn))
+                transport->fast_recovery = 0;
+
         /* The appropriate cwnd increase algorithm is performed if, and only
-         * if the cumulative TSN has advanced and the congestion window is
+         * if the cumulative TSN whould advanced and the congestion window is
          * being fully utilized.
          */
-        if ((transport->asoc->ctsn_ack_point >= sack_ctsn) ||
+        if (TSN_lte(sack_ctsn, transport->asoc->ctsn_ack_point) ||
             (flight_size < cwnd))
                 return;
 
@@ -416,17 +422,23 @@ void sctp_transport_raise_cwnd(struct sctp_transport *transport,
         pmtu = transport->asoc->pathmtu;
 
         if (cwnd <= ssthresh) {
-                /* RFC 2960 7.2.1, sctpimpguide-05 2.14.2 When cwnd is less
-                 * than or equal to ssthresh an SCTP endpoint MUST use the
-                 * slow start algorithm to increase cwnd only if the current
-                 * congestion window is being fully utilized and an incoming
-                 * SACK advances the Cumulative TSN Ack Point. Only when these
-                 * two conditions are met can the cwnd be increased otherwise
-                 * the cwnd MUST not be increased. If these conditions are met
-                 * then cwnd MUST be increased by at most the lesser of
-                 * 1) the total size of the previously outstanding DATA
-                 * chunk(s) acknowledged, and 2) the destination's path MTU.
+                /* RFC 4960 7.2.1
+                 * o  When cwnd is less than or equal to ssthresh, an SCTP
+                 *    endpoint MUST use the slow-start algorithm to increase
+                 *    cwnd only if the current congestion window is being fully
+                 *    utilized, an incoming SACK advances the Cumulative TSN
+                 *    Ack Point, and the data sender is not in Fast Recovery.
+                 *    Only when these three conditions are met can the cwnd be
+                 *    increased; otherwise, the cwnd MUST not be increased.
+                 *    If these conditions are met, then cwnd MUST be increased
+                 *    by, at most, the lesser of 1) the total size of the
+                 *    previously outstanding DATA chunk(s) acknowledged, and
+                 *    2) the destination's path MTU.  This upper bound protects
+                 *    against the ACK-Splitting attack outlined in [SAVAGE99].
                  */
+                if (transport->fast_recovery)
+                        return;
+
                 if (bytes_acked > pmtu)
                         cwnd += pmtu;
                 else
@@ -502,6 +514,13 @@ void sctp_transport_lower_cwnd(struct sctp_transport *transport,
                  *      cwnd = ssthresh
                  *      partial_bytes_acked = 0
                  */
+                if (transport->fast_recovery)
+                        return;
+
+                /* Mark Fast recovery */
+                transport->fast_recovery = 1;
+                transport->fast_recovery_exit = transport->asoc->next_tsn - 1;
+
                 transport->ssthresh = max(transport->cwnd/2,
                                           4*transport->asoc->pathmtu);
                 transport->cwnd = transport->ssthresh;
@@ -586,6 +605,7 @@ void sctp_transport_reset(struct sctp_transport *t)
         t->flight_size = 0;
         t->error_count = 0;
         t->rto_pending = 0;
+        t->fast_recovery = 0;
 
         /* Initialize the state information for SFR-CACC */
         t->cacc.changeover_active = 0;
diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
index 2bdd4dddc0e1..fb75f265b39c 100644
--- a/net/wireless/nl80211.c
+++ b/net/wireless/nl80211.c
@@ -187,7 +187,8 @@ static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         return genlmsg_end(msg, hdr);
 
  nla_put_failure:
-        return genlmsg_cancel(msg, hdr);
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
 }
 
 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
@@ -273,7 +274,8 @@ static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
         return genlmsg_end(msg, hdr);
 
  nla_put_failure:
-        return genlmsg_cancel(msg, hdr);
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
 }
 
 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
@@ -928,7 +930,8 @@ static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
         return genlmsg_end(msg, hdr);
 
  nla_put_failure:
-        return genlmsg_cancel(msg, hdr);
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
 }
 
 static int nl80211_dump_station(struct sk_buff *skb,
@@ -1267,7 +1270,8 @@ static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
         return genlmsg_end(msg, hdr);
 
  nla_put_failure:
-        return genlmsg_cancel(msg, hdr);
+        genlmsg_cancel(msg, hdr);
+        return -EMSGSIZE;
 }
 
 static int nl80211_dump_mpath(struct sk_buff *skb,
diff --git a/net/xfrm/xfrm_algo.c b/net/xfrm/xfrm_algo.c
index ac765dd9c7f5..23a2cc04b8cd 100644
--- a/net/xfrm/xfrm_algo.c
+++ b/net/xfrm/xfrm_algo.c
@@ -200,8 +200,8 @@ static struct xfrm_algo_desc aalg_list[] = {
         }
 },
 {
-        .name = "hmac(ripemd160)",
-        .compat = "ripemd160",
+        .name = "hmac(rmd160)",
+        .compat = "rmd160",
 
         .uinfo = {
                 .auth = {