[IPV4] UDP: Move IPv4-specific bits to other file.
authorYOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
Tue, 4 Mar 2008 05:50:52 +0000 (14:50 +0900)
committerYOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
Tue, 4 Mar 2008 06:18:22 +0000 (15:18 +0900)
Move IPv4-specific UDP bits from net/ipv4/udp.c into (new) net/ipv4/udp_ipv4.c.
Rename net/ipv4/udplite.c to net/ipv4/udplite_ipv4.c.

Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
net/ipv4/Makefile
net/ipv4/udp.c
net/ipv4/udp_ipv4.c [new file with mode: 0644]
net/ipv4/udplite.c [deleted file]
net/ipv4/udplite_ipv4.c [new file with mode: 0644]

index e88cebdf3e306228dceb60b0f8dd669bff20e906..d5226241d5ed79281c2c9e9ee580a2c039e7350f 100644 (file)
@@ -8,7 +8,7 @@ obj-y     := route.o inetpeer.o protocol.o \
             inet_timewait_sock.o inet_connection_sock.o \
             tcp.o tcp_input.o tcp_output.o tcp_timer.o tcp_ipv4.o \
             tcp_minisocks.o tcp_cong.o \
-            datagram.o raw.o udp.o \
+            datagram.o raw.o udp.o udp_ipv4.o \
             arp.o icmp.o devinet.o af_inet.o  igmp.o \
             fib_frontend.o fib_semantics.o \
             inet_fragment.o
@@ -49,7 +49,7 @@ obj-$(CONFIG_TCP_CONG_SCALABLE) += tcp_scalable.o
 obj-$(CONFIG_TCP_CONG_LP) += tcp_lp.o
 obj-$(CONFIG_TCP_CONG_YEAH) += tcp_yeah.o
 obj-$(CONFIG_TCP_CONG_ILLINOIS) += tcp_illinois.o
-obj-$(CONFIG_IP_UDPLITE) += udplite.o
+obj-$(CONFIG_IP_UDPLITE) += udplite_ipv4.o
 obj-$(CONFIG_NETLABEL) += cipso_ipv4.o
 
 obj-$(CONFIG_XFRM) += xfrm4_policy.o xfrm4_state.o xfrm4_input.o \
index acc353aa89eb00159783b3851852e322c98984f2..c53d7673b57d5b68f7b7784daabba08c0b9c4c8b 100644 (file)
@@ -246,553 +246,6 @@ int udp_get_port(struct sock *sk, unsigned short snum,
        return  __udp_lib_get_port(sk, snum, udp_hash, scmp);
 }
 
