udp.c (8a517c514d5893602cf85c1b4c47afbbc04d2198) udp.c (6ce9e7b5fe3195d1ae6e3a0753d4ddcac5cd699e)
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * The User Datagram Protocol (UDP).
7 *
8 * Authors: Ross Biro

--- 96 unchanged lines hidden (view full) ---

105#include <net/checksum.h>
106#include <net/xfrm.h>
107#include "udp_impl.h"
108
109struct udp_table udp_table;
110EXPORT_SYMBOL(udp_table);
111
112int sysctl_udp_mem[3] __read_mostly;
1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * The User Datagram Protocol (UDP).
7 *
8 * Authors: Ross Biro

--- 96 unchanged lines hidden (view full) ---

105#include <net/checksum.h>
106#include <net/xfrm.h>
107#include "udp_impl.h"
108
109struct udp_table udp_table;
110EXPORT_SYMBOL(udp_table);
111
112int sysctl_udp_mem[3] __read_mostly;
113int sysctl_udp_rmem_min __read_mostly;
114int sysctl_udp_wmem_min __read_mostly;
115
116EXPORT_SYMBOL(sysctl_udp_mem);
113EXPORT_SYMBOL(sysctl_udp_mem);
114
115int sysctl_udp_rmem_min __read_mostly;
117EXPORT_SYMBOL(sysctl_udp_rmem_min);
116EXPORT_SYMBOL(sysctl_udp_rmem_min);
117
118int sysctl_udp_wmem_min __read_mostly;
118EXPORT_SYMBOL(sysctl_udp_wmem_min);
119
120atomic_t udp_memory_allocated;
121EXPORT_SYMBOL(udp_memory_allocated);
122
123#define PORTS_PER_CHAIN (65536 / UDP_HTABLE_SIZE)
124
125static int udp_lib_lport_inuse(struct net *net, __u16 num,

--- 27 unchanged lines hidden (view full) ---

153 * udp_lib_get_port - UDP/-Lite port lookup for IPv4 and IPv6
154 *
155 * @sk: socket struct in question
156 * @snum: port number to look up
157 * @saddr_comp: AF-dependent comparison of bound local IP addresses
158 */
159int udp_lib_get_port(struct sock *sk, unsigned short snum,
160 int (*saddr_comp)(const struct sock *sk1,
119EXPORT_SYMBOL(sysctl_udp_wmem_min);
120
121atomic_t udp_memory_allocated;
122EXPORT_SYMBOL(udp_memory_allocated);
123
124#define PORTS_PER_CHAIN (65536 / UDP_HTABLE_SIZE)
125
126static int udp_lib_lport_inuse(struct net *net, __u16 num,

--- 27 unchanged lines hidden (view full) ---

154 * udp_lib_get_port - UDP/-Lite port lookup for IPv4 and IPv6
155 *
156 * @sk: socket struct in question
157 * @snum: port number to look up
158 * @saddr_comp: AF-dependent comparison of bound local IP addresses
159 */
160int udp_lib_get_port(struct sock *sk, unsigned short snum,
161 int (*saddr_comp)(const struct sock *sk1,
161 const struct sock *sk2 ) )
162 const struct sock *sk2))
162{
163 struct udp_hslot *hslot;
164 struct udp_table *udptable = sk->sk_prot->h.udp_table;
165 int error = 1;
166 struct net *net = sock_net(sk);
167
168 if (!snum) {
169 int low, high, remaining;

--- 46 unchanged lines hidden (view full) ---

216 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
217 }
218 error = 0;
219fail_unlock:
220 spin_unlock_bh(&hslot->lock);
221fail:
222 return error;
223}
163{
164 struct udp_hslot *hslot;
165 struct udp_table *udptable = sk->sk_prot->h.udp_table;
166 int error = 1;
167 struct net *net = sock_net(sk);
168
169 if (!snum) {
170 int low, high, remaining;

--- 46 unchanged lines hidden (view full) ---

217 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
218 }
219 error = 0;
220fail_unlock:
221 spin_unlock_bh(&hslot->lock);
222fail:
223 return error;
224}
225EXPORT_SYMBOL(udp_lib_get_port);
224
225static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
226{
227 struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
228
226
227static int ipv4_rcv_saddr_equal(const struct sock *sk1, const struct sock *sk2)
228{
229 struct inet_sock *inet1 = inet_sk(sk1), *inet2 = inet_sk(sk2);
230
229 return ( !ipv6_only_sock(sk2) &&
230 (!inet1->rcv_saddr || !inet2->rcv_saddr ||
231 inet1->rcv_saddr == inet2->rcv_saddr ));
231 return (!ipv6_only_sock(sk2) &&
232 (!inet1->rcv_saddr || !inet2->rcv_saddr ||
233 inet1->rcv_saddr == inet2->rcv_saddr));
232}
233
234int udp_v4_get_port(struct sock *sk, unsigned short snum)
235{
236 return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal);
237}
238
239static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,

--- 138 unchanged lines hidden (view full) ---

378 * on past this. Then (as it used to claim before adjustment)
379 * header points to the first 8 bytes of the udp header. We need
380 * to find the appropriate port.
381 */
382
383void __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
384{
385 struct inet_sock *inet;
234}
235
236int udp_v4_get_port(struct sock *sk, unsigned short snum)
237{
238 return udp_lib_get_port(sk, snum, ipv4_rcv_saddr_equal);
239}
240
241static inline int compute_score(struct sock *sk, struct net *net, __be32 saddr,

--- 138 unchanged lines hidden (view full) ---

380 * on past this. Then (as it used to claim before adjustment)
381 * header points to the first 8 bytes of the udp header. We need
382 * to find the appropriate port.
383 */
384
385void __udp4_lib_err(struct sk_buff *skb, u32 info, struct udp_table *udptable)
386{
387 struct inet_sock *inet;
386 struct iphdr *iph = (struct iphdr*)skb->data;
387 struct udphdr *uh = (struct udphdr*)(skb->data+(iph->ihl<<2));
388 struct iphdr *iph = (struct iphdr *)skb->data;
389 struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2));
388 const int type = icmp_hdr(skb)->type;
389 const int code = icmp_hdr(skb)->code;
390 struct sock *sk;
391 int harderr;
392 int err;
393 struct net *net = dev_net(skb->dev);
394
395 sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,

--- 38 unchanged lines hidden (view full) ---

434 /*
435 * RFC1122: OK. Passes ICMP errors back to application, as per
436 * 4.1.3.3.
437 */
438 if (!inet->recverr) {
439 if (!harderr || sk->sk_state != TCP_ESTABLISHED)
440 goto out;
441 } else {
390 const int type = icmp_hdr(skb)->type;
391 const int code = icmp_hdr(skb)->code;
392 struct sock *sk;
393 int harderr;
394 int err;
395 struct net *net = dev_net(skb->dev);
396
397 sk = __udp4_lib_lookup(net, iph->daddr, uh->dest,

--- 38 unchanged lines hidden (view full) ---

436 /*
437 * RFC1122: OK. Passes ICMP errors back to application, as per
438 * 4.1.3.3.
439 */
440 if (!inet->recverr) {
441 if (!harderr || sk->sk_state != TCP_ESTABLISHED)
442 goto out;
443 } else {
442 ip_icmp_error(sk, skb, err, uh->dest, info, (u8*)(uh+1));
444 ip_icmp_error(sk, skb, err, uh->dest, info, (u8 *)(uh+1));
443 }
444 sk->sk_err = err;
445 sk->sk_error_report(sk);
446out:
447 sock_put(sk);
448}
449
450void udp_err(struct sk_buff *skb, u32 info)

--- 18 unchanged lines hidden (view full) ---

469
470/**
471 * udp4_hwcsum_outgoing - handle outgoing HW checksumming
472 * @sk: socket we are sending on
473 * @skb: sk_buff containing the filled-in UDP header
474 * (checksum field must be zeroed out)
475 */
476static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
445 }
446 sk->sk_err = err;
447 sk->sk_error_report(sk);
448out:
449 sock_put(sk);
450}
451
452void udp_err(struct sk_buff *skb, u32 info)

--- 18 unchanged lines hidden (view full) ---

471
472/**
473 * udp4_hwcsum_outgoing - handle outgoing HW checksumming
474 * @sk: socket we are sending on
475 * @skb: sk_buff containing the filled-in UDP header
476 * (checksum field must be zeroed out)
477 */
478static void udp4_hwcsum_outgoing(struct sock *sk, struct sk_buff *skb,
477 __be32 src, __be32 dst, int len )
479 __be32 src, __be32 dst, int len)
478{
479 unsigned int offset;
480 struct udphdr *uh = udp_hdr(skb);
481 __wsum csum = 0;
482
483 if (skb_queue_len(&sk->sk_write_queue) == 1) {
484 /*
485 * Only one fragment on the socket.

--- 54 unchanged lines hidden (view full) ---

540
541 else if (sk->sk_no_check == UDP_CSUM_NOXMIT) { /* UDP csum disabled */
542
543 skb->ip_summed = CHECKSUM_NONE;
544 goto send;
545
546 } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
547
480{
481 unsigned int offset;
482 struct udphdr *uh = udp_hdr(skb);
483 __wsum csum = 0;
484
485 if (skb_queue_len(&sk->sk_write_queue) == 1) {
486 /*
487 * Only one fragment on the socket.

--- 54 unchanged lines hidden (view full) ---

542
543 else if (sk->sk_no_check == UDP_CSUM_NOXMIT) { /* UDP csum disabled */
544
545 skb->ip_summed = CHECKSUM_NONE;
546 goto send;
547
548 } else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
549
548 udp4_hwcsum_outgoing(sk, skb, fl->fl4_src,fl->fl4_dst, up->len);
550 udp4_hwcsum_outgoing(sk, skb, fl->fl4_src, fl->fl4_dst, up->len);
549 goto send;
550
551 } else /* `normal' UDP */
552 csum = udp_csum_outgoing(sk, skb);
553
554 /* add protocol-dependent pseudo-header */
555 uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
551 goto send;
552
553 } else /* `normal' UDP */
554 csum = udp_csum_outgoing(sk, skb);
555
556 /* add protocol-dependent pseudo-header */
557 uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len,
556 sk->sk_protocol, csum );
558 sk->sk_protocol, csum);
557 if (uh->check == 0)
558 uh->check = CSUM_MANGLED_0;
559
560send:
561 err = ip_push_pending_frames(sk);
559 if (uh->check == 0)
560 uh->check = CSUM_MANGLED_0;
561
562send:
563 err = ip_push_pending_frames(sk);
564 if (err) {
565 if (err == -ENOBUFS && !inet->recverr) {
566 UDP_INC_STATS_USER(sock_net(sk),
567 UDP_MIB_SNDBUFERRORS, is_udplite);
568 err = 0;
569 }
570 } else
571 UDP_INC_STATS_USER(sock_net(sk),
572 UDP_MIB_OUTDATAGRAMS, is_udplite);
562out:
563 up->len = 0;
564 up->pending = 0;
573out:
574 up->len = 0;
575 up->pending = 0;
565 if (!err)
566 UDP_INC_STATS_USER(sock_net(sk),
567 UDP_MIB_OUTDATAGRAMS, is_udplite);
568 return err;
569}
570
571int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
572 size_t len)
573{
574 struct inet_sock *inet = inet_sk(sk);
575 struct udp_sock *up = udp_sk(sk);

--- 11 unchanged lines hidden (view full) ---

587
588 if (len > 0xFFFF)
589 return -EMSGSIZE;
590
591 /*
592 * Check the flags.
593 */
594
576 return err;
577}
578
579int udp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
580 size_t len)
581{
582 struct inet_sock *inet = inet_sk(sk);
583 struct udp_sock *up = udp_sk(sk);

--- 11 unchanged lines hidden (view full) ---

595
596 if (len > 0xFFFF)
597 return -EMSGSIZE;
598
599 /*
600 * Check the flags.
601 */
602
595 if (msg->msg_flags&MSG_OOB) /* Mirror BSD error message compatibility */
603 if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message compatibility */
596 return -EOPNOTSUPP;
597
598 ipc.opt = NULL;
599 ipc.shtx.flags = 0;
600
601 if (up->pending) {
602 /*
603 * There are pending frames.

--- 10 unchanged lines hidden (view full) ---

614 release_sock(sk);
615 }
616 ulen += sizeof(struct udphdr);
617
618 /*
619 * Get and verify the address.
620 */
621 if (msg->msg_name) {
604 return -EOPNOTSUPP;
605
606 ipc.opt = NULL;
607 ipc.shtx.flags = 0;
608
609 if (up->pending) {
610 /*
611 * There are pending frames.

--- 10 unchanged lines hidden (view full) ---

622 release_sock(sk);
623 }
624 ulen += sizeof(struct udphdr);
625
626 /*
627 * Get and verify the address.
628 */
629 if (msg->msg_name) {
622 struct sockaddr_in * usin = (struct sockaddr_in*)msg->msg_name;
630 struct sockaddr_in * usin = (struct sockaddr_in *)msg->msg_name;
623 if (msg->msg_namelen < sizeof(*usin))
624 return -EINVAL;
625 if (usin->sin_family != AF_INET) {
626 if (usin->sin_family != AF_UNSPEC)
627 return -EAFNOSUPPORT;
628 }
629
630 daddr = usin->sin_addr.s_addr;

--- 48 unchanged lines hidden (view full) ---

679 if (!ipc.oif)
680 ipc.oif = inet->mc_index;
681 if (!saddr)
682 saddr = inet->mc_addr;
683 connected = 0;
684 }
685
686 if (connected)
631 if (msg->msg_namelen < sizeof(*usin))
632 return -EINVAL;
633 if (usin->sin_family != AF_INET) {
634 if (usin->sin_family != AF_UNSPEC)
635 return -EAFNOSUPPORT;
636 }
637
638 daddr = usin->sin_addr.s_addr;

--- 48 unchanged lines hidden (view full) ---

687 if (!ipc.oif)
688 ipc.oif = inet->mc_index;
689 if (!saddr)
690 saddr = inet->mc_addr;
691 connected = 0;
692 }
693
694 if (connected)
687 rt = (struct rtable*)sk_dst_check(sk, 0);
695 rt = (struct rtable *)sk_dst_check(sk, 0);
688
689 if (rt == NULL) {
690 struct flowi fl = { .oif = ipc.oif,
691 .nl_u = { .ip4_u =
692 { .daddr = faddr,
693 .saddr = saddr,
694 .tos = tos } },
695 .proto = sk->sk_protocol,

--- 81 unchanged lines hidden (view full) ---

777
778do_confirm:
779 dst_confirm(&rt->u.dst);
780 if (!(msg->msg_flags&MSG_PROBE) || len)
781 goto back_from_confirm;
782 err = 0;
783 goto out;
784}
696
697 if (rt == NULL) {
698 struct flowi fl = { .oif = ipc.oif,
699 .nl_u = { .ip4_u =
700 { .daddr = faddr,
701 .saddr = saddr,
702 .tos = tos } },
703 .proto = sk->sk_protocol,

--- 81 unchanged lines hidden (view full) ---

785
786do_confirm:
787 dst_confirm(&rt->u.dst);
788 if (!(msg->msg_flags&MSG_PROBE) || len)
789 goto back_from_confirm;
790 err = 0;
791 goto out;
792}
793EXPORT_SYMBOL(udp_sendmsg);
785
786int udp_sendpage(struct sock *sk, struct page *page, int offset,
787 size_t size, int flags)
788{
789 struct udp_sock *up = udp_sk(sk);
790 int ret;
791
792 if (!up->pending) {

--- 73 unchanged lines hidden (view full) ---

866 }
867
868 default:
869 return -ENOIOCTLCMD;
870 }
871
872 return 0;
873}
794
795int udp_sendpage(struct sock *sk, struct page *page, int offset,
796 size_t size, int flags)
797{
798 struct udp_sock *up = udp_sk(sk);
799 int ret;
800
801 if (!up->pending) {

--- 73 unchanged lines hidden (view full) ---

875 }
876
877 default:
878 return -ENOIOCTLCMD;
879 }
880
881 return 0;
882}
883EXPORT_SYMBOL(udp_ioctl);
874
875/*
876 * This should be easy, if there is something there we
877 * return it, otherwise we block.
878 */
879
880int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
881 size_t len, int noblock, int flags, int *addr_len)

--- 5 unchanged lines hidden (view full) ---

887 int peeked;
888 int err;
889 int is_udplite = IS_UDPLITE(sk);
890
891 /*
892 * Check any passed addresses
893 */
894 if (addr_len)
884
885/*
886 * This should be easy, if there is something there we
887 * return it, otherwise we block.
888 */
889
890int udp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
891 size_t len, int noblock, int flags, int *addr_len)

--- 5 unchanged lines hidden (view full) ---

897 int peeked;
898 int err;
899 int is_udplite = IS_UDPLITE(sk);
900
901 /*
902 * Check any passed addresses
903 */
904 if (addr_len)
895 *addr_len=sizeof(*sin);
905 *addr_len = sizeof(*sin);
896
897 if (flags & MSG_ERRQUEUE)
898 return ip_recv_error(sk, msg, len);
899
900try_again:
901 skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
902 &peeked, &err);
903 if (!skb)

