1 files changed, 79 insertions, 41 deletions

diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index f136cec96d95..77e265d7bb8f 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -118,14 +118,33 @@ DEFINE_SNMP_STAT(struct udp_mib, udp_statistics) __read_mostly;
 struct hlist_head udp_hash[UDP_HTABLE_SIZE];
 DEFINE_RWLOCK(udp_hash_lock);
 
-/* Shared by v4/v6 udp. */
-int udp_port_rover;
+static int udp_port_rover;
 
-static int udp_v4_get_port(struct sock *sk, unsigned short snum)
+static inline int udp_lport_inuse(u16 num)
+{
+        struct sock *sk;
+        struct hlist_node *node;
+
+        sk_for_each(sk, node, &udp_hash[num & (UDP_HTABLE_SIZE - 1)])
+                if (inet_sk(sk)->num == num)
+                        return 1;
+        return 0;
+}
+
+/**
+ *  udp_get_port  -  common port lookup for IPv4 and IPv6
+ *
+ *  @sk:          socket struct in question
+ *  @snum:        port number to look up
+ *  @saddr_comp:  AF-dependent comparison of bound local IP addresses
+ */
+int udp_get_port(struct sock *sk, unsigned short snum,
+                 int (*saddr_cmp)(const struct sock *sk1, const struct sock *sk2))
 {
         struct hlist_node *node;
+        struct hlist_head *head;
         struct sock *sk2;
-        struct inet_sock *inet = inet_sk(sk);
+        int    error = 1;
 
         write_lock_bh(&udp_hash_lock);
         if (snum == 0) {
@@ -137,11 +156,10 @@ static int udp_v4_get_port(struct sock *sk, unsigned short snum)
                 best_size_so_far = 32767;
                 best = result = udp_port_rover;
                 for (i = 0; i < UDP_HTABLE_SIZE; i++, result++) {
-                        struct hlist_head *list;
                         int size;
 
-                        list = &udp_hash[result & (UDP_HTABLE_SIZE - 1)];
-                        if (hlist_empty(list)) {
+                        head = &udp_hash[result & (UDP_HTABLE_SIZE - 1)];
+                        if (hlist_empty(head)) {
                                 if (result > sysctl_local_port_range[1])
                                         result = sysctl_local_port_range[0] +
                                                 ((result - sysctl_local_port_range[0]) &
@@ -149,12 +167,11 @@ static int udp_v4_get_port(struct sock *sk, unsigned short snum)
                                 goto gotit;
                         }
                         size = 0;
-                        sk_for_each(sk2, node, list)
-                                if (++size >= best_size_so_far)
-                                        goto next;
-                        best_size_so_far = size;
-                        best = result;
-                next:;
+                        sk_for_each(sk2, node, head)
+                                if (++size < best_size_so_far) {
+                                        best_size_so_far = size;
+                                        best = result;
+                                }
                 }
                 result = best;
                 for(i = 0; i < (1 << 16) / UDP_HTABLE_SIZE; i++, result += UDP_HTABLE_SIZE) {
@@ -170,38 +187,44 @@ static int udp_v4_get_port(struct sock *sk, unsigned short snum)
 gotit:
                 udp_port_rover = snum = result;
         } else {
-                sk_for_each(sk2, node,
-                            &udp_hash[snum & (UDP_HTABLE_SIZE - 1)]) {
-                        struct inet_sock *inet2 = inet_sk(sk2);
-
-                        if (inet2->num == snum &&
-                            sk2 != sk &&
-                            !ipv6_only_sock(sk2) &&
-                            (!sk2->sk_bound_dev_if ||
-                             !sk->sk_bound_dev_if ||
-                             sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
-                            (!inet2->rcv_saddr ||
-                             !inet->rcv_saddr ||
-                             inet2->rcv_saddr == inet->rcv_saddr) &&
-                            (!sk2->sk_reuse || !sk->sk_reuse))
+                head = &udp_hash[snum & (UDP_HTABLE_SIZE - 1)];
+
+                sk_for_each(sk2, node, head)
+                        if (inet_sk(sk2)->num == snum                        &&
+                            sk2 != sk                                        &&
+                            (!sk2->sk_reuse        || !sk->sk_reuse)         &&
+                            (!sk2->sk_bound_dev_if || !sk->sk_bound_dev_if
+                             || sk2->sk_bound_dev_if == sk->sk_bound_dev_if) &&
+                            (*saddr_cmp)(sk, sk2)                              )
                                 goto fail;
-                }
         }
-        inet->num = snum;
+        inet_sk(sk)->num = snum;
         if (sk_unhashed(sk)) {
-                struct hlist_head *h = &udp_hash[snum & (UDP_HTABLE_SIZE - 1)];
-
-                sk_add_node(sk, h);
+                head = &udp_hash[snum & (UDP_HTABLE_SIZE - 1)];
+                sk_add_node(sk, head);
                 sock_prot_inc_use(sk->sk_prot);
         }
-        write_unlock_bh(&udp_hash_lock);
-        return 0;
-
+        error = 0;
 fail:
         write_unlock_bh(&udp_hash_lock);
-        return 1;
+        return error;
+}
+
+static inline int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
+{
+        struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
+
+        return  ( !ipv6_only_sock(sk2)  &&
+                  (!inet1->rcv_saddr || !inet2->rcv_saddr ||
+                   inet1->rcv_saddr == inet2->rcv_saddr      ));
 }
 
+static inline int udp_v4_get_port(struct sock *sk, unsigned short snum)
+{
+        return udp_get_port(sk, snum, ipv4_rcv_saddr_equal);
+}
+
+
 static void udp_v4_hash(struct sock *sk)
 {
         BUG();
@@ -429,7 +452,7 @@ static int udp_push_pending_frames(struct sock *sk, struct udp_sock *up)
                 /*
                  * Only one fragment on the socket.
                  */
-                if (skb->ip_summed == CHECKSUM_HW) {
+                if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         skb->csum = offsetof(struct udphdr, check);
                         uh->check = ~csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst,
                                         up->len, IPPROTO_UDP, 0);
@@ -448,7 +471,7 @@ static int udp_push_pending_frames(struct sock *sk, struct udp_sock *up)
                  * fragments on the socket so that all csums of sk_buffs
                  * should be together.
                  */
-                if (skb->ip_summed == CHECKSUM_HW) {
+                if (skb->ip_summed == CHECKSUM_PARTIAL) {
                         int offset = (unsigned char *)uh - skb->data;
                         skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
 
@@ -603,6 +626,7 @@ int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
                                     .uli_u = { .ports =
                                                { .sport = inet->sport,
                                                  .dport = dport } } };
+                security_sk_classify_flow(sk, &fl);
                 err = ip_route_output_flow(&rt, &fl, sk, !(msg->msg_flags&MSG_DONTWAIT));
                 if (err)
                         goto out;
@@ -661,6 +685,16 @@ out:
                 UDP_INC_STATS_USER(UDP_MIB_OUTDATAGRAMS);
                 return len;
         }
+        /*
+         * ENOBUFS = no kernel mem, SOCK_NOSPACE = no sndbuf space.  Reporting
+         * ENOBUFS might not be good (it's not tunable per se), but otherwise
+         * we don't have a good statistic (IpOutDiscards but it can be too many
+         * things).  We could add another new stat but at least for now that
+         * seems like overkill.
+         */
+        if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
+                UDP_INC_STATS_USER(UDP_MIB_SNDBUFERRORS);
+        }
         return err;
 
 do_confirm:
@@ -980,6 +1014,7 @@ static int udp_encap_rcv(struct sock * sk, struct sk_buff *skb)
 static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
 {
         struct udp_sock *up = udp_sk(sk);
+        int rc;
 
         /*
          *      Charge it to the socket, dropping if the queue is full.
@@ -1026,7 +1061,10 @@ static int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
         }
 
-        if (sock_queue_rcv_skb(sk,skb)<0) {
+        if ((rc = sock_queue_rcv_skb(sk,skb)) < 0) {
+                /* Note that an ENOMEM error is charged twice */
+                if (rc == -ENOMEM)
+                        UDP_INC_STATS_BH(UDP_MIB_RCVBUFERRORS);
                 UDP_INC_STATS_BH(UDP_MIB_INERRORS);
                 kfree_skb(skb);
                 return -1;
@@ -1087,7 +1125,7 @@ static void udp_checksum_init(struct sk_buff *skb, struct udphdr *uh,
 {
         if (uh->check == 0) {
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else if (skb->ip_summed == CHECKSUM_HW) {
+        } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
                 if (!udp_check(uh, ulen, saddr, daddr, skb->csum))
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
         }
@@ -1581,7 +1619,7 @@ EXPORT_SYMBOL(udp_disconnect);
 EXPORT_SYMBOL(udp_hash);
 EXPORT_SYMBOL(udp_hash_lock);
 EXPORT_SYMBOL(udp_ioctl);
-EXPORT_SYMBOL(udp_port_rover);
+EXPORT_SYMBOL(udp_get_port);
 EXPORT_SYMBOL(udp_prot);
 EXPORT_SYMBOL(udp_sendmsg);
 EXPORT_SYMBOL(udp_poll);