-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);
-}
-
-/* UDP is nearly always wildcards out the wazoo, it makes no sense to try
- * harder than this. -DaveM
- */
-static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
-               __be16 sport, __be32 daddr, __be16 dport,
-               int dif, struct hlist_head udptable[])
-{
-       struct sock *sk, *result = NULL;
-       struct hlist_node *node;
-       unsigned short hnum = ntohs(dport);
-       int badness = -1;
-
-       read_lock(&udp_hash_lock);
-       sk_for_each(sk, node, &udptable[hnum & (UDP_HTABLE_SIZE - 1)]) {
-               struct inet_sock *inet = inet_sk(sk);
-
-               if (sk->sk_net == net && sk->sk_hash == hnum &&
-                               !ipv6_only_sock(sk)) {
-                       int score = (sk->sk_family == PF_INET ? 1 : 0);
-                       if (inet->rcv_saddr) {
-                               if (inet->rcv_saddr != daddr)
-                                       continue;
-                               score+=2;
-                       }
-                       if (inet->daddr) {
-                               if (inet->daddr != saddr)
-                                       continue;
-                               score+=2;
-                       }
-                       if (inet->dport) {
-                               if (inet->dport != sport)
-                                       continue;
-                               score+=2;
-                       }
-                       if (sk->sk_bound_dev_if) {
-                               if (sk->sk_bound_dev_if != dif)
-                                       continue;
-                               score+=2;
-                       }
-                       if (score == 9) {
-                               result = sk;
-                               break;
-                       } else if (score > badness) {
-                               result = sk;
-                               badness = score;
-                       }
-               }
-       }
-       if (result)
-               sock_hold(result);
-       read_unlock(&udp_hash_lock);
-       return result;
-}
-
-static inline struct sock *udp_v4_mcast_next(struct sock *sk,
-                                            __be16 loc_port, __be32 loc_addr,
-                                            __be16 rmt_port, __be32 rmt_addr,
-                                            int dif)
-{
-       struct hlist_node *node;
-       struct sock *s = sk;
-       unsigned short hnum = ntohs(loc_port);
-
-       sk_for_each_from(s, node) {
-               struct inet_sock *inet = inet_sk(s);
-
-               if (s->sk_hash != hnum                                  ||
-                   (inet->daddr && inet->daddr != rmt_addr)            ||
-                   (inet->dport != rmt_port && inet->dport)            ||
-                   (inet->rcv_saddr && inet->rcv_saddr != loc_addr)    ||
-                   ipv6_only_sock(s)                                   ||
-                   (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
-                       continue;
-               if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
-                       continue;
-               goto found;
-       }
-       s = NULL;
-found:
-       return s;
-}
-
-/*
- * This routine is called by the ICMP module when it gets some
- * sort of error condition.  If err < 0 then the socket should
- * be closed and the error returned to the user.  If err > 0
- * it's just the icmp type << 8 | icmp code.
- * Header points to the ip header of the error packet. We move
- * on past this. Then (as it used to claim before adjustment)
- * header points to the first 8 bytes of the udp header.  We need
- * to find the appropriate port.
- */
-
-void __udp4_lib_err(struct sk_buff *skb, u32 info, struct hlist_head udptable[])
-{
-       struct inet_sock *inet;
-       struct iphdr *iph = (struct iphdr*)skb->data;
-       struct udphdr *uh = (struct udphdr*)(skb->data+(iph->ihl<<2));
-       const int type = icmp_hdr(skb)->type;
-       const int code = icmp_hdr(skb)->code;
-       struct sock *sk;
-       int harderr;
-       int err;
-
-       sk = __udp4_lib_lookup(skb->dev->nd_net, iph->daddr, uh->dest,
-                       iph->saddr, uh->source, skb->dev->ifindex, udptable);
-       if (sk == NULL) {
-               ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
-               return; /* No socket for error */
-       }
-
-       err = 0;
-       harderr = 0;
-       inet = inet_sk(sk);
-
-       switch (type) {
-       default:
-       case ICMP_TIME_EXCEEDED:
-               err = EHOSTUNREACH;
-               break;
-       case ICMP_SOURCE_QUENCH:
-               goto out;
-       case ICMP_PARAMETERPROB:
-               err = EPROTO;
-               harderr = 1;
-               break;
-       case ICMP_DEST_UNREACH:
-               if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
-                       if (inet->pmtudisc != IP_PMTUDISC_DONT) {
-                               err = EMSGSIZE;
-                               harderr = 1;
-                               break;
-                       }
-                       goto out;
-               }
-               err = EHOSTUNREACH;
-               if (code <= NR_ICMP_UNREACH) {
-                       harderr = icmp_err_convert[code].fatal;
-                       err = icmp_err_convert[code].errno;
-               }
-               break;
-       }
-
-       /*
-        *      RFC1122: OK.  Passes ICMP errors back to application, as per
-        *      4.1.3.3.
-        */
-       if (!inet->recverr) {
-               if (!harderr || sk->sk_state != TCP_ESTABLISHED)
-                       goto out;
-       } else {
-               ip_icmp_error(sk, skb, err, uh->dest, info, (u8*)(uh+1));
-       }
-       sk->sk_err = err;
-       sk->sk_error_report(sk);
-out:
-       sock_put(sk);
-}
-
-void udp_err(struct sk_buff *skb, u32 info)
-{
-       __udp4_lib_err(skb, info, udp_hash);
-}
-
-/*
- * Throw away all pending data and cancel the corking. Socket is locked.
- */
-static void udp_flush_pending_frames(struct sock *sk)
-{
-       struct udp_sock *up = udp_sk(sk);
-
-       if (up->pending) {
-               up->len = 0;
-               up->pending = 0;
-               ip_flush_pending_frames(sk);
-       }
-}
-
-/**
- *     udp4_hwcsum_outgoing  -  handle outgoing HW checksumming
- *     @sk:    socket we are sending on
- *     @skb:   sk_buff containing the filled-in UDP header
- *             (checksum field must be zeroed out)
- */
-static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
-                                __be32 src, __be32 dst, int len      )
-{
-       unsigned int offset;
-       struct udphdr *uh = udp_hdr(skb);
-       __wsum csum = 0;
-
-       if (skb_queue_len(&sk->sk_write_queue) == 1) {
-               /*
-                * Only one fragment on the socket.
-                */
-               skb->csum_start = skb_transport_header(skb) - skb->head;
-               skb->csum_offset = offsetof(struct udphdr, check);
-               uh->check = ~csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, 0);
-       } else {
-               /*
-                * HW-checksum won't work as there are two or more
-                * fragments on the socket so that all csums of sk_buffs
-                * should be together
-                */
-               offset = skb_transport_offset(skb);
-               skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
-
-               skb->ip_summed = CHECKSUM_NONE;
-
-               skb_queue_walk(&sk->sk_write_queue, skb) {
-                       csum = csum_add(csum, skb->csum);
-               }
-
-               uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
-               if (uh->check == 0)
-                       uh->check = CSUM_MANGLED_0;
-       }
-}
-
-/*
- * Push out all pending data as one UDP datagram. Socket is locked.
- */
-static int udp_push_pending_frames(struct sock *sk)
-{
-       struct udp_sock  *up = udp_sk(sk);
-       struct inet_sock *inet = inet_sk(sk);
-       struct flowi *fl = &inet->cork.fl;
-       struct sk_buff *skb;
-       struct udphdr *uh;
-       int err = 0;
-       int is_udplite = IS_UDPLITE(sk);
-       __wsum csum = 0;
-
-       /* Grab the skbuff where UDP header space exists. */
-       if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
-               goto out;
-
-       /*
-        * Create a UDP header
-        */
-       uh = udp_hdr(skb);
-       uh->source = fl->fl_ip_sport;
-       uh->dest = fl->fl_ip_dport;
-       uh->len = htons(up->len);
-       uh->check = 0;
-
-       if (is_udplite)                                  /*     UDP-Lite      */
-               csum  = udplite_csum_outgoing(sk, skb);
-
-       else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {   /* UDP csum disabled */
-
-               skb->ip_summed = CHECKSUM_NONE;
-               goto send;
-
-       } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
-
-               udp4_hwcsum_outgoing(sk, skb, fl->fl4_src,fl->fl4_dst, up->len);
-               goto send;
-
-       } else                                           /*   `normal' UDP    */
-               csum = udp_csum_outgoing(sk, skb);
-
-       /* add protocol-dependent pseudo-header */
-       uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
-                                     sk->sk_protocol, csum             );
-       if (uh->check == 0)
-               uh->check = CSUM_MANGLED_0;
-
-send:
-       err = ip_push_pending_frames(sk);
-out:
-       up->len = 0;
-       up->pending = 0;
-       if (!err)
-               UDP_INC_STATS_USER(UDP_MIB_OUTDATAGRAMS, is_udplite);
-       return err;
-}
-
-int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
-               size_t len)
-{
-       struct inet_sock *inet = inet_sk(sk);
-       struct udp_sock *up = udp_sk(sk);
-       int ulen = len;
-       struct ipcm_cookie ipc;
-       struct rtable *rt = NULL;
-       int free = 0;
-       int connected = 0;
-       __be32 daddr, faddr, saddr;
-       __be16 dport;
-       u8  tos;
-       int err, is_udplite = IS_UDPLITE(sk);
-       int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
-       int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
-
-       if (len > 0xFFFF)
-               return -EMSGSIZE;
-
-       /*
-        *      Check the flags.
-        */
-
-       if (msg->msg_flags&MSG_OOB)     /* Mirror BSD error message compatibility */
-               return -EOPNOTSUPP;
-
-       ipc.opt = NULL;
-
-       if (up->pending) {
-               /*
-                * There are pending frames.
-                * The socket lock must be held while it's corked.
-                */
-               lock_sock(sk);
-               if (likely(up->pending)) {
-                       if (unlikely(up->pending != AF_INET)) {
-                               release_sock(sk);
-                               return -EINVAL;
-                       }
-                       goto do_append_data;
-               }
-               release_sock(sk);
-       }
-       ulen += sizeof(struct udphdr);
-
-       /*
-        *      Get and verify the address.
-        */
-       if (msg->msg_name) {
-               struct sockaddr_in * usin = (struct sockaddr_in*)msg->msg_name;
-               if (msg->msg_namelen < sizeof(*usin))
-                       return -EINVAL;
-               if (usin->sin_family != AF_INET) {
-                       if (usin->sin_family != AF_UNSPEC)
-                               return -EAFNOSUPPORT;
-               }
-
-               daddr = usin->sin_addr.s_addr;
-               dport = usin->sin_port;
-               if (dport == 0)
-                       return -EINVAL;
-       } else {
-               if (sk->sk_state != TCP_ESTABLISHED)
-                       return -EDESTADDRREQ;
-               daddr = inet->daddr;
-               dport = inet->dport;
-               /* Open fast path for connected socket.
-                  Route will not be used, if at least one option is set.
-                */
-               connected = 1;
-       }
-       ipc.addr = inet->saddr;
-
-       ipc.oif = sk->sk_bound_dev_if;
-       if (msg->msg_controllen) {
-               err = ip_cmsg_send(msg, &ipc);
-               if (err)
-                       return err;
-               if (ipc.opt)
-                       free = 1;
-               connected = 0;
-       }
-       if (!ipc.opt)
-               ipc.opt = inet->opt;
-
-       saddr = ipc.addr;
-       ipc.addr = faddr = daddr;
-
-       if (ipc.opt && ipc.opt->srr) {
-               if (!daddr)
-                       return -EINVAL;
-               faddr = ipc.opt->faddr;
-               connected = 0;
-       }
-       tos = RT_TOS(inet->tos);
-       if (sock_flag(sk, SOCK_LOCALROUTE) ||
-           (msg->msg_flags & MSG_DONTROUTE) ||
-           (ipc.opt && ipc.opt->is_strictroute)) {
-               tos |= RTO_ONLINK;
-               connected = 0;
-       }
-
-       if (ipv4_is_multicast(daddr)) {
-               if (!ipc.oif)
-                       ipc.oif = inet->mc_index;
-               if (!saddr)
-                       saddr = inet->mc_addr;
-               connected = 0;
-       }
-
-       if (connected)
-               rt = (struct rtable*)sk_dst_check(sk, 0);
-
-       if (rt == NULL) {
-               struct flowi fl = { .oif = ipc.oif,
-                                   .nl_u = { .ip4_u =
-                                             { .daddr = faddr,
-                                               .saddr = saddr,
-                                               .tos = tos } },
-                                   .proto = sk->sk_protocol,
-                                   .uli_u = { .ports =
-                                              { .sport = inet->sport,
-                                                .dport = dport } } };
-               security_sk_classify_flow(sk, &fl);
-               err = ip_route_output_flow(&init_net, &rt, &fl, sk, 1);
-               if (err) {
-                       if (err == -ENETUNREACH)
-                               IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
-                       goto out;
-               }
-
-               err = -EACCES;
-               if ((rt->rt_flags & RTCF_BROADCAST) &&
-                   !sock_flag(sk, SOCK_BROADCAST))
-                       goto out;
-               if (connected)
-                       sk_dst_set(sk, dst_clone(&rt->u.dst));
-       }
-
-       if (msg->msg_flags&MSG_CONFIRM)
-               goto do_confirm;
-back_from_confirm:
-
-       saddr = rt->rt_src;
-       if (!ipc.addr)
-               daddr = ipc.addr = rt->rt_dst;
-
-       lock_sock(sk);
-       if (unlikely(up->pending)) {
-               /* The socket is already corked while preparing it. */
-               /* ... which is an evident application bug. --ANK */
-               release_sock(sk);
-
-               LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
-               err = -EINVAL;
-               goto out;
-       }
-       /*
-        *      Now cork the socket to pend data.
-        */
-       inet->cork.fl.fl4_dst = daddr;
-       inet->cork.fl.fl_ip_dport = dport;
-       inet->cork.fl.fl4_src = saddr;
-       inet->cork.fl.fl_ip_sport = inet->sport;
-       up->pending = AF_INET;
-
-do_append_data:
-       up->len += ulen;
-       getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
-       err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,
-                       sizeof(struct udphdr), &ipc, rt,
-                       corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
-       if (err)
-               udp_flush_pending_frames(sk);
-       else if (!corkreq)
-               err = udp_push_pending_frames(sk);
-       else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
-               up->pending = 0;
-       release_sock(sk);
-
-out:
-       ip_rt_put(rt);
-       if (free)
-               kfree(ipc.opt);
-       if (!err)
-               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, is_udplite);
-       }
-       return err;
-
-do_confirm:
-       dst_confirm(&rt->u.dst);
-       if (!(msg->msg_flags&MSG_PROBE) || len)
-               goto back_from_confirm;
-       err = 0;
-       goto out;
-}
-
-int udp_sendpage(struct sock *sk, struct page *page, int offset,
-                size_t size, int flags)
-{
-       struct udp_sock *up = udp_sk(sk);
-       int ret;
-
-       if (!up->pending) {
-               struct msghdr msg = {   .msg_flags = flags|MSG_MORE };
-
-               /* Call udp_sendmsg to specify destination address which
-                * sendpage interface can't pass.
-                * This will succeed only when the socket is connected.
-                */
-               ret = udp_sendmsg(NULL, sk, &msg, 0);
-               if (ret < 0)
-                       return ret;
-       }
-
-       lock_sock(sk);
-
-       if (unlikely(!up->pending)) {
-               release_sock(sk);
-
-               LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 3\n");
-               return -EINVAL;
-       }
-
-       ret = ip_append_page(sk, page, offset, size, flags);
-       if (ret == -EOPNOTSUPP) {
-               release_sock(sk);
-               return sock_no_sendpage(sk->sk_socket, page, offset,
-                                       size, flags);
-       }
-       if (ret < 0) {
-               udp_flush_pending_frames(sk);
-               goto out;
-       }
-
-       up->len += size;
-       if (!(up->corkflag || (flags&MSG_MORE)))
-               ret = udp_push_pending_frames(sk);
-       if (!ret)
-               ret = size;
-out:
-       release_sock(sk);
-       return ret;
-}
-
 /*
  *     IOCTL requests applicable to the UDP protocol
  */
@@ -833,107 +286,6 @@ int udp_ioctl(struct sock *sk, int cmd, unsigned long arg)
        return 0;
 }
 
-/*
- *     This should be easy, if there is something there we
- *     return it, otherwise we block.
- */
-
-int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
-               size_t len, int noblock, int flags, int *addr_len)
-{
-       struct inet_sock *inet = inet_sk(sk);
-       struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
-       struct sk_buff *skb;
-       unsigned int ulen, copied;
-       int peeked;
-       int err;
-       int is_udplite = IS_UDPLITE(sk);
-
-       /*
-        *      Check any passed addresses
-        */
-       if (addr_len)
-               *addr_len=sizeof(*sin);
-
-       if (flags & MSG_ERRQUEUE)
-               return ip_recv_error(sk, msg, len);
-
-try_again:
-       skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
-                                 &peeked, &err);
-       if (!skb)
-               goto out;
-
-       ulen = skb->len - sizeof(struct udphdr);
-       copied = len;
-       if (copied > ulen)
-               copied = ulen;
-       else if (copied < ulen)
-               msg->msg_flags |= MSG_TRUNC;
-
-       /*
-        * If checksum is needed at all, try to do it while copying the
-        * data.  If the data is truncated, or if we only want a partial
-        * coverage checksum (UDP-Lite), do it before the copy.
-        */
-
-       if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
-               if (udp_lib_checksum_complete(skb))
-                       goto csum_copy_err;
-       }
-
-       if (skb_csum_unnecessary(skb))
-               err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
-                                             msg->msg_iov, copied       );
-       else {
-               err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
-
-               if (err == -EINVAL)
-                       goto csum_copy_err;
-       }
-
-       if (err)
-               goto out_free;
-
-       if (!peeked)
-               UDP_INC_STATS_USER(UDP_MIB_INDATAGRAMS, is_udplite);
-
-       sock_recv_timestamp(msg, sk, skb);
-
-       /* Copy the address. */
-       if (sin)
-       {
-               sin->sin_family = AF_INET;
-               sin->sin_port = udp_hdr(skb)->source;
-               sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
-               memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
-       }
-       if (inet->cmsg_flags)
-               ip_cmsg_recv(msg, skb);
-
-       err = copied;
-       if (flags & MSG_TRUNC)
-               err = ulen;
-
-out_free:
-       lock_sock(sk);
-       skb_free_datagram(sk, skb);
-       release_sock(sk);
-out:
-       return err;
-
-csum_copy_err:
-       lock_sock(sk);
-       if (!skb_kill_datagram(sk, skb, flags))
-               UDP_INC_STATS_USER(UDP_MIB_INERRORS, is_udplite);
-       release_sock(sk);
-
-       if (noblock)
-               return -EAGAIN;
-       goto try_again;
-}
-
-
 int udp_disconnect(struct sock *sk, int flags)
 {
        struct inet_sock *inet = inet_sk(sk);
@@ -956,319 +308,6 @@ int udp_disconnect(struct sock *sk, int flags)
        return 0;
 }
 
