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 | fdcc8aa9 | 2009-11-08 10:17:05 +0000 | [diff] [blame] | 53 | /** |
| 54 | * struct udp_hslot - UDP hash slot |
| 55 | * |
| 56 | * @head: head of list of sockets |
| 57 | * @count: number of sockets in 'head' list |
| 58 | * @lock: spinlock protecting changes to head/count |
| 59 | */ |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 60 | struct udp_hslot { |
Eric Dumazet | 88ab193 | 2008-11-16 19:39:21 -0800 | [diff] [blame] | 61 | struct hlist_nulls_head head; |
Eric Dumazet | fdcc8aa9 | 2009-11-08 10:17:05 +0000 | [diff] [blame] | 62 | int count; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 63 | spinlock_t lock; |
| 64 | } __attribute__((aligned(2 * sizeof(long)))); |
Eric Dumazet | f86dcc5 | 2009-10-07 00:37:59 +0000 | [diff] [blame] | 65 | |
Eric Dumazet | 512615b | 2009-11-08 10:17:58 +0000 | [diff] [blame] | 66 | /** |
| 67 | * struct udp_table - UDP table |
| 68 | * |
| 69 | * @hash: hash table, sockets are hashed on (local port) |
| 70 | * @hash2: hash table, sockets are hashed on (local port, local address) |
| 71 | * @mask: number of slots in hash tables, minus 1 |
| 72 | * @log: log2(number of slots in hash table) |
| 73 | */ |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 74 | struct udp_table { |
Eric Dumazet | f86dcc5 | 2009-10-07 00:37:59 +0000 | [diff] [blame] | 75 | struct udp_hslot *hash; |
Eric Dumazet | 512615b | 2009-11-08 10:17:58 +0000 | [diff] [blame] | 76 | struct udp_hslot *hash2; |
| 77 | unsigned int mask; |
| 78 | unsigned int log; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 79 | }; |
| 80 | extern struct udp_table udp_table; |
Eric Dumazet | f86dcc5 | 2009-10-07 00:37:59 +0000 | [diff] [blame] | 81 | extern void udp_table_init(struct udp_table *, const char *); |
| 82 | static inline struct udp_hslot *udp_hashslot(struct udp_table *table, |
| 83 | struct net *net, unsigned num) |
| 84 | { |
| 85 | return &table->hash[udp_hashfn(net, num, table->mask)]; |
| 86 | } |
Eric Dumazet | 512615b | 2009-11-08 10:17:58 +0000 | [diff] [blame] | 87 | /* |
| 88 | * For secondary hash, net_hash_mix() is performed before calling |
| 89 | * udp_hashslot2(), this explains difference with udp_hashslot() |
| 90 | */ |
| 91 | static inline struct udp_hslot *udp_hashslot2(struct udp_table *table, |
| 92 | unsigned int hash) |
| 93 | { |
| 94 | return &table->hash2[hash & table->mask]; |
| 95 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | |
| 97 | /* Note: this must match 'valbool' in sock_setsockopt */ |
| 98 | #define UDP_CSUM_NOXMIT 1 |
| 99 | |
| 100 | /* Used by SunRPC/xprt layer. */ |
| 101 | #define UDP_CSUM_NORCV 2 |
| 102 | |
| 103 | /* Default, as per the RFC, is to always do csums. */ |
| 104 | #define UDP_CSUM_DEFAULT 0 |
| 105 | |
| 106 | extern struct proto udp_prot; |
| 107 | |
Hideo Aoki | 95766ff | 2007-12-31 00:29:24 -0800 | [diff] [blame] | 108 | extern atomic_t udp_memory_allocated; |
| 109 | |
| 110 | /* sysctl variables for udp */ |
| 111 | extern int sysctl_udp_mem[3]; |
| 112 | extern int sysctl_udp_rmem_min; |
| 113 | extern int sysctl_udp_wmem_min; |
| 114 | |
Arnaldo Carvalho de Melo | 14c8502 | 2005-12-27 02:43:12 -0200 | [diff] [blame] | 115 | struct sk_buff; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 117 | /* |
| 118 | * Generic checksumming routines for UDP(-Lite) v4 and v6 |
| 119 | */ |
Al Viro | b51655b | 2006-11-14 21:40:42 -0800 | [diff] [blame] | 120 | static inline __sum16 __udp_lib_checksum_complete(struct sk_buff *skb) |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 121 | { |
Herbert Xu | 759e5d0 | 2007-03-25 20:10:56 -0700 | [diff] [blame] | 122 | return __skb_checksum_complete_head(skb, UDP_SKB_CB(skb)->cscov); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Al Viro | 8e5200f | 2006-11-20 18:06:37 -0800 | [diff] [blame] | 125 | static inline int udp_lib_checksum_complete(struct sk_buff *skb) |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 126 | { |
Herbert Xu | 6047637 | 2007-04-09 11:59:39 -0700 | [diff] [blame] | 127 | return !skb_csum_unnecessary(skb) && |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 128 | __udp_lib_checksum_complete(skb); |
| 129 | } |
| 130 | |
| 131 | /** |
| 132 | * udp_csum_outgoing - compute UDPv4/v6 checksum over fragments |
| 133 | * @sk: socket we are writing to |
| 134 | * @skb: sk_buff containing the filled-in UDP header |
| 135 | * (checksum field must be zeroed out) |
| 136 | */ |
Al Viro | 868c86b | 2006-11-14 21:35:48 -0800 | [diff] [blame] | 137 | 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] | 138 | { |
Arnaldo Carvalho de Melo | 9c70220 | 2007-04-25 18:04:18 -0700 | [diff] [blame] | 139 | __wsum csum = csum_partial(skb_transport_header(skb), |
| 140 | sizeof(struct udphdr), 0); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 141 | skb_queue_walk(&sk->sk_write_queue, skb) { |
| 142 | csum = csum_add(csum, skb->csum); |
| 143 | } |
| 144 | return csum; |
| 145 | } |
| 146 | |
| 147 | /* hash routines shared between UDPv4/6 and UDP-Litev4/6 */ |
| 148 | static inline void udp_lib_hash(struct sock *sk) |
| 149 | { |
| 150 | BUG(); |
| 151 | } |
| 152 | |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 153 | extern void udp_lib_unhash(struct sock *sk); |
Eric Dumazet | 719f835 | 2010-09-08 05:08:44 +0000 | [diff] [blame] | 154 | extern void udp_lib_rehash(struct sock *sk, u16 new_hash); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 155 | |
| 156 | static inline void udp_lib_close(struct sock *sk, long timeout) |
| 157 | { |
| 158 | sk_common_release(sk); |
| 159 | } |
| 160 | |
Changli Gao | 53d3176 | 2010-07-10 20:41:06 +0000 | [diff] [blame] | 161 | extern int udp_lib_get_port(struct sock *sk, unsigned short snum, |
| 162 | int (*)(const struct sock *,const struct sock *), |
| 163 | unsigned int hash2_nulladdr); |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 164 | |
| 165 | /* net/ipv4/udp.c */ |
Changli Gao | 53d3176 | 2010-07-10 20:41:06 +0000 | [diff] [blame] | 166 | extern int udp_get_port(struct sock *sk, unsigned short snum, |
| 167 | int (*saddr_cmp)(const struct sock *, |
| 168 | const struct sock *)); |
| 169 | extern void udp_err(struct sk_buff *, u32); |
| 170 | extern int udp_sendmsg(struct kiocb *iocb, struct sock *sk, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | struct msghdr *msg, size_t len); |
Changli Gao | 53d3176 | 2010-07-10 20:41:06 +0000 | [diff] [blame] | 172 | extern void udp_flush_pending_frames(struct sock *sk); |
| 173 | extern int udp_rcv(struct sk_buff *skb); |
| 174 | extern int udp_ioctl(struct sock *sk, int cmd, unsigned long arg); |
| 175 | extern int udp_disconnect(struct sock *sk, int flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | extern unsigned int udp_poll(struct file *file, struct socket *sock, |
| 177 | poll_table *wait); |
Changli Gao | 53d3176 | 2010-07-10 20:41:06 +0000 | [diff] [blame] | 178 | extern int udp_lib_getsockopt(struct sock *sk, int level, int optname, |
| 179 | char __user *optval, int __user *optlen); |
| 180 | extern int udp_lib_setsockopt(struct sock *sk, int level, int optname, |
| 181 | char __user *optval, unsigned int optlen, |
| 182 | int (*push_pending_frames)(struct sock *)); |
KOVACS Krisztian | bcd4130 | 2008-10-01 07:48:10 -0700 | [diff] [blame] | 183 | extern struct sock *udp4_lib_lookup(struct net *net, __be32 saddr, __be16 sport, |
| 184 | __be32 daddr, __be16 dport, |
| 185 | int dif); |
Balazs Scheidler | aa976fc | 2010-10-21 16:05:41 +0200 | [diff] [blame^] | 186 | extern struct sock *udp6_lib_lookup(struct net *net, const struct in6_addr *saddr, __be16 sport, |
| 187 | const struct in6_addr *daddr, __be16 dport, |
| 188 | int dif); |
KOVACS Krisztian | bcd4130 | 2008-10-01 07:48:10 -0700 | [diff] [blame] | 189 | |
Gerrit Renker | ba4e58e | 2006-11-27 11:10:57 -0800 | [diff] [blame] | 190 | /* |
| 191 | * SNMP statistics for UDP and UDP-Lite |
| 192 | */ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 193 | #define UDP_INC_STATS_USER(net, field, is_udplite) do { \ |
Pavel Emelyanov | 386019d | 2008-07-18 04:03:45 -0700 | [diff] [blame] | 194 | if (is_udplite) SNMP_INC_STATS_USER((net)->mib.udplite_statistics, field); \ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 195 | else SNMP_INC_STATS_USER((net)->mib.udp_statistics, field); } while(0) |
| 196 | #define UDP_INC_STATS_BH(net, field, is_udplite) do { \ |
Pavel Emelyanov | 386019d | 2008-07-18 04:03:45 -0700 | [diff] [blame] | 197 | if (is_udplite) SNMP_INC_STATS_BH((net)->mib.udplite_statistics, field); \ |
Pavel Emelyanov | 2f275f9 | 2008-07-18 04:03:27 -0700 | [diff] [blame] | 198 | else SNMP_INC_STATS_BH((net)->mib.udp_statistics, field); } while(0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | |
Denis V. Lunev | 0c7ed67 | 2008-10-07 14:49:36 -0700 | [diff] [blame] | 200 | #define UDP6_INC_STATS_BH(net, field, is_udplite) do { \ |
Denis V. Lunev | be713a4 | 2008-10-07 14:50:06 -0700 | [diff] [blame] | 201 | 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] | 202 | else SNMP_INC_STATS_BH((net)->mib.udp_stats_in6, field); \ |
| 203 | } while(0) |
Denis V. Lunev | be713a4 | 2008-10-07 14:50:06 -0700 | [diff] [blame] | 204 | #define UDP6_INC_STATS_USER(net, field, __lite) do { \ |
| 205 | if (__lite) SNMP_INC_STATS_USER((net)->mib.udplite_stats_in6, field); \ |
| 206 | else SNMP_INC_STATS_USER((net)->mib.udp_stats_in6, field); \ |
Denis V. Lunev | 0c7ed67 | 2008-10-07 14:49:36 -0700 | [diff] [blame] | 207 | } while(0) |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 208 | |
| 209 | #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) |
| 210 | #define UDPX_INC_STATS_BH(sk, field) \ |
| 211 | do { \ |
| 212 | if ((sk)->sk_family == AF_INET) \ |
Pavel Emelyanov | 0283328 | 2008-07-05 21:18:48 -0700 | [diff] [blame] | 213 | UDP_INC_STATS_BH(sock_net(sk), field, 0); \ |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 214 | else \ |
Pavel Emelyanov | ef28d1a | 2008-07-05 21:19:40 -0700 | [diff] [blame] | 215 | UDP6_INC_STATS_BH(sock_net(sk), field, 0); \ |
Herbert Xu | 1781f7f | 2007-12-11 11:30:32 -0800 | [diff] [blame] | 216 | } while (0); |
| 217 | #else |
Pavel Emelyanov | 0283328 | 2008-07-05 21:18:48 -0700 | [diff] [blame] | 218 | #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] | 219 | #endif |
| 220 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | /* /proc */ |
| 222 | struct udp_seq_afinfo { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | char *name; |
| 224 | sa_family_t family; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 225 | struct udp_table *udp_table; |
Denis V. Lunev | 3ba9441 | 2008-03-28 18:25:32 -0700 | [diff] [blame] | 226 | struct file_operations seq_fops; |
Denis V. Lunev | dda6192 | 2008-03-28 18:24:26 -0700 | [diff] [blame] | 227 | struct seq_operations seq_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | }; |
| 229 | |
| 230 | struct udp_iter_state { |
Denis V. Lunev | 6f191ef | 2008-03-28 18:23:33 -0700 | [diff] [blame] | 231 | struct seq_net_private p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | sa_family_t family; |
| 233 | int bucket; |
Eric Dumazet | 645ca70 | 2008-10-29 01:41:45 -0700 | [diff] [blame] | 234 | struct udp_table *udp_table; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | }; |
| 236 | |
Arnaldo Carvalho de Melo | 2038073 | 2005-08-16 02:18:02 -0300 | [diff] [blame] | 237 | #ifdef CONFIG_PROC_FS |
Daniel Lezcano | 0c96d8c | 2008-03-21 04:14:17 -0700 | [diff] [blame] | 238 | extern int udp_proc_register(struct net *net, struct udp_seq_afinfo *afinfo); |
| 239 | 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] | 240 | |
Changli Gao | 53d3176 | 2010-07-10 20:41:06 +0000 | [diff] [blame] | 241 | extern int udp4_proc_init(void); |
Arnaldo Carvalho de Melo | 2038073 | 2005-08-16 02:18:02 -0300 | [diff] [blame] | 242 | extern void udp4_proc_exit(void); |
| 243 | #endif |
Hideo Aoki | 95766ff | 2007-12-31 00:29:24 -0800 | [diff] [blame] | 244 | |
| 245 | extern void udp_init(void); |
Sridhar Samudrala | d7ca4cc | 2009-07-09 08:09:47 +0000 | [diff] [blame] | 246 | |
| 247 | extern int udp4_ufo_send_check(struct sk_buff *skb); |
| 248 | 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] | 249 | #endif /* _UDP_H */ |