--- 14 unchanged lines hidden (view full) ---

918
919 if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
920 if (udp_lib_checksum_complete(skb))
921 goto csum_copy_err;
922 }
923
924 if (skb_csum_unnecessary(skb))
925 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
906
907 if (flags & MSG_ERRQUEUE)
908 return ip_recv_error(sk, msg, len);
909
910try_again:
911 skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0),
912 &peeked, &err);
913 if (!skb)

--- 14 unchanged lines hidden (view full) ---

928
929 if (copied < ulen || UDP_SKB_CB(skb)->partial_cov) {
930 if (udp_lib_checksum_complete(skb))
931 goto csum_copy_err;
932 }
933
934 if (skb_csum_unnecessary(skb))
935 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr),
926 msg->msg_iov, copied );
936 msg->msg_iov, copied);
927 else {
937 else {
928 err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
938 err = skb_copy_and_csum_datagram_iovec(skb,
939 sizeof(struct udphdr),
940 msg->msg_iov);
929
930 if (err == -EINVAL)
931 goto csum_copy_err;
932 }
933
934 if (err)
935 goto out_free;
936
937 if (!peeked)
938 UDP_INC_STATS_USER(sock_net(sk),
939 UDP_MIB_INDATAGRAMS, is_udplite);
940
941 sock_recv_timestamp(msg, sk, skb);
942
943 /* Copy the address. */
941
942 if (err == -EINVAL)
943 goto csum_copy_err;
944 }
945
946 if (err)
947 goto out_free;
948
949 if (!peeked)
950 UDP_INC_STATS_USER(sock_net(sk),
951 UDP_MIB_INDATAGRAMS, is_udplite);
952
953 sock_recv_timestamp(msg, sk, skb);
954
955 /* Copy the address. */
944 if (sin)
945 {
956 if (sin) {
946 sin->sin_family = AF_INET;
947 sin->sin_port = udp_hdr(skb)->source;
948 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
949 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
950 }
951 if (inet->cmsg_flags)
952 ip_cmsg_recv(msg, skb);
953

--- 36 unchanged lines hidden (view full) ---

990
991 if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
992 sk->sk_prot->unhash(sk);
993 inet->sport = 0;
994 }
995 sk_dst_reset(sk);
996 return 0;
997}
957 sin->sin_family = AF_INET;
958 sin->sin_port = udp_hdr(skb)->source;
959 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
960 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
961 }
962 if (inet->cmsg_flags)
963 ip_cmsg_recv(msg, skb);
964