-/* returns:
- *  -1: error
- *   0: success
- *  >0: "udp encap" protocol resubmission
- *
- * Note that in the success and error cases, the skb is assumed to
- * have either been requeued or freed.
- */
-int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
-{
-       struct udp_sock *up = udp_sk(sk);
-       int rc;
-       int is_udplite = IS_UDPLITE(sk);
-
-       /*
-        *      Charge it to the socket, dropping if the queue is full.
-        */
-       if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
-               goto drop;
-       nf_reset(skb);
-
-       if (up->encap_type) {
-               /*
-                * This is an encapsulation socket so pass the skb to
-                * the socket's udp_encap_rcv() hook. Otherwise, just
-                * fall through and pass this up the UDP socket.
-                * up->encap_rcv() returns the following value:
-                * =0 if skb was successfully passed to the encap
-                *    handler or was discarded by it.
-                * >0 if skb should be passed on to UDP.
-                * <0 if skb should be resubmitted as proto -N
-                */
-
-               /* if we're overly short, let UDP handle it */
-               if (skb->len > sizeof(struct udphdr) &&
-                   up->encap_rcv != NULL) {
-                       int ret;
-
-                       ret = (*up->encap_rcv)(sk, skb);
-                       if (ret <= 0) {
-                               UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS,
-                                                is_udplite);
-                               return -ret;
-                       }
-               }
-
-               /* FALLTHROUGH -- it's a UDP Packet */
-       }
-
-       /*
-        *      UDP-Lite specific tests, ignored on UDP sockets
-        */
-       if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
-
-               /*
-                * MIB statistics other than incrementing the error count are
-                * disabled for the following two types of errors: these depend
-                * on the application settings, not on the functioning of the
-                * protocol stack as such.
-                *
-                * RFC 3828 here recommends (sec 3.3): "There should also be a
-                * way ... to ... at least let the receiving application block
-                * delivery of packets with coverage values less than a value
-                * provided by the application."
-                */
-               if (up->pcrlen == 0) {          /* full coverage was set  */
-                       LIMIT_NETDEBUG(KERN_WARNING "UDPLITE: partial coverage "
-                               "%d while full coverage %d requested\n",
-                               UDP_SKB_CB(skb)->cscov, skb->len);
-                       goto drop;
-               }
-               /* The next case involves violating the min. coverage requested
-                * by the receiver. This is subtle: if receiver wants x and x is
-                * greater than the buffersize/MTU then receiver will complain
-                * that it wants x while sender emits packets of smaller size y.
-                * Therefore the above ...()->partial_cov statement is essential.
-                */
-               if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
-                       LIMIT_NETDEBUG(KERN_WARNING
-                               "UDPLITE: coverage %d too small, need min %d\n",
-                               UDP_SKB_CB(skb)->cscov, up->pcrlen);
-                       goto drop;
-               }
-       }
-
-       if (sk->sk_filter) {
-               if (udp_lib_checksum_complete(skb))
-                       goto drop;
-       }
-
-       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, is_udplite);
-               goto drop;
-       }
-
-       return 0;
-
-drop:
-       UDP_INC_STATS_BH(UDP_MIB_INERRORS, is_udplite);
-       kfree_skb(skb);
-       return -1;
-}
-
-/*
- *     Multicasts and broadcasts go to each listener.
- *
- *     Note: called only from the BH handler context,
- *     so we don't need to lock the hashes.
- */
-static int __udp4_lib_mcast_deliver(struct sk_buff *skb,
-                                   struct udphdr  *uh,
-                                   __be32 saddr, __be32 daddr,
-                                   struct hlist_head udptable[])
-{
-       struct sock *sk;
-       int dif;
-
-       read_lock(&udp_hash_lock);
-       sk = sk_head(&udptable[ntohs(uh->dest) & (UDP_HTABLE_SIZE - 1)]);
-       dif = skb->dev->ifindex;
-       sk = udp_v4_mcast_next(sk, uh->dest, daddr, uh->source, saddr, dif);
-       if (sk) {
-               struct sock *sknext = NULL;
-
-               do {
-                       struct sk_buff *skb1 = skb;
-
-                       sknext = udp_v4_mcast_next(sk_next(sk), uh->dest, daddr,
-                                                  uh->source, saddr, dif);
-                       if (sknext)
-                               skb1 = skb_clone(skb, GFP_ATOMIC);
-
-                       if (skb1) {
-                               int ret = 0;
-
-                               bh_lock_sock_nested(sk);
-                               if (!sock_owned_by_user(sk))
-                                       ret = udp_queue_rcv_skb(sk, skb1);
-                               else
-                                       sk_add_backlog(sk, skb1);
-                               bh_unlock_sock(sk);
-
-                               if (ret > 0)
-                                       /* we should probably re-process instead
-                                        * of dropping packets here. */
-                                       kfree_skb(skb1);
-                       }
-                       sk = sknext;
-               } while (sknext);
-       } else
-               kfree_skb(skb);
-       read_unlock(&udp_hash_lock);
-       return 0;
-}
-
-/* Initialize UDP checksum. If exited with zero value (success),
- * CHECKSUM_UNNECESSARY means, that no more checks are required.
- * Otherwise, csum completion requires chacksumming packet body,
- * including udp header and folding it to skb->csum.
- */
-static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
-                                int proto)
-{
-       const struct iphdr *iph;
-       int err;
-
-       UDP_SKB_CB(skb)->partial_cov = 0;
-       UDP_SKB_CB(skb)->cscov = skb->len;
-
-       if (IS_PROTO_UDPLITE(proto)) {
-               err = udplite_checksum_init(skb, uh);
-               if (err)
-                       return err;
-       }
-
-       iph = ip_hdr(skb);
-       if (uh->check == 0) {
-               skb->ip_summed = CHECKSUM_UNNECESSARY;
-       } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
-              if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
-                                     proto, skb->csum))
-                       skb->ip_summed = CHECKSUM_UNNECESSARY;
-       }
-       if (!skb_csum_unnecessary(skb))
-               skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
-                                              skb->len, proto, 0);
-       /* Probably, we should checksum udp header (it should be in cache
-        * in any case) and data in tiny packets (< rx copybreak).
-        */
-
-       return 0;
-}
-
-/*
- *     All we need to do is get the socket, and then do a checksum.
- */
-
-int __udp4_lib_rcv(struct sk_buff *skb, struct hlist_head udptable[],
-                  int proto)
-{
-       struct sock *sk;
-       struct udphdr *uh = udp_hdr(skb);
-       unsigned short ulen;
-       struct rtable *rt = (struct rtable*)skb->dst;
-       __be32 saddr = ip_hdr(skb)->saddr;
-       __be32 daddr = ip_hdr(skb)->daddr;
-
-       /*
-        *  Validate the packet.
-        */
-       if (!pskb_may_pull(skb, sizeof(struct udphdr)))
-               goto drop;              /* No space for header. */
-
-       ulen = ntohs(uh->len);
-       if (ulen > skb->len)
-               goto short_packet;
-
-       if (IS_PROTO_UDPLITE(proto)) {
-               /* UDP validates ulen. */
-               if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
-                       goto short_packet;
-               uh = udp_hdr(skb);
-       }
-
-       if (udp4_csum_init(skb, uh, proto))
-               goto csum_error;
-
-       if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
-               return __udp4_lib_mcast_deliver(skb, uh, saddr, daddr, udptable);
-
-       sk = __udp4_lib_lookup(skb->dev->nd_net, saddr, uh->source, daddr,
-                       uh->dest, inet_iif(skb), udptable);
-
-       if (sk != NULL) {
-               int ret = 0;
-               bh_lock_sock_nested(sk);
-               if (!sock_owned_by_user(sk))
-                       ret = udp_queue_rcv_skb(sk, skb);
-               else
-                       sk_add_backlog(sk, skb);
-               bh_unlock_sock(sk);
-               sock_put(sk);
-
-               /* a return value > 0 means to resubmit the input, but
-                * it wants the return to be -protocol, or 0
-                */
-               if (ret > 0)
-                       return -ret;
-               return 0;
-       }
-
-       if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
-               goto drop;
-       nf_reset(skb);
-
-       /* No socket. Drop packet silently, if checksum is wrong */
-       if (udp_lib_checksum_complete(skb))
-               goto csum_error;
-
-       UDP_INC_STATS_BH(UDP_MIB_NOPORTS, IS_PROTO_UDPLITE(proto));
-       icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
-
-       /*
-        * Hmm.  We got an UDP packet to a port to which we
-        * don't wanna listen.  Ignore it.
-        */
-       kfree_skb(skb);
-       return 0;
-
-short_packet:
-       LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %u.%u.%u.%u:%u %d/%d to %u.%u.%u.%u:%u\n",
-                      IS_PROTO_UDPLITE(proto) ? "-Lite" : "",
-                      NIPQUAD(saddr),
-                      ntohs(uh->source),
-                      ulen,
-                      skb->len,
-                      NIPQUAD(daddr),
-                      ntohs(uh->dest));
-       goto drop;
-
-csum_error:
-       /*
-        * RFC1122: OK.  Discards the bad packet silently (as far as
-        * the network is concerned, anyway) as per 4.1.3.4 (MUST).
-        */
-       LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %d.%d.%d.%d:%d to %d.%d.%d.%d:%d ulen %d\n",
-                      IS_PROTO_UDPLITE(proto) ? "-Lite" : "",
-                      NIPQUAD(saddr),
-                      ntohs(uh->source),
-                      NIPQUAD(daddr),
-                      ntohs(uh->dest),
-                      ulen);
-drop:
-       UDP_INC_STATS_BH(UDP_MIB_INERRORS, IS_PROTO_UDPLITE(proto));
-       kfree_skb(skb);
-       return 0;
-}
-
-int udp_rcv(struct sk_buff *skb)
-{
-       return __udp4_lib_rcv(skb, udp_hash, IPPROTO_UDP);
-}
-
-int udp_destroy_sock(struct sock *sk)
-{
-       lock_sock(sk);
-       udp_flush_pending_frames(sk);
-       release_sock(sk);
-       return 0;
-}
-
 /*
  *     Socket option code for UDP
  */
