]>
git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - net/ipv4/ip_options.c
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 * The options processing module for ip.c
8 * Authors: A.N.Kuznetsov
12 #define pr_fmt(fmt) "IPv4: " fmt
14 #include <linux/capability.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18 #include <linux/uaccess.h>
19 #include <asm/unaligned.h>
20 #include <linux/skbuff.h>
22 #include <linux/icmp.h>
23 #include <linux/netdevice.h>
24 #include <linux/rtnetlink.h>
28 #include <net/route.h>
29 #include <net/cipso_ipv4.h>
30 #include <net/ip_fib.h>
33 * Write options to IP header, record destination address to
34 * source route option, address of outgoing interface
35 * (we should already know it, so that this function is allowed be
36 * called only after routing decision) and timestamp,
37 * if we originate this datagram.
39 * daddr is real destination address, next hop is recorded in IP header.
40 * saddr is address of outgoing interface.
43 void ip_options_build(struct sk_buff
*skb
, struct ip_options
*opt
,
44 __be32 daddr
, struct rtable
*rt
, int is_frag
)
46 unsigned char *iph
= skb_network_header(skb
);
48 memcpy(&(IPCB(skb
)->opt
), opt
, sizeof(struct ip_options
));
49 memcpy(iph
+sizeof(struct iphdr
), opt
->__data
, opt
->optlen
);
50 opt
= &(IPCB(skb
)->opt
);
53 memcpy(iph
+opt
->srr
+iph
[opt
->srr
+1]-4, &daddr
, 4);
57 ip_rt_get_source(iph
+opt
->rr
+iph
[opt
->rr
+2]-5, skb
, rt
);
59 ip_rt_get_source(iph
+opt
->ts
+iph
[opt
->ts
+2]-9, skb
, rt
);
60 if (opt
->ts_needtime
) {
63 midtime
= inet_current_timestamp();
64 memcpy(iph
+opt
->ts
+iph
[opt
->ts
+2]-5, &midtime
, 4);
69 memset(iph
+opt
->rr
, IPOPT_NOP
, iph
[opt
->rr
+1]);
74 memset(iph
+opt
->ts
, IPOPT_NOP
, iph
[opt
->ts
+1]);
76 opt
->ts_needaddr
= opt
->ts_needtime
= 0;
81 * Provided (sopt, skb) points to received options,
82 * build in dopt compiled option set appropriate for answering.
83 * i.e. invert SRR option, copy anothers,
84 * and grab room in RR/TS options.
86 * NOTE: dopt cannot point to skb.
89 int __ip_options_echo(struct net
*net
, struct ip_options
*dopt
,
90 struct sk_buff
*skb
, const struct ip_options
*sopt
)
92 unsigned char *sptr
, *dptr
;
96 memset(dopt
, 0, sizeof(struct ip_options
));
98 if (sopt
->optlen
== 0)
101 sptr
= skb_network_header(skb
);
105 optlen
= sptr
[sopt
->rr
+1];
106 soffset
= sptr
[sopt
->rr
+2];
107 dopt
->rr
= dopt
->optlen
+ sizeof(struct iphdr
);
108 memcpy(dptr
, sptr
+sopt
->rr
, optlen
);
109 if (sopt
->rr_needaddr
&& soffset
<= optlen
) {
110 if (soffset
+ 3 > optlen
)
112 dptr
[2] = soffset
+ 4;
113 dopt
->rr_needaddr
= 1;
116 dopt
->optlen
+= optlen
;
119 optlen
= sptr
[sopt
->ts
+1];
120 soffset
= sptr
[sopt
->ts
+2];
121 dopt
->ts
= dopt
->optlen
+ sizeof(struct iphdr
);
122 memcpy(dptr
, sptr
+sopt
->ts
, optlen
);
123 if (soffset
<= optlen
) {
124 if (sopt
->ts_needaddr
) {
125 if (soffset
+ 3 > optlen
)
127 dopt
->ts_needaddr
= 1;
130 if (sopt
->ts_needtime
) {
131 if (soffset
+ 3 > optlen
)
133 if ((dptr
[3]&0xF) != IPOPT_TS_PRESPEC
) {
134 dopt
->ts_needtime
= 1;
137 dopt
->ts_needtime
= 0;
139 if (soffset
+ 7 <= optlen
) {
142 memcpy(&addr
, dptr
+soffset
-1, 4);
143 if (inet_addr_type(net
, addr
) != RTN_UNICAST
) {
144 dopt
->ts_needtime
= 1;
153 dopt
->optlen
+= optlen
;
156 unsigned char *start
= sptr
+sopt
->srr
;
162 if (soffset
> optlen
)
163 soffset
= optlen
+ 1;
166 memcpy(&faddr
, &start
[soffset
-1], 4);
167 for (soffset
-= 4, doffset
= 4; soffset
> 3; soffset
-= 4, doffset
+= 4)
168 memcpy(&dptr
[doffset
-1], &start
[soffset
-1], 4);
170 * RFC1812 requires to fix illegal source routes.
172 if (memcmp(&ip_hdr(skb
)->saddr
,
173 &start
[soffset
+ 3], 4) == 0)
182 dopt
->srr
= dopt
->optlen
+ sizeof(struct iphdr
);
183 dopt
->optlen
+= doffset
+3;
184 dopt
->is_strictroute
= sopt
->is_strictroute
;
188 optlen
= sptr
[sopt
->cipso
+1];
189 dopt
->cipso
= dopt
->optlen
+sizeof(struct iphdr
);
190 memcpy(dptr
, sptr
+sopt
->cipso
, optlen
);
192 dopt
->optlen
+= optlen
;
194 while (dopt
->optlen
& 3) {
202 * Options "fragmenting", just fill options not
203 * allowed in fragments with NOOPs.
204 * Simple and stupid 8), but the most efficient way.
207 void ip_options_fragment(struct sk_buff
*skb
)
209 unsigned char *optptr
= skb_network_header(skb
) + sizeof(struct iphdr
);
210 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
224 if (optlen
< 2 || optlen
> l
)
226 if (!IPOPT_COPIED(*optptr
))
227 memset(optptr
, IPOPT_NOOP
, optlen
);
233 opt
->rr_needaddr
= 0;
234 opt
->ts_needaddr
= 0;
235 opt
->ts_needtime
= 0;
238 /* helper used by ip_options_compile() to call fib_compute_spec_dst()
241 static void spec_dst_fill(__be32
*spec_dst
, struct sk_buff
*skb
)
243 if (*spec_dst
== htonl(INADDR_ANY
))
244 *spec_dst
= fib_compute_spec_dst(skb
);
248 * Verify options and fill pointers in struct options.
249 * Caller should clear *opt, and set opt->data.
250 * If opt == NULL, then skb->data should point to IP header.
253 int ip_options_compile(struct net
*net
,
254 struct ip_options
*opt
, struct sk_buff
*skb
)
256 __be32 spec_dst
= htonl(INADDR_ANY
);
257 unsigned char *pp_ptr
= NULL
;
258 struct rtable
*rt
= NULL
;
259 unsigned char *optptr
;
264 rt
= skb_rtable(skb
);
265 optptr
= (unsigned char *)&(ip_hdr(skb
)[1]);
267 optptr
= opt
->__data
;
268 iph
= optptr
- sizeof(struct iphdr
);
270 for (l
= opt
->optlen
; l
> 0; ) {
273 for (optptr
++, l
--; l
> 0; optptr
++, l
--) {
274 if (*optptr
!= IPOPT_END
) {
285 if (unlikely(l
< 2)) {
290 if (optlen
< 2 || optlen
> l
) {
305 /* NB: cf RFC-1812 5.2.4.1 */
311 if (optptr
[2] != 4 || optlen
< 7 || ((optlen
-3) & 3)) {
315 memcpy(&opt
->faddr
, &optptr
[3], 4);
317 memmove(&optptr
[3], &optptr
[7], optlen
-7);
319 opt
->is_strictroute
= (optptr
[0] == IPOPT_SSRR
);
320 opt
->srr
= optptr
- iph
;
335 if (optptr
[2] <= optlen
) {
336 if (optptr
[2]+3 > optlen
) {
341 spec_dst_fill(&spec_dst
, skb
);
342 memcpy(&optptr
[optptr
[2]-1], &spec_dst
, 4);
346 opt
->rr_needaddr
= 1;
348 opt
->rr
= optptr
- iph
;
350 case IPOPT_TIMESTAMP
:
363 if (optptr
[2] <= optlen
) {
364 unsigned char *timeptr
= NULL
;
365 if (optptr
[2]+3 > optlen
) {
369 switch (optptr
[3]&0xF) {
370 case IPOPT_TS_TSONLY
:
372 timeptr
= &optptr
[optptr
[2]-1];
373 opt
->ts_needtime
= 1;
376 case IPOPT_TS_TSANDADDR
:
377 if (optptr
[2]+7 > optlen
) {
382 spec_dst_fill(&spec_dst
, skb
);
383 memcpy(&optptr
[optptr
[2]-1], &spec_dst
, 4);
384 timeptr
= &optptr
[optptr
[2]+3];
386 opt
->ts_needaddr
= 1;
387 opt
->ts_needtime
= 1;
390 case IPOPT_TS_PRESPEC
:
391 if (optptr
[2]+7 > optlen
) {
397 memcpy(&addr
, &optptr
[optptr
[2]-1], 4);
398 if (inet_addr_type(net
, addr
) == RTN_UNICAST
)
401 timeptr
= &optptr
[optptr
[2]+3];
403 opt
->ts_needtime
= 1;
407 if (!skb
&& !ns_capable(net
->user_ns
, CAP_NET_RAW
)) {
416 midtime
= inet_current_timestamp();
417 memcpy(timeptr
, &midtime
, 4);
420 } else if ((optptr
[3]&0xF) != IPOPT_TS_PRESPEC
) {
421 unsigned int overflow
= optptr
[3]>>4;
422 if (overflow
== 15) {
427 optptr
[3] = (optptr
[3]&0xF)|((overflow
+1)<<4);
431 opt
->ts
= optptr
- iph
;
438 if (optptr
[2] == 0 && optptr
[3] == 0)
439 opt
->router_alert
= optptr
- iph
;
442 if ((!skb
&& !ns_capable(net
->user_ns
, CAP_NET_RAW
)) || opt
->cipso
) {
446 opt
->cipso
= optptr
- iph
;
447 if (cipso_v4_validate(skb
, &optptr
)) {
455 if (!skb
&& !ns_capable(net
->user_ns
, CAP_NET_RAW
)) {
471 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl((pp_ptr
-iph
)<<24));
475 EXPORT_SYMBOL(ip_options_compile
);
478 * Undo all the changes done by ip_options_compile().
481 void ip_options_undo(struct ip_options
*opt
)
484 unsigned char *optptr
= opt
->__data
+opt
->srr
-sizeof(struct iphdr
);
485 memmove(optptr
+7, optptr
+3, optptr
[1]-7);
486 memcpy(optptr
+3, &opt
->faddr
, 4);
488 if (opt
->rr_needaddr
) {
489 unsigned char *optptr
= opt
->__data
+opt
->rr
-sizeof(struct iphdr
);
491 memset(&optptr
[optptr
[2]-1], 0, 4);
494 unsigned char *optptr
= opt
->__data
+opt
->ts
-sizeof(struct iphdr
);
495 if (opt
->ts_needtime
) {
497 memset(&optptr
[optptr
[2]-1], 0, 4);
498 if ((optptr
[3]&0xF) == IPOPT_TS_PRESPEC
)
501 if (opt
->ts_needaddr
) {
503 memset(&optptr
[optptr
[2]-1], 0, 4);
508 static struct ip_options_rcu
*ip_options_get_alloc(const int optlen
)
510 return kzalloc(sizeof(struct ip_options_rcu
) + ((optlen
+ 3) & ~3),
514 static int ip_options_get_finish(struct net
*net
, struct ip_options_rcu
**optp
,
515 struct ip_options_rcu
*opt
, int optlen
)
518 opt
->opt
.__data
[optlen
++] = IPOPT_END
;
519 opt
->opt
.optlen
= optlen
;
520 if (optlen
&& ip_options_compile(net
, &opt
->opt
, NULL
)) {
529 int ip_options_get_from_user(struct net
*net
, struct ip_options_rcu
**optp
,
530 unsigned char __user
*data
, int optlen
)
532 struct ip_options_rcu
*opt
= ip_options_get_alloc(optlen
);
536 if (optlen
&& copy_from_user(opt
->opt
.__data
, data
, optlen
)) {
540 return ip_options_get_finish(net
, optp
, opt
, optlen
);
543 int ip_options_get(struct net
*net
, struct ip_options_rcu
**optp
,
544 unsigned char *data
, int optlen
)
546 struct ip_options_rcu
*opt
= ip_options_get_alloc(optlen
);
551 memcpy(opt
->opt
.__data
, data
, optlen
);
552 return ip_options_get_finish(net
, optp
, opt
, optlen
);
555 void ip_forward_options(struct sk_buff
*skb
)
557 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
558 unsigned char *optptr
;
559 struct rtable
*rt
= skb_rtable(skb
);
560 unsigned char *raw
= skb_network_header(skb
);
562 if (opt
->rr_needaddr
) {
563 optptr
= (unsigned char *)raw
+ opt
->rr
;
564 ip_rt_get_source(&optptr
[optptr
[2]-5], skb
, rt
);
567 if (opt
->srr_is_hit
) {
568 int srrptr
, srrspace
;
570 optptr
= raw
+ opt
->srr
;
572 for ( srrptr
= optptr
[2], srrspace
= optptr
[1];
576 if (srrptr
+ 3 > srrspace
)
578 if (memcmp(&opt
->nexthop
, &optptr
[srrptr
-1], 4) == 0)
581 if (srrptr
+ 3 <= srrspace
) {
583 ip_hdr(skb
)->daddr
= opt
->nexthop
;
584 ip_rt_get_source(&optptr
[srrptr
-1], skb
, rt
);
585 optptr
[2] = srrptr
+4;
587 net_crit_ratelimited("%s(): Argh! Destination lost!\n",
590 if (opt
->ts_needaddr
) {
591 optptr
= raw
+ opt
->ts
;
592 ip_rt_get_source(&optptr
[optptr
[2]-9], skb
, rt
);
596 if (opt
->is_changed
) {
598 ip_send_check(ip_hdr(skb
));
602 int ip_options_rcv_srr(struct sk_buff
*skb
)
604 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
605 int srrspace
, srrptr
;
607 struct iphdr
*iph
= ip_hdr(skb
);
608 unsigned char *optptr
= skb_network_header(skb
) + opt
->srr
;
609 struct rtable
*rt
= skb_rtable(skb
);
611 unsigned long orefdst
;
617 if (skb
->pkt_type
!= PACKET_HOST
)
619 if (rt
->rt_type
== RTN_UNICAST
) {
620 if (!opt
->is_strictroute
)
622 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl(16<<24));
625 if (rt
->rt_type
!= RTN_LOCAL
)
628 for (srrptr
= optptr
[2], srrspace
= optptr
[1]; srrptr
<= srrspace
; srrptr
+= 4) {
629 if (srrptr
+ 3 > srrspace
) {
630 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl((opt
->srr
+2)<<24));
633 memcpy(&nexthop
, &optptr
[srrptr
-1], 4);
635 orefdst
= skb
->_skb_refdst
;
636 skb_dst_set(skb
, NULL
);
637 err
= ip_route_input(skb
, nexthop
, iph
->saddr
, iph
->tos
, skb
->dev
);
638 rt2
= skb_rtable(skb
);
639 if (err
|| (rt2
->rt_type
!= RTN_UNICAST
&& rt2
->rt_type
!= RTN_LOCAL
)) {
641 skb
->_skb_refdst
= orefdst
;
644 refdst_drop(orefdst
);
645 if (rt2
->rt_type
!= RTN_LOCAL
)
647 /* Superfast 8) loopback forward */
648 iph
->daddr
= nexthop
;
651 if (srrptr
<= srrspace
) {
653 opt
->nexthop
= nexthop
;
658 EXPORT_SYMBOL(ip_options_rcv_srr
);