]>
git.proxmox.com Git - mirror_ubuntu-bionic-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 * Version: $Id: ip_options.c,v 1.21 2001/09/01 00:31:50 davem Exp $
10 * Authors: A.N.Kuznetsov
14 #include <linux/capability.h>
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <asm/uaccess.h>
18 #include <linux/skbuff.h>
20 #include <linux/icmp.h>
21 #include <linux/netdevice.h>
22 #include <linux/rtnetlink.h>
26 #include <net/route.h>
27 #include <net/cipso_ipv4.h>
30 * Write options to IP header, record destination address to
31 * source route option, address of outgoing interface
32 * (we should already know it, so that this function is allowed be
33 * called only after routing decision) and timestamp,
34 * if we originate this datagram.
36 * daddr is real destination address, next hop is recorded in IP header.
37 * saddr is address of outgoing interface.
40 void ip_options_build(struct sk_buff
* skb
, struct ip_options
* opt
,
41 __be32 daddr
, struct rtable
*rt
, int is_frag
)
43 unsigned char *iph
= skb_network_header(skb
);
45 memcpy(&(IPCB(skb
)->opt
), opt
, sizeof(struct ip_options
));
46 memcpy(iph
+sizeof(struct iphdr
), opt
->__data
, opt
->optlen
);
47 opt
= &(IPCB(skb
)->opt
);
51 memcpy(iph
+opt
->srr
+iph
[opt
->srr
+1]-4, &daddr
, 4);
55 ip_rt_get_source(iph
+opt
->rr
+iph
[opt
->rr
+2]-5, rt
);
57 ip_rt_get_source(iph
+opt
->ts
+iph
[opt
->ts
+2]-9, rt
);
58 if (opt
->ts_needtime
) {
62 midtime
= htonl((tv
.tv_sec
% 86400) * 1000 + tv
.tv_usec
/ 1000);
63 memcpy(iph
+opt
->ts
+iph
[opt
->ts
+2]-5, &midtime
, 4);
68 memset(iph
+opt
->rr
, IPOPT_NOP
, iph
[opt
->rr
+1]);
73 memset(iph
+opt
->ts
, IPOPT_NOP
, iph
[opt
->ts
+1]);
75 opt
->ts_needaddr
= opt
->ts_needtime
= 0;
80 * Provided (sopt, skb) points to received options,
81 * build in dopt compiled option set appropriate for answering.
82 * i.e. invert SRR option, copy anothers,
83 * and grab room in RR/TS options.
85 * NOTE: dopt cannot point to skb.
88 int ip_options_echo(struct ip_options
* dopt
, struct sk_buff
* skb
)
90 struct ip_options
*sopt
;
91 unsigned char *sptr
, *dptr
;
96 memset(dopt
, 0, sizeof(struct ip_options
));
100 sopt
= &(IPCB(skb
)->opt
);
102 if (sopt
->optlen
== 0) {
107 sptr
= skb_network_header(skb
);
111 daddr
= ((struct rtable
*)skb
->dst
)->rt_spec_dst
;
113 daddr
= ip_hdr(skb
)->daddr
;
116 optlen
= sptr
[sopt
->rr
+1];
117 soffset
= sptr
[sopt
->rr
+2];
118 dopt
->rr
= dopt
->optlen
+ sizeof(struct iphdr
);
119 memcpy(dptr
, sptr
+sopt
->rr
, optlen
);
120 if (sopt
->rr_needaddr
&& soffset
<= optlen
) {
121 if (soffset
+ 3 > optlen
)
123 dptr
[2] = soffset
+ 4;
124 dopt
->rr_needaddr
= 1;
127 dopt
->optlen
+= optlen
;
130 optlen
= sptr
[sopt
->ts
+1];
131 soffset
= sptr
[sopt
->ts
+2];
132 dopt
->ts
= dopt
->optlen
+ sizeof(struct iphdr
);
133 memcpy(dptr
, sptr
+sopt
->ts
, optlen
);
134 if (soffset
<= optlen
) {
135 if (sopt
->ts_needaddr
) {
136 if (soffset
+ 3 > optlen
)
138 dopt
->ts_needaddr
= 1;
141 if (sopt
->ts_needtime
) {
142 if (soffset
+ 3 > optlen
)
144 if ((dptr
[3]&0xF) != IPOPT_TS_PRESPEC
) {
145 dopt
->ts_needtime
= 1;
148 dopt
->ts_needtime
= 0;
150 if (soffset
+ 8 <= optlen
) {
153 memcpy(&addr
, sptr
+soffset
-1, 4);
154 if (inet_addr_type(addr
) != RTN_LOCAL
) {
155 dopt
->ts_needtime
= 1;
164 dopt
->optlen
+= optlen
;
167 unsigned char * start
= sptr
+sopt
->srr
;
173 if (soffset
> optlen
)
174 soffset
= optlen
+ 1;
177 memcpy(&faddr
, &start
[soffset
-1], 4);
178 for (soffset
-=4, doffset
=4; soffset
> 3; soffset
-=4, doffset
+=4)
179 memcpy(&dptr
[doffset
-1], &start
[soffset
-1], 4);
181 * RFC1812 requires to fix illegal source routes.
183 if (memcmp(&ip_hdr(skb
)->saddr
,
184 &start
[soffset
+ 3], 4) == 0)
188 memcpy(&start
[doffset
-1], &daddr
, 4);
194 dopt
->srr
= dopt
->optlen
+ sizeof(struct iphdr
);
195 dopt
->optlen
+= doffset
+3;
196 dopt
->is_strictroute
= sopt
->is_strictroute
;
200 optlen
= sptr
[sopt
->cipso
+1];
201 dopt
->cipso
= dopt
->optlen
+sizeof(struct iphdr
);
202 memcpy(dptr
, sptr
+sopt
->cipso
, optlen
);
204 dopt
->optlen
+= optlen
;
206 while (dopt
->optlen
& 3) {
214 * Options "fragmenting", just fill options not
215 * allowed in fragments with NOOPs.
216 * Simple and stupid 8), but the most efficient way.
219 void ip_options_fragment(struct sk_buff
* skb
)
221 unsigned char *optptr
= skb_network_header(skb
) + sizeof(struct iphdr
);
222 struct ip_options
* opt
= &(IPCB(skb
)->opt
);
236 if (optlen
<2 || optlen
>l
)
238 if (!IPOPT_COPIED(*optptr
))
239 memset(optptr
, IPOPT_NOOP
, optlen
);
245 opt
->rr_needaddr
= 0;
246 opt
->ts_needaddr
= 0;
247 opt
->ts_needtime
= 0;
252 * Verify options and fill pointers in struct options.
253 * Caller should clear *opt, and set opt->data.
254 * If opt == NULL, then skb->data should point to IP header.
257 int ip_options_compile(struct ip_options
* opt
, struct sk_buff
* skb
)
261 unsigned char * optptr
;
263 unsigned char * pp_ptr
= NULL
;
264 struct rtable
*rt
= skb
? (struct rtable
*)skb
->dst
: NULL
;
267 opt
= &(IPCB(skb
)->opt
);
268 iph
= skb_network_header(skb
);
269 opt
->optlen
= ((struct iphdr
*)iph
)->ihl
*4 - sizeof(struct iphdr
);
270 optptr
= iph
+ sizeof(struct iphdr
);
273 optptr
= opt
->is_data
? opt
->__data
:
274 (unsigned char *)&(ip_hdr(skb
)[1]);
275 iph
= optptr
- sizeof(struct iphdr
);
278 for (l
= opt
->optlen
; l
> 0; ) {
281 for (optptr
++, l
--; l
>0; optptr
++, l
--) {
282 if (*optptr
!= IPOPT_END
) {
294 if (optlen
<2 || optlen
>l
) {
309 /* NB: cf RFC-1812 5.2.4.1 */
315 if (optptr
[2] != 4 || optlen
< 7 || ((optlen
-3) & 3)) {
319 memcpy(&opt
->faddr
, &optptr
[3], 4);
321 memmove(&optptr
[3], &optptr
[7], optlen
-7);
323 opt
->is_strictroute
= (optptr
[0] == IPOPT_SSRR
);
324 opt
->srr
= optptr
- iph
;
339 if (optptr
[2] <= optlen
) {
340 if (optptr
[2]+3 > optlen
) {
345 memcpy(&optptr
[optptr
[2]-1], &rt
->rt_spec_dst
, 4);
349 opt
->rr_needaddr
= 1;
351 opt
->rr
= optptr
- iph
;
353 case IPOPT_TIMESTAMP
:
366 if (optptr
[2] <= optlen
) {
367 __be32
*timeptr
= NULL
;
368 if (optptr
[2]+3 > optptr
[1]) {
372 switch (optptr
[3]&0xF) {
373 case IPOPT_TS_TSONLY
:
374 opt
->ts
= optptr
- iph
;
376 timeptr
= (__be32
*)&optptr
[optptr
[2]-1];
377 opt
->ts_needtime
= 1;
380 case IPOPT_TS_TSANDADDR
:
381 if (optptr
[2]+7 > optptr
[1]) {
385 opt
->ts
= optptr
- iph
;
387 memcpy(&optptr
[optptr
[2]-1], &rt
->rt_spec_dst
, 4);
388 timeptr
= (__be32
*)&optptr
[optptr
[2]+3];
390 opt
->ts_needaddr
= 1;
391 opt
->ts_needtime
= 1;
394 case IPOPT_TS_PRESPEC
:
395 if (optptr
[2]+7 > optptr
[1]) {
399 opt
->ts
= optptr
- iph
;
402 memcpy(&addr
, &optptr
[optptr
[2]-1], 4);
403 if (inet_addr_type(addr
) == RTN_UNICAST
)
406 timeptr
= (__be32
*)&optptr
[optptr
[2]+3];
408 opt
->ts_needtime
= 1;
412 if (!skb
&& !capable(CAP_NET_RAW
)) {
421 do_gettimeofday(&tv
);
422 midtime
= htonl((tv
.tv_sec
% 86400) * 1000 + tv
.tv_usec
/ 1000);
423 memcpy(timeptr
, &midtime
, sizeof(__be32
));
427 unsigned overflow
= optptr
[3]>>4;
428 if (overflow
== 15) {
432 opt
->ts
= optptr
- iph
;
434 optptr
[3] = (optptr
[3]&0xF)|((overflow
+1)<<4);
444 if (optptr
[2] == 0 && optptr
[3] == 0)
445 opt
->router_alert
= optptr
- iph
;
448 if ((!skb
&& !capable(CAP_NET_RAW
)) || opt
->cipso
) {
452 opt
->cipso
= optptr
- iph
;
453 if (cipso_v4_validate(&optptr
)) {
461 if (!skb
&& !capable(CAP_NET_RAW
)) {
477 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl((pp_ptr
-iph
)<<24));
484 * Undo all the changes done by ip_options_compile().
487 void ip_options_undo(struct ip_options
* opt
)
490 unsigned char * optptr
= opt
->__data
+opt
->srr
-sizeof(struct iphdr
);
491 memmove(optptr
+7, optptr
+3, optptr
[1]-7);
492 memcpy(optptr
+3, &opt
->faddr
, 4);
494 if (opt
->rr_needaddr
) {
495 unsigned char * optptr
= opt
->__data
+opt
->rr
-sizeof(struct iphdr
);
497 memset(&optptr
[optptr
[2]-1], 0, 4);
500 unsigned char * optptr
= opt
->__data
+opt
->ts
-sizeof(struct iphdr
);
501 if (opt
->ts_needtime
) {
503 memset(&optptr
[optptr
[2]-1], 0, 4);
504 if ((optptr
[3]&0xF) == IPOPT_TS_PRESPEC
)
507 if (opt
->ts_needaddr
) {
509 memset(&optptr
[optptr
[2]-1], 0, 4);
514 static struct ip_options
*ip_options_get_alloc(const int optlen
)
516 return kzalloc(sizeof(struct ip_options
) + ((optlen
+ 3) & ~3),
520 static int ip_options_get_finish(struct ip_options
**optp
,
521 struct ip_options
*opt
, int optlen
)
524 opt
->__data
[optlen
++] = IPOPT_END
;
525 opt
->optlen
= optlen
;
527 if (optlen
&& ip_options_compile(opt
, NULL
)) {
536 int ip_options_get_from_user(struct ip_options
**optp
, unsigned char __user
*data
, int optlen
)
538 struct ip_options
*opt
= ip_options_get_alloc(optlen
);
542 if (optlen
&& copy_from_user(opt
->__data
, data
, optlen
)) {
546 return ip_options_get_finish(optp
, opt
, optlen
);
549 int ip_options_get(struct ip_options
**optp
, unsigned char *data
, int optlen
)
551 struct ip_options
*opt
= ip_options_get_alloc(optlen
);
556 memcpy(opt
->__data
, data
, optlen
);
557 return ip_options_get_finish(optp
, opt
, optlen
);
560 void ip_forward_options(struct sk_buff
*skb
)
562 struct ip_options
* opt
= &(IPCB(skb
)->opt
);
563 unsigned char * optptr
;
564 struct rtable
*rt
= (struct rtable
*)skb
->dst
;
565 unsigned char *raw
= skb_network_header(skb
);
567 if (opt
->rr_needaddr
) {
568 optptr
= (unsigned char *)raw
+ opt
->rr
;
569 ip_rt_get_source(&optptr
[optptr
[2]-5], rt
);
572 if (opt
->srr_is_hit
) {
573 int srrptr
, srrspace
;
575 optptr
= raw
+ opt
->srr
;
577 for ( srrptr
=optptr
[2], srrspace
= optptr
[1];
581 if (srrptr
+ 3 > srrspace
)
583 if (memcmp(&rt
->rt_dst
, &optptr
[srrptr
-1], 4) == 0)
586 if (srrptr
+ 3 <= srrspace
) {
588 ip_rt_get_source(&optptr
[srrptr
-1], rt
);
589 ip_hdr(skb
)->daddr
= rt
->rt_dst
;
590 optptr
[2] = srrptr
+4;
591 } else if (net_ratelimit())
592 printk(KERN_CRIT
"ip_forward(): Argh! Destination lost!\n");
593 if (opt
->ts_needaddr
) {
594 optptr
= raw
+ opt
->ts
;
595 ip_rt_get_source(&optptr
[optptr
[2]-9], rt
);
599 if (opt
->is_changed
) {
601 ip_send_check(ip_hdr(skb
));
605 int ip_options_rcv_srr(struct sk_buff
*skb
)
607 struct ip_options
*opt
= &(IPCB(skb
)->opt
);
608 int srrspace
, srrptr
;
610 struct iphdr
*iph
= ip_hdr(skb
);
611 unsigned char *optptr
= skb_network_header(skb
) + opt
->srr
;
612 struct rtable
*rt
= (struct rtable
*)skb
->dst
;
619 if (skb
->pkt_type
!= PACKET_HOST
)
621 if (rt
->rt_type
== RTN_UNICAST
) {
622 if (!opt
->is_strictroute
)
624 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl(16<<24));
627 if (rt
->rt_type
!= RTN_LOCAL
)
630 for (srrptr
=optptr
[2], srrspace
= optptr
[1]; srrptr
<= srrspace
; srrptr
+= 4) {
631 if (srrptr
+ 3 > srrspace
) {
632 icmp_send(skb
, ICMP_PARAMETERPROB
, 0, htonl((opt
->srr
+2)<<24));
635 memcpy(&nexthop
, &optptr
[srrptr
-1], 4);
637 rt
= (struct rtable
*)skb
->dst
;
639 err
= ip_route_input(skb
, nexthop
, iph
->saddr
, iph
->tos
, skb
->dev
);
640 rt2
= (struct rtable
*)skb
->dst
;
641 if (err
|| (rt2
->rt_type
!= RTN_UNICAST
&& rt2
->rt_type
!= RTN_LOCAL
)) {
643 skb
->dst
= &rt
->u
.dst
;
647 if (rt2
->rt_type
!= RTN_LOCAL
)
649 /* Superfast 8) loopback forward */
650 memcpy(&iph
->daddr
, &optptr
[srrptr
-1], 4);
653 if (srrptr
<= srrspace
) {