@@ -1353,26 +392,6 @@ int udp_lib_setsockopt(struct sock *sk, int level, int optname,
        return err;
 }
 
-int udp_setsockopt(struct sock *sk, int level, int optname,
-                  char __user *optval, int optlen)
-{
-       if (IS_SOL_UDPFAMILY(level))
-               return udp_lib_setsockopt(sk, level, optname, optval, optlen,
-                                         udp_push_pending_frames);
-       return ip_setsockopt(sk, level, optname, optval, optlen);
-}
-
-#ifdef CONFIG_COMPAT
-int compat_udp_setsockopt(struct sock *sk, int level, int optname,
-                         char __user *optval, int optlen)
-{
-       if (IS_SOL_UDPFAMILY(level))
-               return udp_lib_setsockopt(sk, level, optname, optval, optlen,
-                                         udp_push_pending_frames);
-       return compat_ip_setsockopt(sk, level, optname, optval, optlen);
-}
-#endif
-
 int udp_lib_getsockopt(struct sock *sk, int level, int optname,
                       char __user *optval, int __user *optlen)
 {
@@ -1417,23 +436,6 @@ int udp_lib_getsockopt(struct sock *sk, int level, int optname,
        return 0;
 }
 
-int udp_getsockopt(struct sock *sk, int level, int optname,
-                  char __user *optval, int __user *optlen)
-{
-       if (IS_SOL_UDPFAMILY(level))
-               return udp_lib_getsockopt(sk, level, optname, optval, optlen);
-       return ip_getsockopt(sk, level, optname, optval, optlen);
-}
-
-#ifdef CONFIG_COMPAT
-int compat_udp_getsockopt(struct sock *sk, int level, int optname,
-                                char __user *optval, int __user *optlen)
-{
-       if (IS_SOL_UDPFAMILY(level))
-               return udp_lib_getsockopt(sk, level, optname, optval, optlen);
-       return compat_ip_getsockopt(sk, level, optname, optval, optlen);
-}
-#endif
 /**
  *     udp_poll - wait for a UDP event.
  *     @file - file struct
@@ -1478,36 +480,6 @@ unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
 
 }
 
-DEFINE_PROTO_INUSE(udp)
-
-struct proto udp_prot = {
-       .name              = "UDP",
-       .owner             = THIS_MODULE,
-       .close             = udp_lib_close,
-       .connect           = ip4_datagram_connect,
-       .disconnect        = udp_disconnect,
-       .ioctl             = udp_ioctl,
-       .destroy           = udp_destroy_sock,
-       .setsockopt        = udp_setsockopt,
-       .getsockopt        = udp_getsockopt,
-       .sendmsg           = udp_sendmsg,
-       .recvmsg           = udp_recvmsg,
-       .sendpage          = udp_sendpage,
-       .backlog_rcv       = udp_queue_rcv_skb,
-       .hash              = udp_lib_hash,
-       .unhash            = udp_lib_unhash,
-       .get_port          = udp_v4_get_port,
-       .memory_allocated  = &udp_memory_allocated,
-       .sysctl_mem        = sysctl_udp_mem,
-       .sysctl_wmem       = &sysctl_udp_wmem_min,
-       .sysctl_rmem       = &sysctl_udp_rmem_min,
-       .obj_size          = sizeof(struct udp_sock),
-#ifdef CONFIG_COMPAT
-       .compat_setsockopt = compat_udp_setsockopt,
-       .compat_getsockopt = compat_udp_getsockopt,
-#endif
-       REF_PROTO_INUSE(udp)
-};
 
 /* ------------------------------------------------------------------------ */
 #ifdef CONFIG_PROC_FS
@@ -1640,62 +612,6 @@ void udp_proc_unregister(struct udp_seq_afinfo *afinfo)
        proc_net_remove(&init_net, afinfo->name);
        memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
 }
-
-/* ------------------------------------------------------------------------ */
-static void udp4_format_sock(struct sock *sp, char *tmpbuf, int bucket)
-{
-       struct inet_sock *inet = inet_sk(sp);
-       __be32 dest = inet->daddr;
-       __be32 src  = inet->rcv_saddr;
-       __u16 destp       = ntohs(inet->dport);
-       __u16 srcp        = ntohs(inet->sport);
-
-       sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
-               " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p",
-               bucket, src, srcp, dest, destp, sp->sk_state,
-               atomic_read(&sp->sk_wmem_alloc),
-               atomic_read(&sp->sk_rmem_alloc),
-               0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
-               atomic_read(&sp->sk_refcnt), sp);
-}
-
-int udp4_seq_show(struct seq_file *seq, void *v)
-{
-       if (v == SEQ_START_TOKEN)
-               seq_printf(seq, "%-127s\n",
-                          "  sl  local_address rem_address   st tx_queue "
-                          "rx_queue tr tm->when retrnsmt   uid  timeout "
-                          "inode");
-       else {
-               char tmpbuf[129];
-               struct udp_iter_state *state = seq->private;
-
-               udp4_format_sock(v, tmpbuf, state->bucket);
-               seq_printf(seq, "%-127s\n", tmpbuf);
-       }
-       return 0;
-}
-
-/* ------------------------------------------------------------------------ */
-static struct file_operations udp4_seq_fops;
-static struct udp_seq_afinfo udp4_seq_afinfo = {
-       .owner          = THIS_MODULE,
-       .name           = "udp",
-       .family         = AF_INET,
-       .hashtable      = udp_hash,
-       .seq_show       = udp4_seq_show,
-       .seq_fops       = &udp4_seq_fops,
-};
-
-int __init udp4_proc_init(void)
-{
-       return udp_proc_register(&udp4_seq_afinfo);
-}
-
-void udp4_proc_exit(void)
-{
-       udp_proc_unregister(&udp4_seq_afinfo);
-}
 #endif /* CONFIG_PROC_FS */
 
 void __init udp_init(void)
@@ -1722,8 +638,6 @@ EXPORT_SYMBOL(udp_hash);
 EXPORT_SYMBOL(udp_hash_lock);
 EXPORT_SYMBOL(udp_ioctl);
 EXPORT_SYMBOL(udp_get_port);
-EXPORT_SYMBOL(udp_prot);
-EXPORT_SYMBOL(udp_sendmsg);
 EXPORT_SYMBOL(udp_lib_getsockopt);
 EXPORT_SYMBOL(udp_lib_setsockopt);
 EXPORT_SYMBOL(udp_poll);