--- 36 unchanged lines hidden (view full) ---

1001
1002 if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
1003 sk->sk_prot->unhash(sk);
1004 inet->sport = 0;
1005 }
1006 sk_dst_reset(sk);
1007 return 0;
1008}
1009EXPORT_SYMBOL(udp_disconnect);
998
999void udp_lib_unhash(struct sock *sk)
1000{
1001 if (sk_hashed(sk)) {
1002 struct udp_table *udptable = sk->sk_prot->h.udp_table;
1003 unsigned int hash = udp_hashfn(sock_net(sk), sk->sk_hash);
1004 struct udp_hslot *hslot = &udptable->hash[hash];
1005

--- 33 unchanged lines hidden (view full) ---

1039/* returns:
1040 * -1: error
1041 * 0: success
1042 * >0: "udp encap" protocol resubmission
1043 *
1044 * Note that in the success and error cases, the skb is assumed to
1045 * have either been requeued or freed.
1046 */
1010
1011void udp_lib_unhash(struct sock *sk)
1012{
1013 if (sk_hashed(sk)) {
1014 struct udp_table *udptable = sk->sk_prot->h.udp_table;
1015 unsigned int hash = udp_hashfn(sock_net(sk), sk->sk_hash);
1016 struct udp_hslot *hslot = &udptable->hash[hash];
1017

--- 33 unchanged lines hidden (view full) ---

1051/* returns:
1052 * -1: error
1053 * 0: success
1054 * >0: "udp encap" protocol resubmission
1055 *
1056 * Note that in the success and error cases, the skb is assumed to
1057 * have either been requeued or freed.
1058 */
1047int udp_queue_rcv_skb(struct sock * sk, struct sk_buff *skb)
1059int udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
1048{
1049 struct udp_sock *up = udp_sk(sk);
1050 int rc;
1051 int is_udplite = IS_UDPLITE(sk);
1052
1053 /*
1054 * Charge it to the socket, dropping if the queue is full.
1055 */

--- 153 unchanged lines hidden (view full) ---

1209 if (err)
1210 return err;
1211 }
1212
1213 iph = ip_hdr(skb);
1214 if (uh->check == 0) {
1215 skb->ip_summed = CHECKSUM_UNNECESSARY;
1216 } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
1060{
1061 struct udp_sock *up = udp_sk(sk);
1062 int rc;
1063 int is_udplite = IS_UDPLITE(sk);
1064
1065 /*
1066 * Charge it to the socket, dropping if the queue is full.
1067 */

--- 153 unchanged lines hidden (view full) ---

1221 if (err)
1222 return err;
1223 }
1224
1225 iph = ip_hdr(skb);
1226 if (uh->check == 0) {
1227 skb->ip_summed = CHECKSUM_UNNECESSARY;
1228 } else if (skb->ip_summed == CHECKSUM_COMPLETE) {
1217 if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1229 if (!csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1218 proto, skb->csum))
1219 skb->ip_summed = CHECKSUM_UNNECESSARY;
1220 }
1221 if (!skb_csum_unnecessary(skb))
1222 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1223 skb->len, proto, 0);
1224 /* Probably, we should checksum udp header (it should be in cache
1225 * in any case) and data in tiny packets (< rx copybreak).

--- 124 unchanged lines hidden (view full) ---

1350 char __user *optval, int optlen,
1351 int (*push_pending_frames)(struct sock *))
1352{
1353 struct udp_sock *up = udp_sk(sk);
1354 int val;
1355 int err = 0;
1356 int is_udplite = IS_UDPLITE(sk);
1357
1230 proto, skb->csum))
1231 skb->ip_summed = CHECKSUM_UNNECESSARY;
1232 }
1233 if (!skb_csum_unnecessary(skb))
1234 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1235 skb->len, proto, 0);
1236 /* Probably, we should checksum udp header (it should be in cache
1237 * in any case) and data in tiny packets (< rx copybreak).

--- 124 unchanged lines hidden (view full) ---

1362 char __user *optval, int optlen,
1363 int (*push_pending_frames)(struct sock *))
1364{
1365 struct udp_sock *up = udp_sk(sk);
1366 int val;
1367 int err = 0;
1368 int is_udplite = IS_UDPLITE(sk);
1369
1358 if (optlen<sizeof(int))
1370 if (optlen < sizeof(int))
1359 return -EINVAL;
1360
1361 if (get_user(val, (int __user *)optval))
1362 return -EFAULT;
1363
1364 switch (optname) {
1365 case UDP_CORK:
1366 if (val != 0) {

--- 54 unchanged lines hidden (view full) ---

1421
1422 default:
1423 err = -ENOPROTOOPT;
1424 break;
1425 }
1426
1427 return err;
1428}
1371 return -EINVAL;
1372
1373 if (get_user(val, (int __user *)optval))
1374 return -EFAULT;
1375
1376 switch (optname) {
1377 case UDP_CORK:
1378 if (val != 0) {

--- 54 unchanged lines hidden (view full) ---

1433
1434 default:
1435 err = -ENOPROTOOPT;
1436 break;
1437 }
1438
1439 return err;
1440}
1441EXPORT_SYMBOL(udp_lib_setsockopt);
1429
1430int udp_setsockopt(struct sock *sk, int level, int optname,
1431 char __user *optval, int optlen)
1432{
1433 if (level == SOL_UDP || level == SOL_UDPLITE)
1434 return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1435 udp_push_pending_frames);
1436 return ip_setsockopt(sk, level, optname, optval, optlen);

--- 11 unchanged lines hidden (view full) ---

1448#endif
1449
1450int udp_lib_getsockopt(struct sock *sk, int level, int optname,
1451 char __user *optval, int __user *optlen)
1452{
1453 struct udp_sock *up = udp_sk(sk);
1454 int val, len;
1455
1442
1443int udp_setsockopt(struct sock *sk, int level, int optname,
1444 char __user *optval, int optlen)
1445{
1446 if (level == SOL_UDP || level == SOL_UDPLITE)
1447 return udp_lib_setsockopt(sk, level, optname, optval, optlen,
1448 udp_push_pending_frames);
1449 return ip_setsockopt(sk, level, optname, optval, optlen);

--- 11 unchanged lines hidden (view full) ---

1461#endif
1462
1463int udp_lib_getsockopt(struct sock *sk, int level, int optname,
1464 char __user *optval, int __user *optlen)
1465{
1466 struct udp_sock *up = udp_sk(sk);
1467 int val, len;
1468
1456 if (get_user(len,optlen))
1469 if (get_user(len, optlen))
1457 return -EFAULT;
1458
1459 len = min_t(unsigned int, len, sizeof(int));
1460
1461 if (len < 0)
1462 return -EINVAL;
1463
1464 switch (optname) {

--- 16 unchanged lines hidden (view full) ---

1481 break;
1482
1483 default:
1484 return -ENOPROTOOPT;
1485 }
1486
1487 if (put_user(len, optlen))
1488 return -EFAULT;
1470 return -EFAULT;
1471
1472 len = min_t(unsigned int, len, sizeof(int));
1473
1474 if (len < 0)
1475 return -EINVAL;
1476
1477 switch (optname) {

--- 16 unchanged lines hidden (view full) ---

1494 break;
1495
1496 default:
1497 return -ENOPROTOOPT;
1498 }
1499
1500 if (put_user(len, optlen))
1501 return -EFAULT;
1489 if (copy_to_user(optval, &val,len))
1502 if (copy_to_user(optval, &val, len))
1490 return -EFAULT;
1491 return 0;
1492}
1503 return -EFAULT;
1504 return 0;
1505}
1506EXPORT_SYMBOL(udp_lib_getsockopt);
1493
1494int udp_getsockopt(struct sock *sk, int level, int optname,
1495 char __user *optval, int __user *optlen)
1496{
1497 if (level == SOL_UDP || level == SOL_UDPLITE)
1498 return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1499 return ip_getsockopt(sk, level, optname, optval, optlen);
1500}

--- 22 unchanged lines hidden (view full) ---

1523 */
1524unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
1525{
1526 unsigned int mask = datagram_poll(file, sock, wait);
1527 struct sock *sk = sock->sk;
1528 int is_lite = IS_UDPLITE(sk);
1529
1530 /* Check for false positives due to checksum errors */
1507
1508int udp_getsockopt(struct sock *sk, int level, int optname,
1509 char __user *optval, int __user *optlen)
1510{
1511 if (level == SOL_UDP || level == SOL_UDPLITE)
1512 return udp_lib_getsockopt(sk, level, optname, optval, optlen);
1513 return ip_getsockopt(sk, level, optname, optval, optlen);
1514}

--- 22 unchanged lines hidden (view full) ---

1537 */
1538unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
1539{
1540 unsigned int mask = datagram_poll(file, sock, wait);
1541 struct sock *sk = sock->sk;
1542 int is_lite = IS_UDPLITE(sk);
1543
1544 /* Check for false positives due to checksum errors */
1531 if ( (mask & POLLRDNORM) &&
1532 !(file->f_flags & O_NONBLOCK) &&
1533 !(sk->sk_shutdown & RCV_SHUTDOWN)){
1545 if ((mask & POLLRDNORM) &&
1546 !(file->f_flags & O_NONBLOCK) &&
1547 !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1534 struct sk_buff_head *rcvq = &sk->sk_receive_queue;
1535 struct sk_buff *skb;
1536
1537 spin_lock_bh(&rcvq->lock);
1538 while ((skb = skb_peek(rcvq)) != NULL &&
1539 udp_lib_checksum_complete(skb)) {
1540 UDP_INC_STATS_BH(sock_net(sk),
1541 UDP_MIB_INERRORS, is_lite);

--- 5 unchanged lines hidden (view full) ---

1547 /* nothing to see, move along */
1548 if (skb == NULL)
1549 mask &= ~(POLLIN | POLLRDNORM);
1550 }
1551
1552 return mask;
1553
1554}
1548 struct sk_buff_head *rcvq = &sk->sk_receive_queue;
1549 struct sk_buff *skb;
1550
1551 spin_lock_bh(&rcvq->lock);
1552 while ((skb = skb_peek(rcvq)) != NULL &&
1553 udp_lib_checksum_complete(skb)) {
1554 UDP_INC_STATS_BH(sock_net(sk),
1555 UDP_MIB_INERRORS, is_lite);

--- 5 unchanged lines hidden (view full) ---

1561 /* nothing to see, move along */
1562 if (skb == NULL)
1563 mask &= ~(POLLIN | POLLRDNORM);
1564 }
1565
1566 return mask;
1567
1568}
1569EXPORT_SYMBOL(udp_poll);
1555
1556struct proto udp_prot = {
1557 .name = "UDP",
1558 .owner = THIS_MODULE,
1559 .close = udp_lib_close,
1560 .connect = ip4_datagram_connect,
1561 .disconnect = udp_disconnect,
1562 .ioctl = udp_ioctl,

--- 14 unchanged lines hidden (view full) ---

1577 .obj_size = sizeof(struct udp_sock),
1578 .slab_flags = SLAB_DESTROY_BY_RCU,
1579 .h.udp_table = &udp_table,
1580#ifdef CONFIG_COMPAT
1581 .compat_setsockopt = compat_udp_setsockopt,
1582 .compat_getsockopt = compat_udp_getsockopt,
1583#endif
1584};
1570
1571struct proto udp_prot = {
1572 .name = "UDP",
1573 .owner = THIS_MODULE,
1574 .close = udp_lib_close,
1575 .connect = ip4_datagram_connect,
1576 .disconnect = udp_disconnect,
1577 .ioctl = udp_ioctl,

--- 14 unchanged lines hidden (view full) ---

1592 .obj_size = sizeof(struct udp_sock),
1593 .slab_flags = SLAB_DESTROY_BY_RCU,
1594 .h.udp_table = &udp_table,
1595#ifdef CONFIG_COMPAT
1596 .compat_setsockopt = compat_udp_setsockopt,
1597 .compat_getsockopt = compat_udp_getsockopt,
1598#endif
1599};
1600EXPORT_SYMBOL(udp_prot);
1585
1586/* ------------------------------------------------------------------------ */
1587#ifdef CONFIG_PROC_FS
1588
1589static struct sock *udp_get_first(struct seq_file *seq, int start)
1590{
1591 struct sock *sk;
1592 struct udp_iter_state *state = seq->private;

--- 105 unchanged lines hidden (view full) ---

1698 afinfo->seq_ops.stop = udp_seq_stop;
1699
1700 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
1701 &afinfo->seq_fops, afinfo);
1702 if (!p)
1703 rc = -ENOMEM;
1704 return rc;
1705}
1601
1602/* ------------------------------------------------------------------------ */
1603#ifdef CONFIG_PROC_FS
1604
1605static struct sock *udp_get_first(struct seq_file *seq, int start)
1606{
1607 struct sock *sk;
1608 struct udp_iter_state *state = seq->private;

--- 105 unchanged lines hidden (view full) ---

1714 afinfo->seq_ops.stop = udp_seq_stop;
1715
1716 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
1717 &afinfo->seq_fops, afinfo);
1718 if (!p)
1719 rc = -ENOMEM;
1720 return rc;
1721}
1722EXPORT_SYMBOL(udp_proc_register);
1706
1707void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
1708{
1709 proc_net_remove(net, afinfo->name);
1710}
1723
1724void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo)
1725{
1726 proc_net_remove(net, afinfo->name);
1727}
1728EXPORT_SYMBOL(udp_proc_unregister);
1711
1712/* ------------------------------------------------------------------------ */
1713static void udp4_format_sock(struct sock *sp, struct seq_file *f,
1714 int bucket, int *len)
1715{
1716 struct inet_sock *inet = inet_sk(sp);
1717 __be32 dest = inet->daddr;
1718 __be32 src = inet->rcv_saddr;

--- 17 unchanged lines hidden (view full) ---

1736 " sl local_address rem_address st tx_queue "
1737 "rx_queue tr tm->when retrnsmt uid timeout "
1738 "inode ref pointer drops");
1739 else {
1740 struct udp_iter_state *state = seq->private;
1741 int len;
1742
1743 udp4_format_sock(v, seq, state->bucket, &len);
1729
1730/* ------------------------------------------------------------------------ */
1731static void udp4_format_sock(struct sock *sp, struct seq_file *f,
1732 int bucket, int *len)
1733{
1734 struct inet_sock *inet = inet_sk(sp);
1735 __be32 dest = inet->daddr;
1736 __be32 src = inet->rcv_saddr;

--- 17 unchanged lines hidden (view full) ---

1754 " sl local_address rem_address st tx_queue "
1755 "rx_queue tr tm->when retrnsmt uid timeout "
1756 "inode ref pointer drops");
1757 else {
1758 struct udp_iter_state *state = seq->private;
1759 int len;
1760
1761 udp4_format_sock(v, seq, state->bucket, &len);
1744 seq_printf(seq, "%*s\n", 127 - len ,"");
1762 seq_printf(seq, "%*s\n", 127 - len, "");
1745 }
1746 return 0;
1747}
1748
1749/* ------------------------------------------------------------------------ */
1750static struct udp_seq_afinfo udp4_seq_afinfo = {
1751 .name = "udp",
1752 .family = AF_INET,

--- 58 unchanged lines hidden (view full) ---

1811 sysctl_udp_mem[0] = limit / 4 * 3;
1812 sysctl_udp_mem[1] = limit;
1813 sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
1814
1815 sysctl_udp_rmem_min = SK_MEM_QUANTUM;
1816 sysctl_udp_wmem_min = SK_MEM_QUANTUM;
1817}
1818
1763 }
1764 return 0;
1765}
1766
1767/* ------------------------------------------------------------------------ */
1768static struct udp_seq_afinfo udp4_seq_afinfo = {
1769 .name = "udp",
1770 .family = AF_INET,

--- 58 unchanged lines hidden (view full) ---

1829 sysctl_udp_mem[0] = limit / 4 * 3;
1830 sysctl_udp_mem[1] = limit;
1831 sysctl_udp_mem[2] = sysctl_udp_mem[0] * 2;
1832
1833 sysctl_udp_rmem_min = SK_MEM_QUANTUM;
1834 sysctl_udp_wmem_min = SK_MEM_QUANTUM;
1835}
1836
1819EXPORT_SYMBOL(udp_disconnect);
1820EXPORT_SYMBOL(udp_ioctl);
1821EXPORT_SYMBOL(udp_prot);
1822EXPORT_SYMBOL(udp_sendmsg);
1823EXPORT_SYMBOL(udp_lib_getsockopt);
1824EXPORT_SYMBOL(udp_lib_setsockopt);
1825EXPORT_SYMBOL(udp_poll);
1826EXPORT_SYMBOL(udp_lib_get_port);
1837int udp4_ufo_send_check(struct sk_buff *skb)
1838{
1839 const struct iphdr *iph;
1840 struct udphdr *uh;
1827
1841
1828#ifdef CONFIG_PROC_FS
1829EXPORT_SYMBOL(udp_proc_register);
1830EXPORT_SYMBOL(udp_proc_unregister);
1831#endif
1842 if (!pskb_may_pull(skb, sizeof(*uh)))
1843 return -EINVAL;
1844
1845 iph = ip_hdr(skb);
1846 uh = udp_hdr(skb);
1847
1848 uh->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, skb->len,
1849 IPPROTO_UDP, 0);
1850 skb->csum_start = skb_transport_header(skb) - skb->head;
1851 skb->csum_offset = offsetof(struct udphdr, check);
1852 skb->ip_summed = CHECKSUM_PARTIAL;
1853 return 0;
1854}
1855
1856struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, int features)
1857{
1858 struct sk_buff *segs = ERR_PTR(-EINVAL);
1859 unsigned int mss;
1860 int offset;
1861 __wsum csum;
1862
1863 mss = skb_shinfo(skb)->gso_size;
1864 if (unlikely(skb->len <= mss))
1865 goto out;
1866
1867 if (skb_gso_ok(skb, features | NETIF_F_GSO_ROBUST)) {
1868 /* Packet is from an untrusted source, reset gso_segs. */
1869 int type = skb_shinfo(skb)->gso_type;
1870
1871 if (unlikely(type & ~(SKB_GSO_UDP | SKB_GSO_DODGY) ||
1872 !(type & (SKB_GSO_UDP))))
1873 goto out;
1874
1875 skb_shinfo(skb)->gso_segs = DIV_ROUND_UP(skb->len, mss);
1876
1877 segs = NULL;
1878 goto out;
1879 }
1880
1881 /* Do software UFO. Complete and fill in the UDP checksum as HW cannot
1882 * do checksum of UDP packets sent as multiple IP fragments.
1883 */
1884 offset = skb->csum_start - skb_headroom(skb);
1885 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1886 offset += skb->csum_offset;
1887 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1888 skb->ip_summed = CHECKSUM_NONE;
1889
1890 /* Fragment the skb. IP headers of the fragments are updated in
1891 * inet_gso_segment()
1892 */
1893 segs = skb_segment(skb, features);
1894out:
1895 return segs;
1896}
1897