Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | * Definitions for the UDP module. |
| 7 | * |
| 8 | * Version: @(#)udp.h 1.0.2 05/07/93 |
| 9 | * |
Jesper Juhl | 02c30a8 | 2005-05-05 16:16:16 -0700 | [diff] [blame] | 10 | * Authors: Ross Biro |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> |
| 12 | * |
| 13 | * Fixes: |
| 14 | * Alan Cox : Turned on udp checksums. I don't want to |
| 15 | * chase 'memory corruption' bugs that aren't! |
| 16 | * |
| 17 | * This program is free software; you can redistribute it and/or |
| 18 | * modify it under the terms of the GNU General Public License |
| 19 | * as published by the Free Software Foundation; either version |
| 20 | * 2 of the License, or (at your option) any later version. |
| 21 | */ |
| 22 | #ifndef _UDP_H |
| 23 | #define _UDP_H |
| 24 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | #include <linux/list.h> |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 26 | #include <net/inet_sock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <net/sock.h> |
| 28 | #include <net/snmp.h> |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 29 | #include <net/ip.h> |
| 30 | #include <linux/ipv6.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/seq_file.h> |
Al Viro | bd01f84 | 2006-10-19 17:23:57 -0400 | [diff] [blame] | 32 | #include <linux/poll.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 34 | /** |
| 35 | * struct udp_skb_cb - UDP(-Lite) private variables |
| 36 | * |
| 37 | * @header: private variables used by IPv4/IPv6 |
| 38 | * @cscov: checksum coverage length (UDP-Lite only) |
| 39 | * @partial_cov: if set indicates partial csum coverage |
| 40 | */ |
| 41 | struct udp_skb_cb { |
| 42 | union { |
| 43 | struct inet_skb_parm h4; |
| 44 | #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) |
| 45 | struct inet6_skb_parm h6; |
| 46 | #endif |
| 47 | } header; |
| 48 | __u16 cscov; |
| 49 | __u8 partial_cov; |
| 50 | }; |
| 51 | #define UDP_SKB_CB(__skb) ((struct udp_skb_cb *)((__skb)->cb)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 53 | struct udp_hslot { |
Eric Dumazet | 88ab193 | 2008-11-16 19:39:21 -0800 | [diff] [blame] | 54 | struct hlist_nulls_head head; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 55 | spinlock_t lock; |
| 56 | } __attribute__((aligned(2 * sizeof(long)))); |
| 57 | struct udp_table { |
| 58 | struct udp_hslot hash[UDP_HTABLE_SIZE]; |
| 59 | }; |
| 60 | extern struct udp_table udp_table; |
| 61 | extern void udp_table_init(struct udp_table *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
| 64 | /* Note: this must match 'valbool' in sock_setsockopt */ |
| 65 | #define UDP_CSUM_NOXMIT 1 |
| 66 | |
| 67 | /* Used by SunRPC/xprt layer. */ |
| 68 | #define UDP_CSUM_NORCV 2 |
| 69 | |
| 70 | /* Default, as per the RFC, is to always do csums. */ |
| 71 | #define UDP_CSUM_DEFAULT 0 |
| 72 | |
| 73 | extern struct proto udp_prot; |
| 74 | |
Hideo Aoki | 95766ff | 2007-12-31 00:29:24 -0800 | [diff] [blame] | 75 | extern atomic_t udp_memory_allocated; |
| 76 | |
| 77 | /* sysctl variables for udp */ |
| 78 | extern int sysctl_udp_mem[3]; |
| 79 | extern int sysctl_udp_rmem_min; |
| 80 | extern int sysctl_udp_wmem_min; |
| 81 | |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 82 | struct sk_buff; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 84 | /* |
| 85 | * Generic checksumming routines for UDP(-Lite) v4 and v6 |
| 86 | */ |
Al Viro | b51655b | 2006-11-14 21:40:42 -0800 | [diff] [blame] | 87 | static inline __sum16 __udp_lib_checksum_complete(struct sk_buff *skb) |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 88 | { |
Herbert Xu | 759e5d0 | 2007-03-25 20:10:56 -0700 | [diff] [blame] | 89 | return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 90 | } |
| 91 | |
Al Viro | 8e5200f | 2006-11-20 18:06:37 -0800 | [diff] [blame] | 92 | static inline int udp_lib_checksum_complete(struct sk_buff *skb) |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 93 | { |
Herbert Xu | 6047637 | 2007-04-09 11:59:39 -0700 | [diff] [blame] | 94 | return !skb_csum_unnecessary(skb) && |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 95 | __udp_lib_checksum_complete(skb); |
| 96 | } |
| 97 | |
| 98 | /** |
| 99 | * udp_csum_outgoing - compute UDPv4/v6 checksum over fragments |
| 100 | * @sk: socket we are writing to |
| 101 | * @skb: sk_buff containing the filled-in UDP header |
| 102 | * (checksum field must be zeroed out) |
| 103 | */ |
Al Viro | 868c86b | 2006-11-14 21:35:48 -0800 | [diff] [blame] | 104 | static inline __wsum udp_csum_outgoing(struct sock *sk, struct sk_buff *skb) |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 105 | { |
Arnaldo Carvalho de Melo | 9c70220 | 2007-04-25 18:04:18 -0700 | [diff] [blame] | 106 | __wsum csum = csum_partial(skb_transport_header(skb), |
| 107 | sizeof(struct udphdr), 0); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 108 | skb_queue_walk(&sk->sk_write_queue, skb) { |
| 109 | csum = csum_add(csum, skb->csum); |
| 110 | } |
| 111 | return csum; |
| 112 | } |
| 113 | |
| 114 | /* hash routines shared between UDPv4/6 and UDP-Litev4/6 */ |
| 115 | static inline void udp_lib_hash(struct sock *sk) |
| 116 | { |
| 117 | BUG(); |
| 118 | } |
| 119 | |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 120 | extern void udp_lib_unhash(struct sock *sk); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 121 | |
| 122 | static inline void udp_lib_close(struct sock *sk, long timeout) |
| 123 | { |
| 124 | sk_common_release(sk); |
| 125 | } |
| 126 | |
Pavel Emelyanov | 6ba5a3c | 2008-03-22 16:51:21 -0700 | [diff] [blame] | 127 | extern int udp_lib_get_port(struct sock *sk, unsigned short snum, |
| 128 | int (*)(const struct sock*,const struct sock*)); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 129 | |
| 130 | /* net/ipv4/udp.c */ |
Gerrit Renker | 25030a7 | 2006-08-26 20:06:05 -0700 | [diff] [blame] | 131 | extern int udp_get_port(struct sock *sk, unsigned short snum, |
David S. Miller | df2bc45 | 2007-06-05 15:18:43 -0700 | [diff] [blame] | 132 | int (*saddr_cmp)(const struct sock *, const struct sock *)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | extern void udp_err(struct sk_buff *, u32); |
| 134 | |
| 135 | extern int udp_sendmsg(struct kiocb *iocb, struct sock *sk, |
| 136 | struct msghdr *msg, size_t len); |
Denis V. Lunev | 36d926b | 2008-06-04 15:49:07 +0400 | [diff] [blame] | 137 | extern void udp_flush_pending_frames(struct sock *sk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | |
| 139 | extern int udp_rcv(struct sk_buff *skb); |
| 140 | extern int udp_ioctl(struct sock *sk, int cmd, unsigned long arg); |
| 141 | extern int udp_disconnect(struct sock *sk, int flags); |
| 142 | extern unsigned int udp_poll(struct file *file, struct socket *sock, |
| 143 | poll_table *wait); |
Gerrit Renker | 4c0a6cb | 2006-11-27 09:29:59 -0800 | [diff] [blame] | 144 | extern int udp_lib_getsockopt(struct sock *sk, int level, int optname, |
| 145 | char __user *optval, int __user *optlen); |
| 146 | extern int udp_lib_setsockopt(struct sock *sk, int level, int optname, |
| 147 | char __user *optval, int optlen, |
| 148 | int (*push_pending_frames)(struct sock *)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 149 | |
KOVACS Krisztian | bcd4130 | 2008-10-01 07:48:10 -0700 | [diff] [blame] | 150 | extern struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport, |
| 151 | __be32 daddr, __be16 dport, |
| 152 | int dif); |
| 153 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 154 | /* |
| 155 | * SNMP statistics for UDP and UDP-Lite |
| 156 | */ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 157 | #define UDP_INC_STATS_USER(net, field, is_udplite) do { \ |
Pavel Emelyanov | 386019d | 2008-07-18 04:03:45 -0700 | [diff] [blame] | 158 | if (is_udplite) SNMP_INC_STATS_USER((net)->mib.udplite_statistics, field); \ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 159 | else SNMP_INC_STATS_USER((net)->mib.udp_statistics, field); } while(0) |
| 160 | #define UDP_INC_STATS_BH(net, field, is_udplite) do { \ |
Pavel Emelyanov | 386019d | 2008-07-18 04:03:45 -0700 | [diff] [blame] | 161 | if (is_udplite) SNMP_INC_STATS_BH((net)->mib.udplite_statistics, field); \ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 162 | else SNMP_INC_STATS_BH((net)->mib.udp_statistics, field); } while(0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | |
Denis V. Lunev | 0c7ed67 | 2008-10-07 14:49:36 -0700 | [diff] [blame] | 164 | #define UDP6_INC_STATS_BH(net, field, is_udplite) do { \ |
Denis V. Lunev | be713a4 | 2008-10-07 14:50:06 -0700 | [diff] [blame] | 165 | if (is_udplite) SNMP_INC_STATS_BH((net)->mib.udplite_stats_in6, field);\ |
Denis V. Lunev | 0c7ed67 | 2008-10-07 14:49:36 -0700 | [diff] [blame] | 166 | else SNMP_INC_STATS_BH((net)->mib.udp_stats_in6, field); \ |
| 167 | } while(0) |
Denis V. Lunev | be713a4 | 2008-10-07 14:50:06 -0700 | [diff] [blame] | 168 | #define UDP6_INC_STATS_USER(net, field, __lite) do { \ |
| 169 | if (__lite) SNMP_INC_STATS_USER((net)->mib.udplite_stats_in6, field); \ |
| 170 | else SNMP_INC_STATS_USER((net)->mib.udp_stats_in6, field); \ |
Denis V. Lunev | 0c7ed67 | 2008-10-07 14:49:36 -0700 | [diff] [blame] | 171 | } while(0) |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 172 | |
| 173 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) |
| 174 | #define UDPX_INC_STATS_BH(sk, field) \ |
| 175 | do { \ |
| 176 | if ((sk)->sk_family == AF_INET) \ |
Pavel Emelyanov | 0283328 | 2008-07-05 21:18:48 -0700 | [diff] [blame] | 177 | UDP_INC_STATS_BH(sock_net(sk), field, 0); \ |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 178 | else \ |
Pavel Emelyanov | ef28d1a | 2008-07-05 21:19:40 -0700 | [diff] [blame] | 179 | UDP6_INC_STATS_BH(sock_net(sk), field, 0); \ |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 180 | } while (0); |
| 181 | #else |
Pavel Emelyanov | 0283328 | 2008-07-05 21:18:48 -0700 | [diff] [blame] | 182 | #define UDPX_INC_STATS_BH(sk, field) UDP_INC_STATS_BH(sock_net(sk), field, 0) |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 183 | #endif |
| 184 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | /* /proc */ |
| 186 | struct udp_seq_afinfo { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | char *name; |
| 188 | sa_family_t family; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 189 | struct udp_table *udp_table; |
Denis V. Lunev | 3ba9441 | 2008-03-28 18:25:32 -0700 | [diff] [blame] | 190 | struct file_operations seq_fops; |
Denis V. Lunev | dda6192 | 2008-03-28 18:24:26 -0700 | [diff] [blame] | 191 | struct seq_operations seq_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | }; |
| 193 | |
| 194 | struct udp_iter_state { |
Denis V. Lunev | 6f191ef | 2008-03-28 18:23:33 -0700 | [diff] [blame] | 195 | struct seq_net_private p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | sa_family_t family; |
| 197 | int bucket; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 198 | struct udp_table *udp_table; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | }; |
| 200 | |
Arnaldo Carvalho de Melo | 2038073 | 2005-08-16 02:18:02 -0300 | [diff] [blame] | 201 | #ifdef CONFIG_PROC_FS |
Daniel Lezcano | 0c96d8c | 2008-03-21 04:14:17 -0700 | [diff] [blame] | 202 | extern int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo); |
| 203 | extern void udp_proc_unregister(struct net *net, struct udp_seq_afinfo *afinfo); |
Arnaldo Carvalho de Melo | 2038073 | 2005-08-16 02:18:02 -0300 | [diff] [blame] | 204 | |
| 205 | extern int udp4_proc_init(void); |
| 206 | extern void udp4_proc_exit(void); |
| 207 | #endif |
Hideo Aoki | 95766ff | 2007-12-31 00:29:24 -0800 | [diff] [blame] | 208 | |
| 209 | extern void udp_init(void); |
Sridhar Samudrala | d7ca4cc | 2009-07-09 08:09:47 +0000 | [diff] [blame] | 210 | |
| 211 | extern int udp4_ufo_send_check(struct sk_buff *skb); |
| 212 | extern struct sk_buff *udp4_ufo_fragment(struct sk_buff *skb, int features); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | #endif /* _UDP_H */ |