diff --git a/net/ipv4/udp_ipv4.c b/net/ipv4/udp_ipv4.c
new file mode 100644 (file)
index 0000000..40978de
--- /dev/null
@@ -0,0 +1,1134 @@
+/*
+ * INET                An implementation of the TCP/IP protocol suite for the LINUX
+ *             operating system.  INET is implemented using the  BSD Socket
+ *             interface as the means of communication with the user level.
+ *
+ *             UDP for IPv4.
+ *
+ *             For full credits, see net/ipv4/udp.c.
+ *
+ *             This program is free software; you can redistribute it and/or
+ *             modify it under the terms of the GNU General Public License
+ *             as published by the Free Software Foundation; either version
+ *             2 of the License, or (at your option) any later version.
+ */
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/ioctls.h>
+#include <linux/bootmem.h>
+#include <linux/types.h>
+#include <linux/fcntl.h>
+#include <linux/module.h>
+#include <linux/socket.h>
+#include <linux/sockios.h>
+#include <linux/igmp.h>
+#include <linux/in.h>
+#include <linux/errno.h>
+#include <linux/timer.h>
+#include <linux/mm.h>
+#include <linux/inet.h>
+#include <linux/netdevice.h>
+#include <net/tcp_states.h>
+#include <linux/skbuff.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <net/net_namespace.h>
+#include <net/icmp.h>
+#include <net/route.h>
+#include <net/checksum.h>
+#include <net/xfrm.h>
+#include "udp_impl.h"
+
+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);
+}
+
+/* UDP is nearly always wildcards out the wazoo, it makes no sense to try
+ * harder than this. -DaveM
+ */
+static struct sock *__udp4_lib_lookup(struct net *net, __be32 saddr,
+               __be16 sport, __be32 daddr, __be16 dport,
+               int dif, struct hlist_head udptable[])
+{
+       struct sock *sk, *result = NULL;
+       struct hlist_node *node;
+       unsigned short hnum = ntohs(dport);
+       int badness = -1;
+
+       read_lock(&udp_hash_lock);
+       sk_for_each(sk, node, &udptable[hnum & (UDP_HTABLE_SIZE - 1)]) {
+               struct inet_sock *inet = inet_sk(sk);
+
+               if (sk->sk_net == net && sk->sk_hash == hnum &&
+                               !ipv6_only_sock(sk)) {
+                       int score = (sk->sk_family == PF_INET ? 1 : 0);
+                       if (inet->rcv_saddr) {
+                               if (inet->rcv_saddr != daddr)
+                                       continue;
+                               score+=2;
+                       }
+                       if (inet->daddr) {
+                               if (inet->daddr != saddr)
+                                       continue;
+                               score+=2;
+                       }
+                       if (inet->dport) {
+                               if (inet->dport != sport)
+                                       continue;
+                               score+=2;
+                       }
+                       if (sk->sk_bound_dev_if) {
+                               if (sk->sk_bound_dev_if != dif)
+                                       continue;
+                               score+=2;
+                       }
+                       if (score == 9) {
+                               result = sk;
+                               break;
+                       } else if (score > badness) {
+                               result = sk;
+                               badness = score;
+                       }
+               }
+       }
+       if (result)
+               sock_hold(result);
+       read_unlock(&udp_hash_lock);
+       return result;
+}
+
+static inline struct sock *udp_v4_mcast_next(struct sock *sk,
+                                            __be16 loc_port, __be32 loc_addr,
+                                            __be16 rmt_port, __be32 rmt_addr,
+                                            int dif)
+{
+       struct hlist_node *node;
+       struct sock *s = sk;
+       unsigned short hnum = ntohs(loc_port);
+
+       sk_for_each_from(s, node) {
+               struct inet_sock *inet = inet_sk(s);
+
+               if (s->sk_hash != hnum                                  ||
+                   (inet->daddr && inet->daddr != rmt_addr)            ||
+                   (inet->dport != rmt_port && inet->dport)            ||
+                   (inet->rcv_saddr && inet->rcv_saddr != loc_addr)    ||
+                   ipv6_only_sock(s)                                   ||
+                   (s->sk_bound_dev_if && s->sk_bound_dev_if != dif))
+                       continue;
+               if (!ip_mc_sf_allow(s, loc_addr, rmt_addr, dif))
+                       continue;
+               goto found;
+       }
+       s = NULL;
+found:
+       return s;
+}
+
+/*
+ * This routine is called by the ICMP module when it gets some
+ * sort of error condition.  If err < 0 then the socket should
+ * be closed and the error returned to the user.  If err > 0
+ * it's just the icmp type << 8 | icmp code.
+ * Header points to the ip header of the error packet. We move
+ * on past this. Then (as it used to claim before adjustment)
+ * header points to the first 8 bytes of the udp header.  We need
+ * to find the appropriate port.
+ */
+
+void __udp4_lib_err(struct sk_buff *skb, u32 info, struct hlist_head udptable[])
+{
+       struct inet_sock *inet;
+       struct iphdr *iph = (struct iphdr*)skb->data;
+       struct udphdr *uh = (struct udphdr*)(skb->data+(iph->ihl<<2));
+       const int type = icmp_hdr(skb)->type;
+       const int code = icmp_hdr(skb)->code;
+       struct sock *sk;
+       int harderr;
+       int err;
+
+       sk = __udp4_lib_lookup(skb->dev->nd_net, iph->daddr, uh->dest,
+                       iph->saddr, uh->source, skb->dev->ifindex, udptable);
+       if (sk == NULL) {
+               ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
+               return; /* No socket for error */
+       }
+
+       err = 0;
+       harderr = 0;
+       inet = inet_sk(sk);
+
+       switch (type) {
+       default:
+       case ICMP_TIME_EXCEEDED:
+               err = EHOSTUNREACH;
+               break;
+       case ICMP_SOURCE_QUENCH:
+               goto out;
+       case ICMP_PARAMETERPROB:
+               err = EPROTO;
+               harderr = 1;
+               break;
+       case ICMP_DEST_UNREACH:
+               if (code == ICMP_FRAG_NEEDED) { /* Path MTU discovery */
+                       if (inet->pmtudisc != IP_PMTUDISC_DONT) {
+                               err = EMSGSIZE;
+                               harderr = 1;
+                               break;
+                       }
+                       goto out;
+               }
+               err = EHOSTUNREACH;
+               if (code <= NR_ICMP_UNREACH) {
+                       harderr = icmp_err_convert[code].fatal;
+                       err = icmp_err_convert[code].errno;
+               }
+               break;
+       }
+
+       /*
+        *      RFC1122: OK.  Passes ICMP errors back to application, as per
+        *      4.1.3.3.
+        */
+       if (!inet->recverr) {
+               if (!harderr || sk->sk_state != TCP_ESTABLISHED)
+                       goto out;
+       } else {
+               ip_icmp_error(sk, skb, err, uh->dest, info, (u8*)(uh+1));
+       }
+       sk->sk_err = err;
+       sk->sk_error_report(sk);
+out:
+       sock_put(sk);
+}
+
+void udp_err(struct sk_buff *skb, u32 info)
+{
+       __udp4_lib_err(skb, info, udp_hash);
+}
+
+/*
+ * Throw away all pending data and cancel the corking. Socket is locked.
+ */
+static void udp_flush_pending_frames(struct sock *sk)
+{
+       struct udp_sock *up = udp_sk(sk);
+
+       if (up->pending) {
+               up->len = 0;
+               up->pending = 0;
+               ip_flush_pending_frames(sk);
+       }
+}
+
+/**
+ *     udp4_hwcsum_outgoing  -  handle outgoing HW checksumming
+ *     @sk:    socket we are sending on
+ *     @skb:   sk_buff containing the filled-in UDP header
+ *             (checksum field must be zeroed out)
+ */
+static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
+                                __be32 src, __be32 dst, int len      )
+{
+       unsigned int offset;
+       struct udphdr *uh = udp_hdr(skb);
+       __wsum csum = 0;
+
+       if (skb_queue_len(&sk->sk_write_queue) == 1) {
+               /*
+                * Only one fragment on the socket.
+                */
+               skb->csum_start = skb_transport_header(skb) - skb->head;
+               skb->csum_offset = offsetof(struct udphdr, check);
+               uh->check = ~csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, 0);
+       } else {
+               /*
+                * HW-checksum won't work as there are two or more
+                * fragments on the socket so that all csums of sk_buffs
+                * should be together
+                */
+               offset = skb_transport_offset(skb);
+               skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
+
+               skb->ip_summed = CHECKSUM_NONE;
+
+               skb_queue_walk(&sk->sk_write_queue, skb) {
+                       csum = csum_add(csum, skb->csum);
+               }
+
+               uh->check = csum_tcpudp_magic(src, dst, len, IPPROTO_UDP, csum);
+               if (uh->check == 0)
+                       uh->check = CSUM_MANGLED_0;
+       }
+}
+
+/*
+ * Push out all pending data as one UDP datagram. Socket is locked.
+ */
+static int udp_push_pending_frames(struct sock *sk)
+{
+       struct udp_sock  *up = udp_sk(sk);
+       struct inet_sock *inet = inet_sk(sk);
+       struct flowi *fl = &inet->cork.fl;
+       struct sk_buff *skb;
+       struct udphdr *uh;
+       int err = 0;
+       int is_udplite = IS_UDPLITE(sk);
+       __wsum csum = 0;
+
+       /* Grab the skbuff where UDP header space exists. */
+       if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
+               goto out;
+
+       /*
+        * Create a UDP header
+        */
+       uh = udp_hdr(skb);
+       uh->source = fl->fl_ip_sport;
+       uh->dest = fl->fl_ip_dport;
+       uh->len = htons(up->len);
+       uh->check = 0;
+
+       if (is_udplite)                                  /*     UDP-Lite      */
+               csum  = udplite_csum_outgoing(sk, skb);
+
+       else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {   /* UDP csum disabled */
+
+               skb->ip_summed = CHECKSUM_NONE;
+               goto send;
+
+       } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
+
+               udp4_hwcsum_outgoing(sk, skb, fl->fl4_src,fl->fl4_dst, up->len);
+               goto send;
+
+       } else                                           /*   `normal' UDP    */
+               csum = udp_csum_outgoing(sk, skb);
+
+       /* add protocol-dependent pseudo-header */
+       uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
+                                     sk->sk_protocol, csum             );
+       if (uh->check == 0)
+               uh->check = CSUM_MANGLED_0;
+
+send:
+       err = ip_push_pending_frames(sk);
+out:
+       up->len = 0;
+       up->pending = 0;
+       if (!err)
+               UDP_INC_STATS_USER(UDP_MIB_OUTDATAGRAMS, is_udplite);
+       return err;
+}
+
+int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
+               size_t len)
+{
+       struct inet_sock *inet = inet_sk(sk);
+       struct udp_sock *up = udp_sk(sk);
+       int ulen = len;
+       struct ipcm_cookie ipc;
+       struct rtable *rt = NULL;
+       int free = 0;
+       int connected = 0;
+       __be32 daddr, faddr, saddr;
+       __be16 dport;
+       u8  tos;
+       int err, is_udplite = IS_UDPLITE(sk);
+       int corkreq = up->corkflag || msg->msg_flags&MSG_MORE;
+       int (*getfrag)(void *, char *, int, int, int, struct sk_buff *);
+
+       if (len > 0xFFFF)
+               return -EMSGSIZE;
+
+       /*
+        *      Check the flags.
+        */
+
+       if (msg->msg_flags&MSG_OOB)     /* Mirror BSD error message compatibility */
+               return -EOPNOTSUPP;
+
+       ipc.opt = NULL;
+
+       if (up->pending) {
+               /*
+                * There are pending frames.
+                * The socket lock must be held while it's corked.
+                */
+               lock_sock(sk);
+               if (likely(up->pending)) {
+                       if (unlikely(up->pending != AF_INET)) {
+                               release_sock(sk);
+                               return -EINVAL;
+                       }
+                       goto do_append_data;
+               }
+               release_sock(sk);
+       }
+       ulen += sizeof(struct udphdr);
+
+       /*
+        *      Get and verify the address.
+        */
+       if (msg->msg_name) {
+               struct sockaddr_in * usin = (struct sockaddr_in*)msg->msg_name;
+               if (msg->msg_namelen < sizeof(*usin))
+                       return -EINVAL;
+               if (usin->sin_family != AF_INET) {
+                       if (usin->sin_family != AF_UNSPEC)
+                               return -EAFNOSUPPORT;
+               }
+
+               daddr = usin->sin_addr.s_addr;
+               dport = usin->sin_port;
+               if (dport == 0)
+                       return -EINVAL;
+       } else {
+               if (sk->sk_state != TCP_ESTABLISHED)
+                       return -EDESTADDRREQ;
+               daddr = inet->daddr;
+               dport = inet->dport;
+               /* Open fast path for connected socket.
+                  Route will not be used, if at least one option is set.
+                */
+               connected = 1;
+       }
+       ipc.addr = inet->saddr;
+
+       ipc.oif = sk->sk_bound_dev_if;
+       if (msg->msg_controllen) {
+               err = ip_cmsg_send(msg, &ipc);
+               if (err)
+                       return err;
+               if (ipc.opt)
+                       free = 1;
+               connected = 0;
+       }
+       if (!ipc.opt)
+               ipc.opt = inet->opt;
+
+       saddr = ipc.addr;
+       ipc.addr = faddr = daddr;
+
+       if (ipc.opt && ipc.opt->srr) {
+               if (!daddr)
+                       return -EINVAL;
+               faddr = ipc.opt->faddr;
+               connected = 0;
+       }
+       tos = RT_TOS(inet->tos);
+       if (sock_flag(sk, SOCK_LOCALROUTE) ||
+           (msg->msg_flags & MSG_DONTROUTE) ||
+           (ipc.opt && ipc.opt->is_strictroute)) {
+               tos |= RTO_ONLINK;
+               connected = 0;
+       }
+
+       if (ipv4_is_multicast(daddr)) {
+               if (!ipc.oif)
+                       ipc.oif = inet->mc_index;
+               if (!saddr)
+                       saddr = inet->mc_addr;
+               connected = 0;
+       }
+
+       if (connected)
+               rt = (struct rtable*)sk_dst_check(sk, 0);
+
+       if (rt == NULL) {
+               struct flowi fl = { .oif = ipc.oif,
+                                   .nl_u = { .ip4_u =
+                                             { .daddr = faddr,
+                                               .saddr = saddr,
+                                               .tos = tos } },
+                                   .proto = sk->sk_protocol,
+                                   .uli_u = { .ports =
+                                              { .sport = inet->sport,
+                                                .dport = dport } } };
+               security_sk_classify_flow(sk, &fl);
+               err = ip_route_output_flow(&init_net, &rt, &fl, sk, 1);
+               if (err) {
+                       if (err == -ENETUNREACH)
+                               IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
+                       goto out;
+               }
+
+               err = -EACCES;
+               if ((rt->rt_flags & RTCF_BROADCAST) &&
+                   !sock_flag(sk, SOCK_BROADCAST))
+                       goto out;
+               if (connected)
+                       sk_dst_set(sk, dst_clone(&rt->u.dst));
+       }
+
+       if (msg->msg_flags&MSG_CONFIRM)
+               goto do_confirm;
+back_from_confirm:
+
+       saddr = rt->rt_src;
+       if (!ipc.addr)
+               daddr = ipc.addr = rt->rt_dst;
+
+       lock_sock(sk);
+       if (unlikely(up->pending)) {
+               /* The socket is already corked while preparing it. */
+               /* ... which is an evident application bug. --ANK */
+               release_sock(sk);
+
+               LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 2\n");
+               err = -EINVAL;
+               goto out;
+       }
+       /*
+        *      Now cork the socket to pend data.
+        */
+       inet->cork.fl.fl4_dst = daddr;
+       inet->cork.fl.fl_ip_dport = dport;
+       inet->cork.fl.fl4_src = saddr;
+       inet->cork.fl.fl_ip_sport = inet->sport;
+       up->pending = AF_INET;
+
+do_append_data:
+       up->len += ulen;
+       getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
+       err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,
+                       sizeof(struct udphdr), &ipc, rt,
+                       corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);
+       if (err)
+               udp_flush_pending_frames(sk);
+       else if (!corkreq)
+               err = udp_push_pending_frames(sk);
+       else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
+               up->pending = 0;
+       release_sock(sk);
+
+out:
+       ip_rt_put(rt);
+       if (free)
+               kfree(ipc.opt);
+       if (!err)
+               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, is_udplite);
+       }
+       return err;
+
+do_confirm:
+       dst_confirm(&rt->u.dst);
+       if (!(msg->msg_flags&MSG_PROBE) || len)
+               goto back_from_confirm;
+       err = 0;
+       goto out;
+}
+
+int udp_sendpage(struct sock *sk, struct page *page, int offset,
+                size_t size, int flags)
+{
+       struct udp_sock *up = udp_sk(sk);
+       int ret;
+
+       if (!up->pending) {
+               struct msghdr msg = {   .msg_flags = flags|MSG_MORE };
+
+               /* Call udp_sendmsg to specify destination address which
+                * sendpage interface can't pass.
+                * This will succeed only when the socket is connected.
+                */
+               ret = udp_sendmsg(NULL, sk, &msg, 0);
+               if (ret < 0)
+                       return ret;
+       }
+
+       lock_sock(sk);
+
+       if (unlikely(!up->pending)) {
+               release_sock(sk);
+
+               LIMIT_NETDEBUG(KERN_DEBUG "udp cork app bug 3\n");
+               return -EINVAL;
+       }
+
+       ret = ip_append_page(sk, page, offset, size, flags);
+       if (ret == -EOPNOTSUPP) {
+               release_sock(sk);
+               return sock_no_sendpage(sk->sk_socket, page, offset,
+                                       size, flags);
+       }
+       if (ret < 0) {
+               udp_flush_pending_frames(sk);
+               goto out;
+       }
+
+       up->len += size;
+       if (!(up->corkflag || (flags&MSG_MORE)))
+               ret = udp_push_pending_frames(sk);
+       if (!ret)
+               ret = size;
+out:
+       release_sock(sk);
+       return ret;
+}
+
+/*
+ *     This should be easy, if there is something there we
+ *     return it, otherwise we block.
+ */
+
+int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
+               size_t len, int noblock, int flags, int *addr_len)
+{
+       struct inet_sock *inet = inet_sk(sk);
+       struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
+       struct sk_buff *skb;
+       unsigned int ulen, copied;
+       int peeked;
+       int err;
+       int is_udplite = IS_UDPLITE(sk);
+
+       /*
+        *      Check any passed addresses
+        */
+       if (addr_len)
+               *addr_len=sizeof(*sin);
+
+       if (flags & MSG_ERRQUEUE)
+               return ip_recv_error(sk, msg, len);
+
+try_again:
+       skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
+                                 &peeked, &err);
+       if (!skb)
+               goto out;
+
+       ulen = skb->len - sizeof(struct udphdr);
+       copied = len;
+       if (copied > ulen)
+               copied = ulen;
+       else if (copied < ulen)
+               msg->msg_flags |= MSG_TRUNC;
+
+       /*
+        * If checksum is needed at all, try to do it while copying the
+        * data.  If the data is truncated, or if we only want a partial
+        * coverage checksum (UDP-Lite), do it before the copy.
+        */
+
+       if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
+               if (udp_lib_checksum_complete(skb))
+                       goto csum_copy_err;
+       }
+
+       if (skb_csum_unnecessary(skb))
+               err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
+                                             msg->msg_iov, copied       );
+       else {
+               err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
+
+               if (err == -EINVAL)
+                       goto csum_copy_err;
+       }
+
+       if (err)
+               goto out_free;
+
+       if (!peeked)
+               UDP_INC_STATS_USER(UDP_MIB_INDATAGRAMS, is_udplite);
+
+       sock_recv_timestamp(msg, sk, skb);
+
+       /* Copy the address. */
+       if (sin)
+       {
+               sin->sin_family = AF_INET;
+               sin->sin_port = udp_hdr(skb)->source;
+               sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
+               memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
+       }
+       if (inet->cmsg_flags)
+               ip_cmsg_recv(msg, skb);
+
+       err = copied;
+       if (flags & MSG_TRUNC)
+               err = ulen;
+
+out_free:
+       lock_sock(sk);
+       skb_free_datagram(sk, skb);
+       release_sock(sk);
+out:
+       return err;
+
+csum_copy_err:
+       lock_sock(sk);
+       if (!skb_kill_datagram(sk, skb, flags))
+               UDP_INC_STATS_USER(UDP_MIB_INERRORS, is_udplite);
+       release_sock(sk);
+
+       if (noblock)
+               return -EAGAIN;
+       goto try_again;
+}
+
+
+/* returns:
+ *  -1: error
+ *   0: success
+ *  >0: "udp encap" protocol resubmission
+ *
+ * Note that in the success and error cases, the skb is assumed to
+ * have either been requeued or freed.
+ */
+int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
+{
+       struct udp_sock *up = udp_sk(sk);
+       int rc;
+       int is_udplite = IS_UDPLITE(sk);
+
+       /*
+        *      Charge it to the socket, dropping if the queue is full.
+        */
+       if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
+               goto drop;
+       nf_reset(skb);
+
+       if (up->encap_type) {
+               /*
+                * This is an encapsulation socket so pass the skb to
+                * the socket's udp_encap_rcv() hook. Otherwise, just
+                * fall through and pass this up the UDP socket.
+                * up->encap_rcv() returns the following value:
+                * =0 if skb was successfully passed to the encap
+                *    handler or was discarded by it.
+                * >0 if skb should be passed on to UDP.
+                * <0 if skb should be resubmitted as proto -N
+                */
+
+               /* if we're overly short, let UDP handle it */
+               if (skb->len > sizeof(struct udphdr) &&
+                   up->encap_rcv != NULL) {
+                       int ret;
+
+                       ret = (*up->encap_rcv)(sk, skb);
+                       if (ret <= 0) {
+                               UDP_INC_STATS_BH(UDP_MIB_INDATAGRAMS,
+                                                is_udplite);
+                               return -ret;
+                       }
+               }
+
+               /* FALLTHROUGH -- it's a UDP Packet */
+       }
+
+       /*
+        *      UDP-Lite specific tests, ignored on UDP sockets
+        */
+       if ((is_udplite & UDPLITE_RECV_CC)  &&  UDP_SKB_CB(skb)->partial_cov) {
+
+               /*
+                * MIB statistics other than incrementing the error count are
+                * disabled for the following two types of errors: these depend
+                * on the application settings, not on the functioning of the
+                * protocol stack as such.
+                *
+                * RFC 3828 here recommends (sec 3.3): "There should also be a
+                * way ... to ... at least let the receiving application block
+                * delivery of packets with coverage values less than a value
+                * provided by the application."
+                */
+               if (up->pcrlen == 0) {          /* full coverage was set  */
+                       LIMIT_NETDEBUG(KERN_WARNING "UDPLITE: partial coverage "
+                               "%d while full coverage %d requested\n",
+                               UDP_SKB_CB(skb)->cscov, skb->len);
+                       goto drop;
+               }
+               /* The next case involves violating the min. coverage requested
+                * by the receiver. This is subtle: if receiver wants x and x is
+                * greater than the buffersize/MTU then receiver will complain
+                * that it wants x while sender emits packets of smaller size y.
+                * Therefore the above ...()->partial_cov statement is essential.
+                */
+               if (UDP_SKB_CB(skb)->cscov  <  up->pcrlen) {
+                       LIMIT_NETDEBUG(KERN_WARNING
+                               "UDPLITE: coverage %d too small, need min %d\n",
+                               UDP_SKB_CB(skb)->cscov, up->pcrlen);
+                       goto drop;
+               }
+       }
+
+       if (sk->sk_filter) {
+               if (udp_lib_checksum_complete(skb))
+                       goto drop;
+       }
+
+       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, is_udplite);
+               goto drop;
+       }
+
+       return 0;
+
+drop:
+       UDP_INC_STATS_BH(UDP_MIB_INERRORS, is_udplite);
+       kfree_skb(skb);
+       return -1;
+}
+
+/*
+ *     Multicasts and broadcasts go to each listener.
+ *
+ *     Note: called only from the BH handler context,
+ *     so we don't need to lock the hashes.
+ */
+static int __udp4_lib_mcast_deliver(struct sk_buff *skb,
+                                   struct udphdr  *uh,
+                                   __be32 saddr, __be32 daddr,
+                                   struct hlist_head udptable[])
+{
+       struct sock *sk;
+       int dif;
+
+       read_lock(&udp_hash_lock);
+       sk = sk_head(&udptable[ntohs(uh->dest) & (UDP_HTABLE_SIZE - 1)]);
+       dif = skb->dev->ifindex;
+       sk = udp_v4_mcast_next(sk, uh->dest, daddr, uh->source, saddr, dif);
+       if (sk) {
+               struct sock *sknext = NULL;
+
+               do {
+                       struct sk_buff *skb1 = skb;
+
+                       sknext = udp_v4_mcast_next(sk_next(sk), uh->dest, daddr,
+                                                  uh->source, saddr, dif);
+                       if (sknext)
+                               skb1 = skb_clone(skb, GFP_ATOMIC);
+
+                       if (skb1) {
+                               int ret = 0;
+
+                               bh_lock_sock_nested(sk);
+                               if (!sock_owned_by_user(sk))
+                                       ret = udp_queue_rcv_skb(sk, skb1);
+                               else
+                                       sk_add_backlog(sk, skb1);
+                               bh_unlock_sock(sk);
+
+                               if (ret > 0)
+                                       /* we should probably re-process instead
+                                        * of dropping packets here. */
+                                       kfree_skb(skb1);
+                       }
+                       sk = sknext;
+               } while (sknext);
+       } else
+               kfree_skb(skb);
+       read_unlock(&udp_hash_lock);
+       return 0;
+}
+
+/* Initialize UDP checksum. If exited with zero value (success),
+ * CHECKSUM_UNNECESSARY means, that no more checks are required.
+ * Otherwise, csum completion requires chacksumming packet body,
+ * including udp header and folding it to skb->csum.
+ */
+static inline int udp4_csum_init(struct sk_buff *skb, struct udphdr *uh,
+                                int proto)
+{
+       const struct iphdr *iph;
+       int err;
+
+       UDP_SKB_CB(skb)->partial_cov = 0;
+       UDP_SKB_CB(skb)->cscov = skb->len;
+
+       if (IS_PROTO_UDPLITE(proto)) {
+               err = udplite_checksum_init(skb, uh);
+               if (err)
+                       return err;
+       }
+
+       iph = ip_hdr(skb);
+       if (uh->check == 0) {
+               skb->ip_summed = CHECKSUM_UNNECESSARY;
+       } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
+              if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
+                                     proto, skb->csum))
+                       skb->ip_summed = CHECKSUM_UNNECESSARY;
+       }
+       if (!skb_csum_unnecessary(skb))
+               skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
+                                              skb->len, proto, 0);
+       /* Probably, we should checksum udp header (it should be in cache
+        * in any case) and data in tiny packets (< rx copybreak).
+        */
+
+       return 0;
+}
+
+/*
+ *     All we need to do is get the socket, and then do a checksum.
+ */
+
+int __udp4_lib_rcv(struct sk_buff *skb, struct hlist_head udptable[],
+                  int proto)
+{
+       struct sock *sk;
+       struct udphdr *uh = udp_hdr(skb);
+       unsigned short ulen;
+       struct rtable *rt = (struct rtable*)skb->dst;
+       __be32 saddr = ip_hdr(skb)->saddr;
+       __be32 daddr = ip_hdr(skb)->daddr;
+
+       /*
+        *  Validate the packet.
+        */
+       if (!pskb_may_pull(skb, sizeof(struct udphdr)))
+               goto drop;              /* No space for header. */
+
+       ulen = ntohs(uh->len);
+       if (ulen > skb->len)
+               goto short_packet;
+
+       if (IS_PROTO_UDPLITE(proto)) {
+               /* UDP validates ulen. */
+               if (ulen < sizeof(*uh) || pskb_trim_rcsum(skb, ulen))
+                       goto short_packet;
+               uh = udp_hdr(skb);
+       }
+
+       if (udp4_csum_init(skb, uh, proto))
+               goto csum_error;
+
+       if (rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST))
+               return __udp4_lib_mcast_deliver(skb, uh, saddr, daddr, udptable);
+
+       sk = __udp4_lib_lookup(skb->dev->nd_net, saddr, uh->source, daddr,
+                       uh->dest, inet_iif(skb), udptable);
+
+       if (sk != NULL) {
+               int ret = 0;
+               bh_lock_sock_nested(sk);
+               if (!sock_owned_by_user(sk))
+                       ret = udp_queue_rcv_skb(sk, skb);
+               else
+                       sk_add_backlog(sk, skb);
+               bh_unlock_sock(sk);
+               sock_put(sk);
+
+               /* a return value > 0 means to resubmit the input, but
+                * it wants the return to be -protocol, or 0
+                */
+               if (ret > 0)
+                       return -ret;
+               return 0;
+       }
+
+       if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
+               goto drop;
+       nf_reset(skb);
+
+       /* No socket. Drop packet silently, if checksum is wrong */
+       if (udp_lib_checksum_complete(skb))
+               goto csum_error;
+
+       UDP_INC_STATS_BH(UDP_MIB_NOPORTS, IS_PROTO_UDPLITE(proto));
+       icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
+
+       /*
+        * Hmm.  We got an UDP packet to a port to which we
+        * don't wanna listen.  Ignore it.
+        */
+       kfree_skb(skb);
+       return 0;
+
+short_packet:
+       LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: short packet: From %u.%u.%u.%u:%u %d/%d to %u.%u.%u.%u:%u\n",
+                      IS_PROTO_UDPLITE(proto) ? "-Lite" : "",
+                      NIPQUAD(saddr),
+                      ntohs(uh->source),
+                      ulen,
+                      skb->len,
+                      NIPQUAD(daddr),
+                      ntohs(uh->dest));
+       goto drop;
+
+csum_error:
+       /*
+        * RFC1122: OK.  Discards the bad packet silently (as far as
+        * the network is concerned, anyway) as per 4.1.3.4 (MUST).
+        */
+       LIMIT_NETDEBUG(KERN_DEBUG "UDP%s: bad checksum. From %d.%d.%d.%d:%d to %d.%d.%d.%d:%d ulen %d\n",
+                      IS_PROTO_UDPLITE(proto) ? "-Lite" : "",
+                      NIPQUAD(saddr),
+                      ntohs(uh->source),
+                      NIPQUAD(daddr),
+                      ntohs(uh->dest),
+                      ulen);
+drop:
+       UDP_INC_STATS_BH(UDP_MIB_INERRORS, IS_PROTO_UDPLITE(proto));
+       kfree_skb(skb);
+       return 0;
+}
+
+int udp_rcv(struct sk_buff *skb)
+{
+       return __udp4_lib_rcv(skb, udp_hash, IPPROTO_UDP);
+}
+
+int udp_destroy_sock(struct sock *sk)
+{
+       lock_sock(sk);
+       udp_flush_pending_frames(sk);
+       release_sock(sk);
+       return 0;
+}
+
+int udp_setsockopt(struct sock *sk, int level, int optname,
+                  char __user *optval, int optlen)
+{
+       if (IS_SOL_UDPFAMILY(level))
+               return udp_lib_setsockopt(sk, level, optname, optval, optlen,
+                                         udp_push_pending_frames);
+       return ip_setsockopt(sk, level, optname, optval, optlen);
+}
+
+#ifdef CONFIG_COMPAT
+int compat_udp_setsockopt(struct sock *sk, int level, int optname,
+                         char __user *optval, int optlen)
+{
+       if (IS_SOL_UDPFAMILY(level))
+               return udp_lib_setsockopt(sk, level, optname, optval, optlen,
+                                         udp_push_pending_frames);
+       return compat_ip_setsockopt(sk, level, optname, optval, optlen);
+}
+#endif
+
+int udp_getsockopt(struct sock *sk, int level, int optname,
+                  char __user *optval, int __user *optlen)
+{
+       if (IS_SOL_UDPFAMILY(level))
+               return udp_lib_getsockopt(sk, level, optname, optval, optlen);
+       return ip_getsockopt(sk, level, optname, optval, optlen);
+}
+
+#ifdef CONFIG_COMPAT
+int compat_udp_getsockopt(struct sock *sk, int level, int optname,
+                         char __user *optval, int __user *optlen)
+{
+       if (IS_SOL_UDPFAMILY(level))
+               return udp_lib_getsockopt(sk, level, optname, optval, optlen);
+       return compat_ip_getsockopt(sk, level, optname, optval, optlen);
+}
+#endif
+
+/* ------------------------------------------------------------------------ */
+DEFINE_PROTO_INUSE(udp)
+
+struct proto udp_prot = {
+       .name              = "UDP",
+       .owner             = THIS_MODULE,
+       .close             = udp_lib_close,
+       .connect           = ip4_datagram_connect,
+       .disconnect        = udp_disconnect,
+       .ioctl             = udp_ioctl,
+       .destroy           = udp_destroy_sock,
+       .setsockopt        = udp_setsockopt,
+       .getsockopt        = udp_getsockopt,
+       .sendmsg           = udp_sendmsg,
+       .recvmsg           = udp_recvmsg,
+       .sendpage          = udp_sendpage,
+       .backlog_rcv       = udp_queue_rcv_skb,
+       .hash              = udp_lib_hash,
+       .unhash            = udp_lib_unhash,
+       .get_port          = udp_v4_get_port,
+       .memory_allocated  = &udp_memory_allocated,
+       .sysctl_mem        = sysctl_udp_mem,
+       .sysctl_wmem       = &sysctl_udp_wmem_min,
+       .sysctl_rmem       = &sysctl_udp_rmem_min,
+       .obj_size          = sizeof(struct udp_sock),
+#ifdef CONFIG_COMPAT
+       .compat_setsockopt = compat_udp_setsockopt,
+       .compat_getsockopt = compat_udp_getsockopt,
+#endif
+       REF_PROTO_INUSE(udp)
+};
+
+/* ------------------------------------------------------------------------ */
+static void udp4_format_sock(struct sock *sp, char *tmpbuf, int bucket)
+{
+       struct inet_sock *inet = inet_sk(sp);
+       __be32 dest = inet->daddr;
+       __be32 src  = inet->rcv_saddr;
+       __u16 destp       = ntohs(inet->dport);
+       __u16 srcp        = ntohs(inet->sport);
+
+       sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
+               " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p",
+               bucket, src, srcp, dest, destp, sp->sk_state,
+               atomic_read(&sp->sk_wmem_alloc),
+               atomic_read(&sp->sk_rmem_alloc),
+               0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
+               atomic_read(&sp->sk_refcnt), sp);
+}
+
+int udp4_seq_show(struct seq_file *seq, void *v)
+{
+       if (v == SEQ_START_TOKEN)
+               seq_printf(seq, "%-127s\n",
+                          "  sl  local_address rem_address   st tx_queue "
+                          "rx_queue tr tm->when retrnsmt   uid  timeout "
+                          "inode");
+       else {
+               char tmpbuf[129];
+               struct udp_iter_state *state = seq->private;
+
+               udp4_format_sock(v, tmpbuf, state->bucket);
+               seq_printf(seq, "%-127s\n", tmpbuf);
+       }
+       return 0;
+}
+
+/* ------------------------------------------------------------------------ */
+#ifdef CONFIG_PROC_FS
+static struct file_operations udp4_seq_fops;
+static struct udp_seq_afinfo udp4_seq_afinfo = {
+       .owner          = THIS_MODULE,
+       .name           = "udp",
+       .family         = AF_INET,
+       .hashtable      = udp_hash,
+       .seq_show       = udp4_seq_show,
+       .seq_fops       = &udp4_seq_fops,
+};
+
+int __init udp4_proc_init(void)
+{
+       return udp_proc_register(&udp4_seq_afinfo);
+}
+
+void udp4_proc_exit(void)
+{
+       udp_proc_unregister(&udp4_seq_afinfo);
+}
+#endif /* CONFIG_PROC_FS */
+
+EXPORT_SYMBOL(udp_prot);
+EXPORT_SYMBOL(udp_sendmsg);
+
diff --git a/net/ipv4/udplite.c b/net/ipv4/udplite.c
deleted file mode 100644 (file)
index 001b881..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- *  UDPLITE     An implementation of the UDP-Lite protocol (RFC 3828).
- *
- *  Version:    $Id: udplite.c,v 1.25 2006/10/19 07:22:36 gerrit Exp $
- *
- *  Authors:    Gerrit Renker       <gerrit@erg.abdn.ac.uk>
- *
- *  Changes:
- *  Fixes:
- *             This program is free software; you can redistribute it and/or
- *             modify it under the terms of the GNU General Public License
- *             as published by the Free Software Foundation; either version
- *             2 of the License, or (at your option) any later version.
- */
-#include "udp_impl.h"
-DEFINE_SNMP_STAT(struct udp_mib, udplite_statistics)   __read_mostly;
-
-struct hlist_head      udplite_hash[UDP_HTABLE_SIZE];
-
-int udplite_get_port(struct sock *sk, unsigned short p,
-                    int (*c)(const struct sock *, const struct sock *))
-{
-       return  __udp_lib_get_port(sk, p, udplite_hash, c);
-}
-
-static int udplite_v4_get_port(struct sock *sk, unsigned short snum)
-{
-       return udplite_get_port(sk, snum, ipv4_rcv_saddr_equal);
-}
-
-static int udplite_rcv(struct sk_buff *skb)
-{
-       return __udp4_lib_rcv(skb, udplite_hash, IPPROTO_UDPLITE);
-}
-
-static void udplite_err(struct sk_buff *skb, u32 info)
-{
-       __udp4_lib_err(skb, info, udplite_hash);
-}
-
-static struct net_protocol udplite_protocol = {
-       .handler        = udplite_rcv,
-       .err_handler    = udplite_err,
-       .no_policy      = 1,
-};
-
-DEFINE_PROTO_INUSE(udplite)
-
-struct proto   udplite_prot = {
-       .name              = "UDP-Lite",
-       .owner             = THIS_MODULE,
-       .close             = udp_lib_close,
-       .connect           = ip4_datagram_connect,
-       .disconnect        = udp_disconnect,
-       .ioctl             = udp_ioctl,
-       .init              = udplite_sk_init,
-       .destroy           = udp_destroy_sock,
-       .setsockopt        = udp_setsockopt,
-       .getsockopt        = udp_getsockopt,
-       .sendmsg           = udp_sendmsg,
-       .recvmsg           = udp_recvmsg,
-       .sendpage          = udp_sendpage,
-       .backlog_rcv       = udp_queue_rcv_skb,
-       .hash              = udp_lib_hash,
-       .unhash            = udp_lib_unhash,
-       .get_port          = udplite_v4_get_port,
-       .obj_size          = sizeof(struct udp_sock),
-#ifdef CONFIG_COMPAT
-       .compat_setsockopt = compat_udp_setsockopt,
-       .compat_getsockopt = compat_udp_getsockopt,
-#endif
-       REF_PROTO_INUSE(udplite)
-};
-
-static struct inet_protosw udplite4_protosw = {
-       .type           =  SOCK_DGRAM,
-       .protocol       =  IPPROTO_UDPLITE,
-       .prot           =  &udplite_prot,
-       .ops            =  &inet_dgram_ops,
-       .capability     = -1,
-       .no_check       =  0,           /* must checksum (RFC 3828) */
-       .flags          =  INET_PROTOSW_PERMANENT,
-};
-
-#ifdef CONFIG_PROC_FS
-static struct file_operations udplite4_seq_fops;
-static struct udp_seq_afinfo udplite4_seq_afinfo = {
-       .owner          = THIS_MODULE,
-       .name           = "udplite",
-       .family         = AF_INET,
-       .hashtable      = udplite_hash,
-       .seq_show       = udp4_seq_show,
-       .seq_fops       = &udplite4_seq_fops,
-};
-#endif
-
-void __init udplite4_register(void)
-{
-       if (proto_register(&udplite_prot, 1))
-               goto out_register_err;
-
-       if (inet_add_protocol(&udplite_protocol, IPPROTO_UDPLITE) < 0)
-               goto out_unregister_proto;
-
-       inet_register_protosw(&udplite4_protosw);
-
-#ifdef CONFIG_PROC_FS
-       if (udp_proc_register(&udplite4_seq_afinfo)) /* udplite4_proc_init() */
-               printk(KERN_ERR "%s: Cannot register /proc!\n", __FUNCTION__);
-#endif
-       return;
-
-out_unregister_proto:
-       proto_unregister(&udplite_prot);
-out_register_err:
-       printk(KERN_CRIT "%s: Cannot add UDP-Lite protocol.\n", __FUNCTION__);
-}
-
-EXPORT_SYMBOL(udplite_hash);
-EXPORT_SYMBOL(udplite_prot);
-EXPORT_SYMBOL(udplite_get_port);
diff --git a/net/ipv4/udplite_ipv4.c b/net/ipv4/udplite_ipv4.c
new file mode 100644 (file)
index 0000000..001b881
--- /dev/null
@@ -0,0 +1,121 @@
+/*
+ *  UDPLITE     An implementation of the UDP-Lite protocol (RFC 3828).
+ *
+ *  Version:    $Id: udplite.c,v 1.25 2006/10/19 07:22:36 gerrit Exp $
+ *
+ *  Authors:    Gerrit Renker       <gerrit@erg.abdn.ac.uk>
+ *
+ *  Changes:
+ *  Fixes:
+ *             This program is free software; you can redistribute it and/or
+ *             modify it under the terms of the GNU General Public License
+ *             as published by the Free Software Foundation; either version
+ *             2 of the License, or (at your option) any later version.
+ */
+#include "udp_impl.h"
+DEFINE_SNMP_STAT(struct udp_mib, udplite_statistics)   __read_mostly;
+
+struct hlist_head      udplite_hash[UDP_HTABLE_SIZE];
+
+int udplite_get_port(struct sock *sk, unsigned short p,
+                    int (*c)(const struct sock *, const struct sock *))
+{
+       return  __udp_lib_get_port(sk, p, udplite_hash, c);
+}
+
+static int udplite_v4_get_port(struct sock *sk, unsigned short snum)
+{
+       return udplite_get_port(sk, snum, ipv4_rcv_saddr_equal);
+}
+
+static int udplite_rcv(struct sk_buff *skb)
+{
+       return __udp4_lib_rcv(skb, udplite_hash, IPPROTO_UDPLITE);
+}
+
+static void udplite_err(struct sk_buff *skb, u32 info)
+{
+       __udp4_lib_err(skb, info, udplite_hash);
+}
+
+static struct net_protocol udplite_protocol = {
+       .handler        = udplite_rcv,
+       .err_handler    = udplite_err,
+       .no_policy      = 1,
+};
+
+DEFINE_PROTO_INUSE(udplite)
+
+struct proto   udplite_prot = {
+       .name              = "UDP-Lite",
+       .owner             = THIS_MODULE,
+       .close             = udp_lib_close,
+       .connect           = ip4_datagram_connect,
+       .disconnect        = udp_disconnect,
+       .ioctl             = udp_ioctl,
+       .init              = udplite_sk_init,
+       .destroy           = udp_destroy_sock,
+       .setsockopt        = udp_setsockopt,
+       .getsockopt        = udp_getsockopt,
+       .sendmsg           = udp_sendmsg,
+       .recvmsg           = udp_recvmsg,
+       .sendpage          = udp_sendpage,
+       .backlog_rcv       = udp_queue_rcv_skb,
+       .hash              = udp_lib_hash,
+       .unhash            = udp_lib_unhash,
+       .get_port          = udplite_v4_get_port,
+       .obj_size          = sizeof(struct udp_sock),
+#ifdef CONFIG_COMPAT
+       .compat_setsockopt = compat_udp_setsockopt,
+       .compat_getsockopt = compat_udp_getsockopt,
+#endif
+       REF_PROTO_INUSE(udplite)
+};
+
+static struct inet_protosw udplite4_protosw = {
+       .type           =  SOCK_DGRAM,
+       .protocol       =  IPPROTO_UDPLITE,
+       .prot           =  &udplite_prot,
+       .ops            =  &inet_dgram_ops,
+       .capability     = -1,
+       .no_check       =  0,           /* must checksum (RFC 3828) */
+       .flags          =  INET_PROTOSW_PERMANENT,
+};
+
+#ifdef CONFIG_PROC_FS
+static struct file_operations udplite4_seq_fops;
+static struct udp_seq_afinfo udplite4_seq_afinfo = {
+       .owner          = THIS_MODULE,
+       .name           = "udplite",
+       .family         = AF_INET,
+       .hashtable      = udplite_hash,
+       .seq_show       = udp4_seq_show,
+       .seq_fops       = &udplite4_seq_fops,
+};
+#endif
+
+void __init udplite4_register(void)
+{
+       if (proto_register(&udplite_prot, 1))
+               goto out_register_err;
+
+       if (inet_add_protocol(&udplite_protocol, IPPROTO_UDPLITE) < 0)
+               goto out_unregister_proto;
+
+       inet_register_protosw(&udplite4_protosw);
+
+#ifdef CONFIG_PROC_FS
+       if (udp_proc_register(&udplite4_seq_afinfo)) /* udplite4_proc_init() */
+               printk(KERN_ERR "%s: Cannot register /proc!\n", __FUNCTION__);
+#endif
+       return;
+
+out_unregister_proto:
+       proto_unregister(&udplite_prot);
+out_register_err:
+       printk(KERN_CRIT "%s: Cannot add UDP-Lite protocol.\n", __FUNCTION__);
+}
+
+EXPORT_SYMBOL(udplite_hash);
+EXPORT_SYMBOL(udplite_prot);
+EXPORT_SYMBOL(udplite_get_port);