1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#ifndef _IP_H
23#define _IP_H
24
25#include <linux/types.h>
26#include <linux/ip.h>
27#include <linux/in.h>
28#include <linux/skbuff.h>
29#include <linux/jhash.h>
30
31#include <net/inet_sock.h>
32#include <net/route.h>
33#include <net/snmp.h>
34#include <net/flow.h>
35#include <net/flow_dissector.h>
36#include <net/netns/hash.h>
37
38#define IPV4_MAX_PMTU 65535U
39#define IPV4_MIN_MTU 68
40
41struct sock;
42
43struct inet_skb_parm {
44 int iif;
45 struct ip_options opt;
46 u16 flags;
47
48#define IPSKB_FORWARDED BIT(0)
49#define IPSKB_XFRM_TUNNEL_SIZE BIT(1)
50#define IPSKB_XFRM_TRANSFORMED BIT(2)
51#define IPSKB_FRAG_COMPLETE BIT(3)
52#define IPSKB_REROUTED BIT(4)
53#define IPSKB_DOREDIRECT BIT(5)
54#define IPSKB_FRAG_PMTU BIT(6)
55#define IPSKB_L3SLAVE BIT(7)
56
57 u16 frag_max_size;
58};
59
60static inline bool ipv4_l3mdev_skb(u16 flags)
61{
62 return !!(flags & IPSKB_L3SLAVE);
63}
64
65static inline unsigned int ip_hdrlen(const struct sk_buff *skb)
66{
67 return ip_hdr(skb)->ihl * 4;
68}
69
70struct ipcm_cookie {
71 struct sockcm_cookie sockc;
72 __be32 addr;
73 int oif;
74 struct ip_options_rcu *opt;
75 __u8 tx_flags;
76 __u8 ttl;
77 __s16 tos;
78 char priority;
79 __u16 gso_size;
80};
81
82#define IPCB(skb) ((struct inet_skb_parm*)((skb)->cb))
83#define PKTINFO_SKB_CB(skb) ((struct in_pktinfo *)((skb)->cb))
84
85
86static inline int inet_sdif(struct sk_buff *skb)
87{
88#if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
89 if (skb && ipv4_l3mdev_skb(IPCB(skb)->flags))
90 return IPCB(skb)->iif;
91#endif
92 return 0;
93}
94
95
96
97
98
99
100
101
102
103
104
105
106struct ip_ra_chain {
107 struct ip_ra_chain __rcu *next;
108 struct sock *sk;
109 union {
110 void (*destructor)(struct sock *);
111 struct sock *saved_sk;
112 };
113 struct rcu_head rcu;
114};
115
116
117#define IP_CE 0x8000
118#define IP_DF 0x4000
119#define IP_MF 0x2000
120#define IP_OFFSET 0x1FFF
121
122#define IP_FRAG_TIME (30 * HZ)
123
124struct msghdr;
125struct net_device;
126struct packet_type;
127struct rtable;
128struct sockaddr;
129
130int igmp_mc_init(void);
131
132
133
134
135
136int ip_build_and_send_pkt(struct sk_buff *skb, const struct sock *sk,
137 __be32 saddr, __be32 daddr,
138 struct ip_options_rcu *opt);
139int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt,
140 struct net_device *orig_dev);
141int ip_local_deliver(struct sk_buff *skb);
142int ip_mr_input(struct sk_buff *skb);
143int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb);
144int ip_mc_output(struct net *net, struct sock *sk, struct sk_buff *skb);
145int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
146 int (*output)(struct net *, struct sock *, struct sk_buff *));
147void ip_send_check(struct iphdr *ip);
148int __ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);
149int ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb);
150
151int __ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
152 __u8 tos);
153void ip_init(void);
154int ip_append_data(struct sock *sk, struct flowi4 *fl4,
155 int getfrag(void *from, char *to, int offset, int len,
156 int odd, struct sk_buff *skb),
157 void *from, int len, int protolen,
158 struct ipcm_cookie *ipc,
159 struct rtable **rt,
160 unsigned int flags);
161int ip_generic_getfrag(void *from, char *to, int offset, int len, int odd,
162 struct sk_buff *skb);
163ssize_t ip_append_page(struct sock *sk, struct flowi4 *fl4, struct page *page,
164 int offset, size_t size, int flags);
165struct sk_buff *__ip_make_skb(struct sock *sk, struct flowi4 *fl4,
166 struct sk_buff_head *queue,
167 struct inet_cork *cork);
168int ip_send_skb(struct net *net, struct sk_buff *skb);
169int ip_push_pending_frames(struct sock *sk, struct flowi4 *fl4);
170void ip_flush_pending_frames(struct sock *sk);
171struct sk_buff *ip_make_skb(struct sock *sk, struct flowi4 *fl4,
172 int getfrag(void *from, char *to, int offset,
173 int len, int odd, struct sk_buff *skb),
174 void *from, int length, int transhdrlen,
175 struct ipcm_cookie *ipc, struct rtable **rtp,
176 struct inet_cork *cork, unsigned int flags);
177
178static inline int ip_queue_xmit(struct sock *sk, struct sk_buff *skb,
179 struct flowi *fl)
180{
181 return __ip_queue_xmit(sk, skb, fl, inet_sk(sk)->tos);
182}
183
184static inline struct sk_buff *ip_finish_skb(struct sock *sk, struct flowi4 *fl4)
185{
186 return __ip_make_skb(sk, fl4, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
187}
188
189static inline __u8 get_rttos(struct ipcm_cookie* ipc, struct inet_sock *inet)
190{
191 return (ipc->tos != -1) ? RT_TOS(ipc->tos) : RT_TOS(inet->tos);
192}
193
194static inline __u8 get_rtconn_flags(struct ipcm_cookie* ipc, struct sock* sk)
195{
196 return (ipc->tos != -1) ? RT_CONN_FLAGS_TOS(sk, ipc->tos) : RT_CONN_FLAGS(sk);
197}
198
199
200int __ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
201int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
202
203void ip4_datagram_release_cb(struct sock *sk);
204
205struct ip_reply_arg {
206 struct kvec iov[1];
207 int flags;
208 __wsum csum;
209 int csumoffset;
210
211 int bound_dev_if;
212 u8 tos;
213 kuid_t uid;
214};
215
216#define IP_REPLY_ARG_NOSRCCHECK 1
217
218static inline __u8 ip_reply_arg_flowi_flags(const struct ip_reply_arg *arg)
219{
220 return (arg->flags & IP_REPLY_ARG_NOSRCCHECK) ? FLOWI_FLAG_ANYSRC : 0;
221}
222
223void ip_send_unicast_reply(struct sock *sk, struct sk_buff *skb,
224 const struct ip_options *sopt,
225 __be32 daddr, __be32 saddr,
226 const struct ip_reply_arg *arg,
227 unsigned int len);
228
229#define IP_INC_STATS(net, field) SNMP_INC_STATS64((net)->mib.ip_statistics, field)
230#define __IP_INC_STATS(net, field) __SNMP_INC_STATS64((net)->mib.ip_statistics, field)
231#define IP_ADD_STATS(net, field, val) SNMP_ADD_STATS64((net)->mib.ip_statistics, field, val)
232#define __IP_ADD_STATS(net, field, val) __SNMP_ADD_STATS64((net)->mib.ip_statistics, field, val)
233#define IP_UPD_PO_STATS(net, field, val) SNMP_UPD_PO_STATS64((net)->mib.ip_statistics, field, val)
234#define __IP_UPD_PO_STATS(net, field, val) __SNMP_UPD_PO_STATS64((net)->mib.ip_statistics, field, val)
235#define NET_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.net_statistics, field)
236#define __NET_INC_STATS(net, field) __SNMP_INC_STATS((net)->mib.net_statistics, field)
237#define NET_ADD_STATS(net, field, adnd) SNMP_ADD_STATS((net)->mib.net_statistics, field, adnd)
238#define __NET_ADD_STATS(net, field, adnd) __SNMP_ADD_STATS((net)->mib.net_statistics, field, adnd)
239
240u64 snmp_get_cpu_field(void __percpu *mib, int cpu, int offct);
241unsigned long snmp_fold_field(void __percpu *mib, int offt);
242#if BITS_PER_LONG==32
243u64 snmp_get_cpu_field64(void __percpu *mib, int cpu, int offct,
244 size_t syncp_offset);
245u64 snmp_fold_field64(void __percpu *mib, int offt, size_t sync_off);
246#else
247static inline u64 snmp_get_cpu_field64(void __percpu *mib, int cpu, int offct,
248 size_t syncp_offset)
249{
250 return snmp_get_cpu_field(mib, cpu, offct);
251
252}
253
254static inline u64 snmp_fold_field64(void __percpu *mib, int offt, size_t syncp_off)
255{
256 return snmp_fold_field(mib, offt);
257}
258#endif
259
260#define snmp_get_cpu_field64_batch(buff64, stats_list, mib_statistic, offset) \
261{ \
262 int i, c; \
263 for_each_possible_cpu(c) { \
264 for (i = 0; stats_list[i].name; i++) \
265 buff64[i] += snmp_get_cpu_field64( \
266 mib_statistic, \
267 c, stats_list[i].entry, \
268 offset); \
269 } \
270}
271
272#define snmp_get_cpu_field_batch(buff, stats_list, mib_statistic) \
273{ \
274 int i, c; \
275 for_each_possible_cpu(c) { \
276 for (i = 0; stats_list[i].name; i++) \
277 buff[i] += snmp_get_cpu_field( \
278 mib_statistic, \
279 c, stats_list[i].entry); \
280 } \
281}
282
283void inet_get_local_port_range(struct net *net, int *low, int *high);
284
285#ifdef CONFIG_SYSCTL
286static inline int inet_is_local_reserved_port(struct net *net, int port)
287{
288 if (!net->ipv4.sysctl_local_reserved_ports)
289 return 0;
290 return test_bit(port, net->ipv4.sysctl_local_reserved_ports);
291}
292
293static inline bool sysctl_dev_name_is_allowed(const char *name)
294{
295 return strcmp(name, "default") != 0 && strcmp(name, "all") != 0;
296}
297
298static inline int inet_prot_sock(struct net *net)
299{
300 return net->ipv4.sysctl_ip_prot_sock;
301}
302
303#else
304static inline int inet_is_local_reserved_port(struct net *net, int port)
305{
306 return 0;
307}
308
309static inline int inet_prot_sock(struct net *net)
310{
311 return PROT_SOCK;
312}
313#endif
314
315__be32 inet_current_timestamp(void);
316
317
318extern int inet_peer_threshold;
319extern int inet_peer_minttl;
320extern int inet_peer_maxttl;
321
322void ipfrag_init(void);
323
324void ip_static_sysctl_init(void);
325
326#define IP4_REPLY_MARK(net, mark) \
327 ((net)->ipv4.sysctl_fwmark_reflect ? (mark) : 0)
328
329static inline bool ip_is_fragment(const struct iphdr *iph)
330{
331 return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0;
332}
333
334#ifdef CONFIG_INET
335#include <net/dst.h>
336
337
338
339static inline
340int ip_decrease_ttl(struct iphdr *iph)
341{
342 u32 check = (__force u32)iph->check;
343 check += (__force u32)htons(0x0100);
344 iph->check = (__force __sum16)(check + (check>=0xFFFF));
345 return --iph->ttl;
346}
347
348static inline int ip_mtu_locked(const struct dst_entry *dst)
349{
350 const struct rtable *rt = (const struct rtable *)dst;
351
352 return rt->rt_mtu_locked || dst_metric_locked(dst, RTAX_MTU);
353}
354
355static inline
356int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst)
357{
358 u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc);
359
360 return pmtudisc == IP_PMTUDISC_DO ||
361 (pmtudisc == IP_PMTUDISC_WANT &&
362 !ip_mtu_locked(dst));
363}
364
365static inline bool ip_sk_accept_pmtu(const struct sock *sk)
366{
367 return inet_sk(sk)->pmtudisc != IP_PMTUDISC_INTERFACE &&
368 inet_sk(sk)->pmtudisc != IP_PMTUDISC_OMIT;
369}
370
371static inline bool ip_sk_use_pmtu(const struct sock *sk)
372{
373 return inet_sk(sk)->pmtudisc < IP_PMTUDISC_PROBE;
374}
375
376static inline bool ip_sk_ignore_df(const struct sock *sk)
377{
378 return inet_sk(sk)->pmtudisc < IP_PMTUDISC_DO ||
379 inet_sk(sk)->pmtudisc == IP_PMTUDISC_OMIT;
380}
381
382static inline unsigned int ip_dst_mtu_maybe_forward(const struct dst_entry *dst,
383 bool forwarding)
384{
385 struct net *net = dev_net(dst->dev);
386
387 if (net->ipv4.sysctl_ip_fwd_use_pmtu ||
388 ip_mtu_locked(dst) ||
389 !forwarding)
390 return dst_mtu(dst);
391
392 return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU);
393}
394
395static inline unsigned int ip_skb_dst_mtu(struct sock *sk,
396 const struct sk_buff *skb)
397{
398 if (!sk || !sk_fullsock(sk) || ip_sk_use_pmtu(sk)) {
399 bool forwarding = IPCB(skb)->flags & IPSKB_FORWARDED;
400
401 return ip_dst_mtu_maybe_forward(skb_dst(skb), forwarding);
402 }
403
404 return min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU);
405}
406
407int ip_metrics_convert(struct net *net, struct nlattr *fc_mx, int fc_mx_len,
408 u32 *metrics);
409
410u32 ip_idents_reserve(u32 hash, int segs);
411void __ip_select_ident(struct net *net, struct iphdr *iph, int segs);
412
413static inline void ip_select_ident_segs(struct net *net, struct sk_buff *skb,
414 struct sock *sk, int segs)
415{
416 struct iphdr *iph = ip_hdr(skb);
417
418 if ((iph->frag_off & htons(IP_DF)) && !skb->ignore_df) {
419
420
421
422
423
424 if (sk && inet_sk(sk)->inet_daddr) {
425 iph->id = htons(inet_sk(sk)->inet_id);
426 inet_sk(sk)->inet_id += segs;
427 } else {
428 iph->id = 0;
429 }
430 } else {
431 __ip_select_ident(net, iph, segs);
432 }
433}
434
435static inline void ip_select_ident(struct net *net, struct sk_buff *skb,
436 struct sock *sk)
437{
438 ip_select_ident_segs(net, skb, sk, 1);
439}
440
441static inline __wsum inet_compute_pseudo(struct sk_buff *skb, int proto)
442{
443 return csum_tcpudp_nofold(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
444 skb->len, proto, 0);
445}
446
447
448
449
450
451static inline void iph_to_flow_copy_v4addrs(struct flow_keys *flow,
452 const struct iphdr *iph)
453{
454 BUILD_BUG_ON(offsetof(typeof(flow->addrs), v4addrs.dst) !=
455 offsetof(typeof(flow->addrs), v4addrs.src) +
456 sizeof(flow->addrs.v4addrs.src));
457 memcpy(&flow->addrs.v4addrs, &iph->saddr, sizeof(flow->addrs.v4addrs));
458 flow->control.addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
459}
460
461static inline __wsum inet_gro_compute_pseudo(struct sk_buff *skb, int proto)
462{
463 const struct iphdr *iph = skb_gro_network_header(skb);
464
465 return csum_tcpudp_nofold(iph->saddr, iph->daddr,
466 skb_gro_len(skb), proto, 0);
467}
468
469
470
471
472
473static inline void ip_eth_mc_map(__be32 naddr, char *buf)
474{
475 __u32 addr=ntohl(naddr);
476 buf[0]=0x01;
477 buf[1]=0x00;
478 buf[2]=0x5e;
479 buf[5]=addr&0xFF;
480 addr>>=8;
481 buf[4]=addr&0xFF;
482 addr>>=8;
483 buf[3]=addr&0x7F;
484}
485
486
487
488
489
490
491static inline void ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
492{
493 __u32 addr;
494 unsigned char scope = broadcast[5] & 0xF;
495
496 buf[0] = 0;
497 buf[1] = 0xff;
498 buf[2] = 0xff;
499 buf[3] = 0xff;
500 addr = ntohl(naddr);
501 buf[4] = 0xff;
502 buf[5] = 0x10 | scope;
503 buf[6] = 0x40;
504 buf[7] = 0x1b;
505 buf[8] = broadcast[8];
506 buf[9] = broadcast[9];
507 buf[10] = 0;
508 buf[11] = 0;
509 buf[12] = 0;
510 buf[13] = 0;
511 buf[14] = 0;
512 buf[15] = 0;
513 buf[19] = addr & 0xff;
514 addr >>= 8;
515 buf[18] = addr & 0xff;
516 addr >>= 8;
517 buf[17] = addr & 0xff;
518 addr >>= 8;
519 buf[16] = addr & 0x0f;
520}
521
522static inline void ip_ipgre_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
523{
524 if ((broadcast[0] | broadcast[1] | broadcast[2] | broadcast[3]) != 0)
525 memcpy(buf, broadcast, 4);
526 else
527 memcpy(buf, &naddr, sizeof(naddr));
528}
529
530#if IS_ENABLED(CONFIG_IPV6)
531#include <linux/ipv6.h>
532#endif
533
534static __inline__ void inet_reset_saddr(struct sock *sk)
535{
536 inet_sk(sk)->inet_rcv_saddr = inet_sk(sk)->inet_saddr = 0;
537#if IS_ENABLED(CONFIG_IPV6)
538 if (sk->sk_family == PF_INET6) {
539 struct ipv6_pinfo *np = inet6_sk(sk);
540
541 memset(&np->saddr, 0, sizeof(np->saddr));
542 memset(&sk->sk_v6_rcv_saddr, 0, sizeof(sk->sk_v6_rcv_saddr));
543 }
544#endif
545}
546
547#endif
548
549static inline unsigned int ipv4_addr_hash(__be32 ip)
550{
551 return (__force unsigned int) ip;
552}
553
554static inline u32 ipv4_portaddr_hash(const struct net *net,
555 __be32 saddr,
556 unsigned int port)
557{
558 return jhash_1word((__force u32)saddr, net_hash_mix(net)) ^ port;
559}
560
561bool ip_call_ra_chain(struct sk_buff *skb);
562
563
564
565
566
567enum ip_defrag_users {
568 IP_DEFRAG_LOCAL_DELIVER,
569 IP_DEFRAG_CALL_RA_CHAIN,
570 IP_DEFRAG_CONNTRACK_IN,
571 __IP_DEFRAG_CONNTRACK_IN_END = IP_DEFRAG_CONNTRACK_IN + USHRT_MAX,
572 IP_DEFRAG_CONNTRACK_OUT,
573 __IP_DEFRAG_CONNTRACK_OUT_END = IP_DEFRAG_CONNTRACK_OUT + USHRT_MAX,
574 IP_DEFRAG_CONNTRACK_BRIDGE_IN,
575 __IP_DEFRAG_CONNTRACK_BRIDGE_IN = IP_DEFRAG_CONNTRACK_BRIDGE_IN + USHRT_MAX,
576 IP_DEFRAG_VS_IN,
577 IP_DEFRAG_VS_OUT,
578 IP_DEFRAG_VS_FWD,
579 IP_DEFRAG_AF_PACKET,
580 IP_DEFRAG_MACVLAN,
581};
582
583
584
585
586static inline bool ip_defrag_user_in_between(u32 user,
587 enum ip_defrag_users lower_bond,
588 enum ip_defrag_users upper_bond)
589{
590 return user >= lower_bond && user <= upper_bond;
591}
592
593int ip_defrag(struct net *net, struct sk_buff *skb, u32 user);
594#ifdef CONFIG_INET
595struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user);
596#else
597static inline struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user)
598{
599 return skb;
600}
601#endif
602
603
604
605
606
607int ip_forward(struct sk_buff *skb);
608
609
610
611
612
613void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
614 __be32 daddr, struct rtable *rt, int is_frag);
615
616int __ip_options_echo(struct net *net, struct ip_options *dopt,
617 struct sk_buff *skb, const struct ip_options *sopt);
618static inline int ip_options_echo(struct net *net, struct ip_options *dopt,
619 struct sk_buff *skb)
620{
621 return __ip_options_echo(net, dopt, skb, &IPCB(skb)->opt);
622}
623
624void ip_options_fragment(struct sk_buff *skb);
625int ip_options_compile(struct net *net, struct ip_options *opt,
626 struct sk_buff *skb);
627int ip_options_get(struct net *net, struct ip_options_rcu **optp,
628 unsigned char *data, int optlen);
629int ip_options_get_from_user(struct net *net, struct ip_options_rcu **optp,
630 unsigned char __user *data, int optlen);
631void ip_options_undo(struct ip_options *opt);
632void ip_forward_options(struct sk_buff *skb);
633int ip_options_rcv_srr(struct sk_buff *skb);
634
635
636
637
638
639void ipv4_pktinfo_prepare(const struct sock *sk, struct sk_buff *skb);
640void ip_cmsg_recv_offset(struct msghdr *msg, struct sock *sk,
641 struct sk_buff *skb, int tlen, int offset);
642int ip_cmsg_send(struct sock *sk, struct msghdr *msg,
643 struct ipcm_cookie *ipc, bool allow_ipv6);
644int ip_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
645 unsigned int optlen);
646int ip_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
647 int __user *optlen);
648int compat_ip_setsockopt(struct sock *sk, int level, int optname,
649 char __user *optval, unsigned int optlen);
650int compat_ip_getsockopt(struct sock *sk, int level, int optname,
651 char __user *optval, int __user *optlen);
652int ip_ra_control(struct sock *sk, unsigned char on,
653 void (*destructor)(struct sock *));
654
655int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len);
656void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, __be16 port,
657 u32 info, u8 *payload);
658void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport,
659 u32 info);
660
661static inline void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
662{
663 ip_cmsg_recv_offset(msg, skb->sk, skb, 0, 0);
664}
665
666bool icmp_global_allow(void);
667extern int sysctl_icmp_msgs_per_sec;
668extern int sysctl_icmp_msgs_burst;
669
670#ifdef CONFIG_PROC_FS
671int ip_misc_proc_init(void);
672#endif
673
674int rtm_getroute_parse_ip_proto(struct nlattr *attr, u8 *ip_proto, u8 family,
675 struct netlink_ext_ack *extack);
676
677#endif
678
