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 unsigned int hash2_nulladdr
);
209 u32
udp_flow_hashrnd(void);
211 static inline __be16
udp_flow_src_port(struct net
*net
, struct sk_buff
*skb
,
212 int min
, int max
, bool use_eth
)
217 /* Use default range */
218 inet_get_local_port_range(net
, &min
, &max
);
221 hash
= skb_get_hash(skb
);
222 if (unlikely(!hash
)) {
224 /* Can't find a normal hash, caller has indicated an
225 * Ethernet packet so use that to compute a hash.
227 hash
= jhash(skb
->data
, 2 * ETH_ALEN
,
228 (__force u32
) skb
->protocol
);
230 /* Can't derive any sort of hash for the packet, set
231 * to some consistent random value.
233 hash
= udp_flow_hashrnd();
237 /* Since this is being sent on the wire obfuscate hash a bit
238 * to minimize possbility that any useful information to an
239 * attacker is leaked. Only upper 16 bits are relevant in the
240 * computation for 16 bit port value.
244 return htons((((u64
) hash
* (max
- min
)) >> 32) + min
);
248 void udp_destruct_sock(struct sock
*sk
);
249 void skb_consume_udp(struct sock
*sk
, struct sk_buff
*skb
, int len
);
250 int __udp_enqueue_schedule_skb(struct sock
*sk
, struct sk_buff
*skb
);
251 void udp_skb_destructor(struct sock
*sk
, struct sk_buff
*skb
);
252 struct sk_buff
*__skb_recv_udp(struct sock
*sk
, unsigned int flags
,
253 int noblock
, int *peeked
, int *off
, int *err
);
254 static inline struct sk_buff
*skb_recv_udp(struct sock
*sk
, unsigned int flags
,
255 int noblock
, int *err
)
259 return __skb_recv_udp(sk
, flags
, noblock
, &peeked
, &off
, err
);
262 int udp_v4_early_demux(struct sk_buff
*skb
);
263 bool udp_sk_rx_dst_set(struct sock
*sk
, struct dst_entry
*dst
);
264 int udp_get_port(struct sock
*sk
, unsigned short snum
,
265 int (*saddr_cmp
)(const struct sock
*,
266 const struct sock
*));
267 void udp_err(struct sk_buff
*, u32
);
268 int udp_abort(struct sock
*sk
, int err
);
269 int udp_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
);
270 int udp_push_pending_frames(struct sock
*sk
);
271 void udp_flush_pending_frames(struct sock
*sk
);
272 void udp4_hwcsum(struct sk_buff
*skb
, __be32 src
, __be32 dst
);
273 int udp_rcv(struct sk_buff
*skb
);
274 int udp_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
);
275 int udp_init_sock(struct sock
*sk
);
276 int __udp_disconnect(struct sock
*sk
, int flags
);
277 int udp_disconnect(struct sock
*sk
, int flags
);
278 __poll_t
udp_poll(struct file
*file
, struct socket
*sock
, poll_table
*wait
);
279 struct sk_buff
*skb_udp_tunnel_segment(struct sk_buff
*skb
,
280 netdev_features_t features
,
282 int udp_lib_getsockopt(struct sock
*sk
, int level
, int optname
,
283 char __user
*optval
, int __user
*optlen
);
284 int udp_lib_setsockopt(struct sock
*sk
, int level
, int optname
,
285 char __user
*optval
, unsigned int optlen
,
286 int (*push_pending_frames
)(struct sock
*));
287 struct sock
*udp4_lib_lookup(struct net
*net
, __be32 saddr
, __be16 sport
,
288 __be32 daddr
, __be16 dport
, int dif
);
289 struct sock
*__udp4_lib_lookup(struct net
*net
, __be32 saddr
, __be16 sport
,
290 __be32 daddr
, __be16 dport
, int dif
, int sdif
,
291 struct udp_table
*tbl
, struct sk_buff
*skb
);
292 struct sock
*udp4_lib_lookup_skb(struct sk_buff
*skb
,
293 __be16 sport
, __be16 dport
);
294 struct sock
*udp6_lib_lookup(struct net
*net
,
295 const struct in6_addr
*saddr
, __be16 sport
,
296 const struct in6_addr
*daddr
, __be16 dport
,
298 struct sock
*__udp6_lib_lookup(struct net
*net
,
299 const struct in6_addr
*saddr
, __be16 sport
,
300 const struct in6_addr
*daddr
, __be16 dport
,
301 int dif
, int sdif
, struct udp_table
*tbl
,
302 struct sk_buff
*skb
);
303 struct sock
*udp6_lib_lookup_skb(struct sk_buff
*skb
,
304 __be16 sport
, __be16 dport
);
306 /* UDP uses skb->dev_scratch to cache as much information as possible and avoid
307 * possibly multiple cache miss on dequeue()
309 struct udp_dev_scratch
{
310 /* skb->truesize and the stateless bit are embedded in a single field;
311 * do not use a bitfield since the compiler emits better/smaller code
316 #if BITS_PER_LONG == 64
317 /* len and the bit needed to compute skb_csum_unnecessary
318 * will be on cold cache lines at recvmsg time.
319 * skb->len can be stored on 16 bits since the udp header has been
320 * already validated and pulled.
324 bool csum_unnecessary
;
328 static inline struct udp_dev_scratch
*udp_skb_scratch(struct sk_buff
*skb
)
330 return (struct udp_dev_scratch
*)&skb
->dev_scratch
;
333 #if BITS_PER_LONG == 64
334 static inline unsigned int udp_skb_len(struct sk_buff
*skb
)
336 return udp_skb_scratch(skb
)->len
;
339 static inline bool udp_skb_csum_unnecessary(struct sk_buff
*skb
)
341 return udp_skb_scratch(skb
)->csum_unnecessary
;
344 static inline bool udp_skb_is_linear(struct sk_buff
*skb
)
346 return udp_skb_scratch(skb
)->is_linear
;
350 static inline unsigned int udp_skb_len(struct sk_buff
*skb
)
355 static inline bool udp_skb_csum_unnecessary(struct sk_buff
*skb
)
357 return skb_csum_unnecessary(skb
);
360 static inline bool udp_skb_is_linear(struct sk_buff
*skb
)
362 return !skb_is_nonlinear(skb
);
366 static inline int copy_linear_skb(struct sk_buff
*skb
, int len
, int off
,
371 n
= copy_to_iter(skb
->data
+ off
, len
, to
);
375 iov_iter_revert(to
, n
);
380 * SNMP statistics for UDP and UDP-Lite
382 #define UDP_INC_STATS(net, field, is_udplite) do { \
383 if (is_udplite) SNMP_INC_STATS((net)->mib.udplite_statistics, field); \
384 else SNMP_INC_STATS((net)->mib.udp_statistics, field); } while(0)
385 #define __UDP_INC_STATS(net, field, is_udplite) do { \
386 if (is_udplite) __SNMP_INC_STATS((net)->mib.udplite_statistics, field); \
387 else __SNMP_INC_STATS((net)->mib.udp_statistics, field); } while(0)
389 #define __UDP6_INC_STATS(net, field, is_udplite) do { \
390 if (is_udplite) __SNMP_INC_STATS((net)->mib.udplite_stats_in6, field);\
391 else __SNMP_INC_STATS((net)->mib.udp_stats_in6, field); \
393 #define UDP6_INC_STATS(net, field, __lite) do { \
394 if (__lite) SNMP_INC_STATS((net)->mib.udplite_stats_in6, field); \
395 else SNMP_INC_STATS((net)->mib.udp_stats_in6, field); \
398 #if IS_ENABLED(CONFIG_IPV6)
399 #define __UDPX_INC_STATS(sk, field) \
401 if ((sk)->sk_family == AF_INET) \
402 __UDP_INC_STATS(sock_net(sk), field, 0); \
404 __UDP6_INC_STATS(sock_net(sk), field, 0); \
407 #define __UDPX_INC_STATS(sk, field) __UDP_INC_STATS(sock_net(sk), field, 0)
411 int udp_seq_open(struct inode
*inode
, struct file
*file
);
413 struct udp_seq_afinfo
{
416 struct udp_table
*udp_table
;
417 const struct file_operations
*seq_fops
;
418 struct seq_operations seq_ops
;
421 struct udp_iter_state
{
422 struct seq_net_private p
;
425 struct udp_table
*udp_table
;
428 #ifdef CONFIG_PROC_FS
429 int udp_proc_register(struct net
*net
, struct udp_seq_afinfo
*afinfo
);
430 void udp_proc_unregister(struct net
*net
, struct udp_seq_afinfo
*afinfo
);
432 int udp4_proc_init(void);
433 void udp4_proc_exit(void);
436 int udpv4_offload_init(void);
440 void udp_encap_enable(void);
441 #if IS_ENABLED(CONFIG_IPV6)
442 void udpv6_encap_enable(void);