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.
6 * Definitions for the UDP module.
8 * Version: @(#)udp.h 1.0.2 05/07/93
11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
14 * Alan Cox : Turned on udp checksums. I don't want to
15 * chase 'memory corruption' bugs that aren't!
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.
25 #include <linux/list.h>
26 #include <linux/bug.h>
27 #include <net/inet_sock.h>
31 #include <linux/ipv6.h>
32 #include <linux/seq_file.h>
33 #include <linux/poll.h>
36 * struct udp_skb_cb - UDP(-Lite) private variables
38 * @header: private variables used by IPv4/IPv6
39 * @cscov: checksum coverage length (UDP-Lite only)
40 * @partial_cov: if set indicates partial csum coverage
44 struct inet_skb_parm h4
;
45 #if IS_ENABLED(CONFIG_IPV6)
46 struct inet6_skb_parm h6
;
52 #define UDP_SKB_CB(__skb) ((struct udp_skb_cb *)((__skb)->cb))
55 * struct udp_hslot - UDP hash slot
57 * @head: head of list of sockets
58 * @count: number of sockets in 'head' list
59 * @lock: spinlock protecting changes to head/count
62 struct hlist_head head
;
65 } __attribute__((aligned(2 * sizeof(long))));
68 * struct udp_table - UDP table
70 * @hash: hash table, sockets are hashed on (local port)
71 * @hash2: hash table, sockets are hashed on (local port, local address)
72 * @mask: number of slots in hash tables, minus 1
73 * @log: log2(number of slots in hash table)
76 struct udp_hslot
*hash
;
77 struct udp_hslot
*hash2
;
81 extern struct udp_table udp_table
;
82 void udp_table_init(struct udp_table
*, const char *);
83 static inline struct udp_hslot
*udp_hashslot(struct udp_table
*table
,
84 struct net
*net
, unsigned int num
)
86 return &table
->hash
[udp_hashfn(net
, num
, table
->mask
)];
89 * For secondary hash, net_hash_mix() is performed before calling
90 * udp_hashslot2(), this explains difference with udp_hashslot()
92 static inline struct udp_hslot
*udp_hashslot2(struct udp_table
*table
,
95 return &table
->hash2
[hash
& table
->mask
];
98 extern struct proto udp_prot
;
100 extern atomic_long_t udp_memory_allocated
;
102 /* sysctl variables for udp */
103 extern long sysctl_udp_mem
[3];
104 extern int sysctl_udp_rmem_min
;
105 extern int sysctl_udp_wmem_min
;
110 * Generic checksumming routines for UDP(-Lite) v4 and v6
112 static inline __sum16
__udp_lib_checksum_complete(struct sk_buff
*skb
)
114 return (UDP_SKB_CB(skb
)->cscov
== skb
->len
?
115 __skb_checksum_complete(skb
) :
116 __skb_checksum_complete_head(skb
, UDP_SKB_CB(skb
)->cscov
));
119 static inline int udp_lib_checksum_complete(struct sk_buff
*skb
)
121 return !skb_csum_unnecessary(skb
) &&
122 __udp_lib_checksum_complete(skb
);
126 * udp_csum_outgoing - compute UDPv4/v6 checksum over fragments
127 * @sk: socket we are writing to
128 * @skb: sk_buff containing the filled-in UDP header
129 * (checksum field must be zeroed out)
131 static inline __wsum
udp_csum_outgoing(struct sock
*sk
, struct sk_buff
*skb
)
133 __wsum csum
= csum_partial(skb_transport_header(skb
),
134 sizeof(struct udphdr
), 0);
135 skb_queue_walk(&sk
->sk_write_queue
, skb
) {
136 csum
= csum_add(csum
, skb
->csum
);
141 static inline __wsum
udp_csum(struct sk_buff
*skb
)
143 __wsum csum
= csum_partial(skb_transport_header(skb
),
144 sizeof(struct udphdr
), skb
->csum
);
146 for (skb
= skb_shinfo(skb
)->frag_list
; skb
; skb
= skb
->next
) {
147 csum
= csum_add(csum
, skb
->csum
);
152 static inline __sum16
udp_v4_check(int len
, __be32 saddr
,
153 __be32 daddr
, __wsum base
)
155 return csum_tcpudp_magic(saddr
, daddr
, len
, IPPROTO_UDP
, base
);
158 void udp_set_csum(bool nocheck
, struct sk_buff
*skb
,
159 __be32 saddr
, __be32 daddr
, int len
);
161 static inline void udp_csum_pull_header(struct sk_buff
*skb
)
163 if (!skb
->csum_valid
&& skb
->ip_summed
== CHECKSUM_NONE
)
164 skb
->csum
= csum_partial(skb
->data
, sizeof(struct udphdr
),
166 skb_pull_rcsum(skb
, sizeof(struct udphdr
));
167 UDP_SKB_CB(skb
)->cscov
-= sizeof(struct udphdr
);
170 typedef struct sock
*(*udp_lookup_t
)(struct sk_buff
*skb
, __be16 sport
,
173 struct sk_buff
**udp_gro_receive(struct sk_buff
**head
, struct sk_buff
*skb
,
174 struct udphdr
*uh
, udp_lookup_t lookup
);
175 int udp_gro_complete(struct sk_buff
*skb
, int nhoff
, udp_lookup_t lookup
);
177 static inline struct udphdr
*udp_gro_udphdr(struct sk_buff
*skb
)
180 unsigned int hlen
, off
;
182 off
= skb_gro_offset(skb
);
183 hlen
= off
+ sizeof(*uh
);
184 uh
= skb_gro_header_fast(skb
, off
);
185 if (skb_gro_header_hard(skb
, hlen
))
186 uh
= skb_gro_header_slow(skb
, hlen
, off
);
191 /* hash routines shared between UDPv4/6 and UDP-Litev4/6 */
192 static inline int udp_lib_hash(struct sock
*sk
)
198 void udp_lib_unhash(struct sock
*sk
);
199 void udp_lib_rehash(struct sock
*sk
, u16 new_hash
);
201 static inline void udp_lib_close(struct sock
*sk
, long timeout
)
203 sk_common_release(sk
);
206 int udp_lib_get_port(struct sock
*sk
, unsigned short snum
,
207 int (*)(const struct sock
*, const struct sock
*, bool),
208 unsigned int hash2_nulladdr
);
210 u32
udp_flow_hashrnd(void);
212 static inline __be16
udp_flow_src_port(struct net
*net
, struct sk_buff
*skb
,
213 int min
, int max
, bool use_eth
)
218 /* Use default range */
219 inet_get_local_port_range(net
, &min
, &max
);
222 hash
= skb_get_hash(skb
);
223 if (unlikely(!hash
)) {
225 /* Can't find a normal hash, caller has indicated an
226 * Ethernet packet so use that to compute a hash.
228 hash
= jhash(skb
->data
, 2 * ETH_ALEN
,
229 (__force u32
) skb
->protocol
);
231 /* Can't derive any sort of hash for the packet, set
232 * to some consistent random value.
234 hash
= udp_flow_hashrnd();
238 /* Since this is being sent on the wire obfuscate hash a bit
239 * to minimize possbility that any useful information to an
240 * attacker is leaked. Only upper 16 bits are relevant in the
241 * computation for 16 bit port value.
245 return htons((((u64
) hash
* (max
- min
)) >> 32) + min
);
249 void udp_destruct_sock(struct sock
*sk
);
250 void skb_consume_udp(struct sock
*sk
, struct sk_buff
*skb
, int len
);
251 int __udp_enqueue_schedule_skb(struct sock
*sk
, struct sk_buff
*skb
);
252 void udp_skb_destructor(struct sock
*sk
, struct sk_buff
*skb
);
253 static inline struct sk_buff
*
254 __skb_recv_udp(struct sock
*sk
, unsigned int flags
, int noblock
, int *peeked
,
257 return __skb_recv_datagram(sk
, flags
| (noblock
? MSG_DONTWAIT
: 0),
258 udp_skb_destructor
, peeked
, off
, err
);
260 static inline struct sk_buff
*skb_recv_udp(struct sock
*sk
, unsigned int flags
,
261 int noblock
, int *err
)
265 return __skb_recv_udp(sk
, flags
, noblock
, &peeked
, &off
, err
);
268 void udp_v4_early_demux(struct sk_buff
*skb
);
269 int udp_get_port(struct sock
*sk
, unsigned short snum
,
270 int (*saddr_cmp
)(const struct sock
*,
271 const struct sock
*));
272 void udp_err(struct sk_buff
*, u32
);
273 int udp_abort(struct sock
*sk
, int err
);
274 int udp_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
);
275 int udp_push_pending_frames(struct sock
*sk
);
276 void udp_flush_pending_frames(struct sock
*sk
);
277 void udp4_hwcsum(struct sk_buff
*skb
, __be32 src
, __be32 dst
);
278 int udp_rcv(struct sk_buff
*skb
);
279 int udp_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
);
280 int udp_init_sock(struct sock
*sk
);
281 int __udp_disconnect(struct sock
*sk
, int flags
);
282 int udp_disconnect(struct sock
*sk
, int flags
);
283 unsigned int udp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
);
284 struct sk_buff
*skb_udp_tunnel_segment(struct sk_buff
*skb
,
285 netdev_features_t features
,
287 int udp_lib_getsockopt(struct sock
*sk
, int level
, int optname
,
288 char __user
*optval
, int __user
*optlen
);
289 int udp_lib_setsockopt(struct sock
*sk
, int level
, int optname
,
290 char __user
*optval
, unsigned int optlen
,
291 int (*push_pending_frames
)(struct sock
*));
292 struct sock
*udp4_lib_lookup(struct net
*net
, __be32 saddr
, __be16 sport
,
293 __be32 daddr
, __be16 dport
, int dif
);
294 struct sock
*__udp4_lib_lookup(struct net
*net
, __be32 saddr
, __be16 sport
,
295 __be32 daddr
, __be16 dport
, int dif
,
296 struct udp_table
*tbl
, struct sk_buff
*skb
);
297 struct sock
*udp4_lib_lookup_skb(struct sk_buff
*skb
,
298 __be16 sport
, __be16 dport
);
299 struct sock
*udp6_lib_lookup(struct net
*net
,
300 const struct in6_addr
*saddr
, __be16 sport
,
301 const struct in6_addr
*daddr
, __be16 dport
,
303 struct sock
*__udp6_lib_lookup(struct net
*net
,
304 const struct in6_addr
*saddr
, __be16 sport
,
305 const struct in6_addr
*daddr
, __be16 dport
,
306 int dif
, struct udp_table
*tbl
,
307 struct sk_buff
*skb
);
308 struct sock
*udp6_lib_lookup_skb(struct sk_buff
*skb
,
309 __be16 sport
, __be16 dport
);
312 * SNMP statistics for UDP and UDP-Lite
314 #define UDP_INC_STATS(net, field, is_udplite) do { \
315 if (is_udplite) SNMP_INC_STATS((net)->mib.udplite_statistics, field); \
316 else SNMP_INC_STATS((net)->mib.udp_statistics, field); } while(0)
317 #define __UDP_INC_STATS(net, field, is_udplite) do { \
318 if (is_udplite) __SNMP_INC_STATS((net)->mib.udplite_statistics, field); \
319 else __SNMP_INC_STATS((net)->mib.udp_statistics, field); } while(0)
321 #define __UDP6_INC_STATS(net, field, is_udplite) do { \
322 if (is_udplite) __SNMP_INC_STATS((net)->mib.udplite_stats_in6, field);\
323 else __SNMP_INC_STATS((net)->mib.udp_stats_in6, field); \
325 #define UDP6_INC_STATS(net, field, __lite) do { \
326 if (__lite) SNMP_INC_STATS((net)->mib.udplite_stats_in6, field); \
327 else SNMP_INC_STATS((net)->mib.udp_stats_in6, field); \
330 #if IS_ENABLED(CONFIG_IPV6)
331 #define __UDPX_INC_STATS(sk, field) \
333 if ((sk)->sk_family == AF_INET) \
334 __UDP_INC_STATS(sock_net(sk), field, 0); \
336 __UDP6_INC_STATS(sock_net(sk), field, 0); \
339 #define __UDPX_INC_STATS(sk, field) __UDP_INC_STATS(sock_net(sk), field, 0)
343 int udp_seq_open(struct inode
*inode
, struct file
*file
);
345 struct udp_seq_afinfo
{
348 struct udp_table
*udp_table
;
349 const struct file_operations
*seq_fops
;
350 struct seq_operations seq_ops
;
353 struct udp_iter_state
{
354 struct seq_net_private p
;
357 struct udp_table
*udp_table
;
360 #ifdef CONFIG_PROC_FS
361 int udp_proc_register(struct net
*net
, struct udp_seq_afinfo
*afinfo
);
362 void udp_proc_unregister(struct net
*net
, struct udp_seq_afinfo
*afinfo
);
364 int udp4_proc_init(void);
365 void udp4_proc_exit(void);
368 int udpv4_offload_init(void);
372 void udp_encap_enable(void);
373 #if IS_ENABLED(CONFIG_IPV6)
374 void udpv6_encap_enable(void);