ipv4: udp: fix short packet and bad checksum logging

[safe/jmp/linux-2.6] / net / core / filter.c

diff --git a/net/core/filter.c b/net/core/filter.c
index f5f3cf6..ff943be 100644 (file)
--- a/net/core/filter.c
+++ b/net/core/filter.c
@@ -25,6 +25,7 @@
 #include <linux/inet.h>
 #include <linux/netdevice.h>
 #include <linux/if_packet.h>
+#include <linux/gfp.h>
 #include <net/ip.h>
 #include <net/protocol.h>
 #include <net/netlink.h>
@@ -68,7 +69,6 @@ static inline void *load_pointer(struct sk_buff *skb, int k,
  *     sk_filter - run a packet through a socket filter
  *     @sk: sock associated with &sk_buff
  *     @skb: buffer to filter
- *     @needlock: set to 1 if the sock is not locked by caller.
  *
  * Run the filter code and then cut skb->data to correct size returned by
  * sk_run_filter. If pkt_len is 0 we toss packet. If skb->len is smaller
@@ -87,7 +87,7 @@ int sk_filter(struct sock *sk, struct sk_buff *skb)
                return err;
 
        rcu_read_lock_bh();
-       filter = rcu_dereference(sk->sk_filter);
+       filter = rcu_dereference_bh(sk->sk_filter);
        if (filter) {
                unsigned int pkt_len = sk_run_filter(skb, filter->insns,
                                filter->len);
@@ -213,7 +213,7 @@ unsigned int sk_run_filter(struct sk_buff *skb, struct sock_filter *filter, int
 load_w:
                        ptr = load_pointer(skb, k, 4, &tmp);
                        if (ptr != NULL) {
-                               A = ntohl(get_unaligned((__be32 *)ptr));
+                               A = get_unaligned_be32(ptr);
                                continue;
                        }
                        break;
@@ -222,7 +222,7 @@ load_w:
 load_h:
                        ptr = load_pointer(skb, k, 2, &tmp);
                        if (ptr != NULL) {
-                               A = ntohs(get_unaligned((__be16 *)ptr));
+                               A = get_unaligned_be16(ptr);
                                continue;
                        }
                        break;
@@ -304,6 +304,12 @@ load_b:
                case SKF_AD_IFINDEX:
                        A = skb->dev->ifindex;
                        continue;
+               case SKF_AD_MARK:
+                       A = skb->mark;
+                       continue;
+               case SKF_AD_QUEUE:
+                       A = skb->queue_mapping;
+                       continue;
                case SKF_AD_NLATTR: {
                        struct nlattr *nla;
 
@@ -320,6 +326,25 @@ load_b:
                                A = 0;
                        continue;
                }
+               case SKF_AD_NLATTR_NEST: {
+                       struct nlattr *nla;
+
+                       if (skb_is_nonlinear(skb))
+                               return 0;
+                       if (A > skb->len - sizeof(struct nlattr))
+                               return 0;
+
+                       nla = (struct nlattr *)&skb->data[A];
+                       if (nla->nla_len > A - skb->len)
+                               return 0;
+
+                       nla = nla_find_nested(nla, X);
+                       if (nla)
+                               A = (void *)nla - (void *)skb->data;
+                       else
+                               A = 0;
+                       continue;
+               }
                default:
                        return 0;
                }
@@ -497,7 +522,7 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
        }
 
        rcu_read_lock_bh();
-       old_fp = rcu_dereference(sk->sk_filter);
+       old_fp = rcu_dereference_bh(sk->sk_filter);
        rcu_assign_pointer(sk->sk_filter, fp);
        rcu_read_unlock_bh();
 
@@ -505,6 +530,7 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk)
                sk_filter_delayed_uncharge(sk, old_fp);
        return 0;
 }
+EXPORT_SYMBOL_GPL(sk_attach_filter);
 
 int sk_detach_filter(struct sock *sk)
 {
@@ -512,7 +538,7 @@ int sk_detach_filter(struct sock *sk)
        struct sk_filter *filter;
 
        rcu_read_lock_bh();
-       filter = rcu_dereference(sk->sk_filter);
+       filter = rcu_dereference_bh(sk->sk_filter);
        if (filter) {
                rcu_assign_pointer(sk->sk_filter, NULL);
                sk_filter_delayed_uncharge(sk, filter);
@@ -521,3 +547,4 @@ int sk_detach_filter(struct sock *sk)
        rcu_read_unlock_bh();
        return ret;
 }
+EXPORT_SYMBOL_GPL(sk_detach_filter);