blob: d107543d3f81b4d13a0e788272a6ac8243c9a155 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
5 *
6 * The options processing module for ip.c
7 *
8 * Version: $Id: ip_options.c,v 1.21 2001/09/01 00:31:50 davem Exp $
9 *
10 * Authors: A.N.Kuznetsov
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090011 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 */
13
Randy Dunlap4fc268d2006-01-11 12:17:47 -080014#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/module.h>
16#include <linux/types.h>
17#include <asm/uaccess.h>
18#include <linux/skbuff.h>
19#include <linux/ip.h>
20#include <linux/icmp.h>
21#include <linux/netdevice.h>
22#include <linux/rtnetlink.h>
23#include <net/sock.h>
24#include <net/ip.h>
25#include <net/icmp.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020026#include <net/route.h>
Paul Moore11a03f72006-08-03 16:46:20 -070027#include <net/cipso_ipv4.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090029/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 * 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.
35 *
36 * daddr is real destination address, next hop is recorded in IP header.
37 * saddr is address of outgoing interface.
38 */
39
40void ip_options_build(struct sk_buff * skb, struct ip_options * opt,
Al Viro8712f772006-09-26 22:27:05 -070041 __be32 daddr, struct rtable *rt, int is_frag)
Linus Torvalds1da177e2005-04-16 15:20:36 -070042{
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -070043 unsigned char *iph = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
49 if (opt->srr)
50 memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
51
52 if (!is_frag) {
53 if (opt->rr_needaddr)
54 ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, rt);
55 if (opt->ts_needaddr)
56 ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, rt);
57 if (opt->ts_needtime) {
58 struct timeval tv;
Al Viroe25d2ca2006-09-27 18:28:47 -070059 __be32 midtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 do_gettimeofday(&tv);
61 midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
62 memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
63 }
64 return;
65 }
66 if (opt->rr) {
67 memset(iph+opt->rr, IPOPT_NOP, iph[opt->rr+1]);
68 opt->rr = 0;
69 opt->rr_needaddr = 0;
70 }
71 if (opt->ts) {
72 memset(iph+opt->ts, IPOPT_NOP, iph[opt->ts+1]);
73 opt->ts = 0;
74 opt->ts_needaddr = opt->ts_needtime = 0;
75 }
76}
77
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090078/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 * Provided (sopt, skb) points to received options,
80 * build in dopt compiled option set appropriate for answering.
81 * i.e. invert SRR option, copy anothers,
82 * and grab room in RR/TS options.
83 *
84 * NOTE: dopt cannot point to skb.
85 */
86
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090087int ip_options_echo(struct ip_options * dopt, struct sk_buff * skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -070088{
89 struct ip_options *sopt;
90 unsigned char *sptr, *dptr;
91 int soffset, doffset;
92 int optlen;
Al Viroe25d2ca2006-09-27 18:28:47 -070093 __be32 daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95 memset(dopt, 0, sizeof(struct ip_options));
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 sopt = &(IPCB(skb)->opt);
98
99 if (sopt->optlen == 0) {
100 dopt->optlen = 0;
101 return 0;
102 }
103
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700104 sptr = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 dptr = dopt->__data;
106
Eric Dumazetee6b9672008-03-05 18:30:47 -0800107 daddr = skb->rtable->rt_spec_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109 if (sopt->rr) {
110 optlen = sptr[sopt->rr+1];
111 soffset = sptr[sopt->rr+2];
112 dopt->rr = dopt->optlen + sizeof(struct iphdr);
113 memcpy(dptr, sptr+sopt->rr, optlen);
114 if (sopt->rr_needaddr && soffset <= optlen) {
115 if (soffset + 3 > optlen)
116 return -EINVAL;
117 dptr[2] = soffset + 4;
118 dopt->rr_needaddr = 1;
119 }
120 dptr += optlen;
121 dopt->optlen += optlen;
122 }
123 if (sopt->ts) {
124 optlen = sptr[sopt->ts+1];
125 soffset = sptr[sopt->ts+2];
126 dopt->ts = dopt->optlen + sizeof(struct iphdr);
127 memcpy(dptr, sptr+sopt->ts, optlen);
128 if (soffset <= optlen) {
129 if (sopt->ts_needaddr) {
130 if (soffset + 3 > optlen)
131 return -EINVAL;
132 dopt->ts_needaddr = 1;
133 soffset += 4;
134 }
135 if (sopt->ts_needtime) {
136 if (soffset + 3 > optlen)
137 return -EINVAL;
138 if ((dptr[3]&0xF) != IPOPT_TS_PRESPEC) {
139 dopt->ts_needtime = 1;
140 soffset += 4;
141 } else {
142 dopt->ts_needtime = 0;
143
144 if (soffset + 8 <= optlen) {
Al Virofd683222006-09-26 22:17:51 -0700145 __be32 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147 memcpy(&addr, sptr+soffset-1, 4);
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900148 if (inet_addr_type(dev_net(skb->dst->dev), addr) != RTN_LOCAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 dopt->ts_needtime = 1;
150 soffset += 8;
151 }
152 }
153 }
154 }
155 dptr[2] = soffset;
156 }
157 dptr += optlen;
158 dopt->optlen += optlen;
159 }
160 if (sopt->srr) {
161 unsigned char * start = sptr+sopt->srr;
Al Viro3ca3c682006-09-27 18:28:07 -0700162 __be32 faddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164 optlen = start[1];
165 soffset = start[2];
166 doffset = 0;
167 if (soffset > optlen)
168 soffset = optlen + 1;
169 soffset -= 4;
170 if (soffset > 3) {
171 memcpy(&faddr, &start[soffset-1], 4);
172 for (soffset-=4, doffset=4; soffset > 3; soffset-=4, doffset+=4)
173 memcpy(&dptr[doffset-1], &start[soffset-1], 4);
174 /*
175 * RFC1812 requires to fix illegal source routes.
176 */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700177 if (memcmp(&ip_hdr(skb)->saddr,
178 &start[soffset + 3], 4) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 doffset -= 4;
180 }
181 if (doffset > 3) {
182 memcpy(&start[doffset-1], &daddr, 4);
183 dopt->faddr = faddr;
184 dptr[0] = start[0];
185 dptr[1] = doffset+3;
186 dptr[2] = 4;
187 dptr += doffset+3;
188 dopt->srr = dopt->optlen + sizeof(struct iphdr);
189 dopt->optlen += doffset+3;
190 dopt->is_strictroute = sopt->is_strictroute;
191 }
192 }
Paul Moore11a03f72006-08-03 16:46:20 -0700193 if (sopt->cipso) {
194 optlen = sptr[sopt->cipso+1];
195 dopt->cipso = dopt->optlen+sizeof(struct iphdr);
196 memcpy(dptr, sptr+sopt->cipso, optlen);
197 dptr += optlen;
198 dopt->optlen += optlen;
199 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 while (dopt->optlen & 3) {
201 *dptr++ = IPOPT_END;
202 dopt->optlen++;
203 }
204 return 0;
205}
206
207/*
208 * Options "fragmenting", just fill options not
209 * allowed in fragments with NOOPs.
210 * Simple and stupid 8), but the most efficient way.
211 */
212
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900213void ip_options_fragment(struct sk_buff * skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700215 unsigned char *optptr = skb_network_header(skb) + sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 struct ip_options * opt = &(IPCB(skb)->opt);
217 int l = opt->optlen;
218 int optlen;
219
220 while (l > 0) {
221 switch (*optptr) {
222 case IPOPT_END:
223 return;
224 case IPOPT_NOOP:
225 l--;
226 optptr++;
227 continue;
228 }
229 optlen = optptr[1];
230 if (optlen<2 || optlen>l)
231 return;
232 if (!IPOPT_COPIED(*optptr))
233 memset(optptr, IPOPT_NOOP, optlen);
234 l -= optlen;
235 optptr += optlen;
236 }
237 opt->ts = 0;
238 opt->rr = 0;
239 opt->rr_needaddr = 0;
240 opt->ts_needaddr = 0;
241 opt->ts_needtime = 0;
242 return;
243}
244
245/*
246 * Verify options and fill pointers in struct options.
247 * Caller should clear *opt, and set opt->data.
248 * If opt == NULL, then skb->data should point to IP header.
249 */
250
Denis V. Lunev0e6bd4a2008-03-24 15:29:23 -0700251int ip_options_compile(struct net *net,
252 struct ip_options * opt, struct sk_buff * skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
254 int l;
255 unsigned char * iph;
256 unsigned char * optptr;
257 int optlen;
258 unsigned char * pp_ptr = NULL;
Denis V. Lunev22aba382008-03-22 16:36:20 -0700259 struct rtable *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Denis V. Lunev22aba382008-03-22 16:36:20 -0700261 if (skb != NULL) {
262 rt = skb->rtable;
263 optptr = (unsigned char *)&(ip_hdr(skb)[1]);
264 } else
Denis V. Lunev10fe7d82008-03-22 16:35:00 -0700265 optptr = opt->__data;
Denis V. Lunev22aba382008-03-22 16:36:20 -0700266 iph = optptr - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
268 for (l = opt->optlen; l > 0; ) {
269 switch (*optptr) {
270 case IPOPT_END:
271 for (optptr++, l--; l>0; optptr++, l--) {
272 if (*optptr != IPOPT_END) {
273 *optptr = IPOPT_END;
274 opt->is_changed = 1;
275 }
276 }
277 goto eol;
278 case IPOPT_NOOP:
279 l--;
280 optptr++;
281 continue;
282 }
283 optlen = optptr[1];
284 if (optlen<2 || optlen>l) {
285 pp_ptr = optptr;
286 goto error;
287 }
288 switch (*optptr) {
289 case IPOPT_SSRR:
290 case IPOPT_LSRR:
291 if (optlen < 3) {
292 pp_ptr = optptr + 1;
293 goto error;
294 }
295 if (optptr[2] < 4) {
296 pp_ptr = optptr + 2;
297 goto error;
298 }
299 /* NB: cf RFC-1812 5.2.4.1 */
300 if (opt->srr) {
301 pp_ptr = optptr;
302 goto error;
303 }
304 if (!skb) {
305 if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
306 pp_ptr = optptr + 1;
307 goto error;
308 }
309 memcpy(&opt->faddr, &optptr[3], 4);
310 if (optlen > 7)
311 memmove(&optptr[3], &optptr[7], optlen-7);
312 }
313 opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
314 opt->srr = optptr - iph;
315 break;
316 case IPOPT_RR:
317 if (opt->rr) {
318 pp_ptr = optptr;
319 goto error;
320 }
321 if (optlen < 3) {
322 pp_ptr = optptr + 1;
323 goto error;
324 }
325 if (optptr[2] < 4) {
326 pp_ptr = optptr + 2;
327 goto error;
328 }
329 if (optptr[2] <= optlen) {
330 if (optptr[2]+3 > optlen) {
331 pp_ptr = optptr + 2;
332 goto error;
333 }
334 if (skb) {
335 memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
336 opt->is_changed = 1;
337 }
338 optptr[2] += 4;
339 opt->rr_needaddr = 1;
340 }
341 opt->rr = optptr - iph;
342 break;
343 case IPOPT_TIMESTAMP:
344 if (opt->ts) {
345 pp_ptr = optptr;
346 goto error;
347 }
348 if (optlen < 4) {
349 pp_ptr = optptr + 1;
350 goto error;
351 }
352 if (optptr[2] < 5) {
353 pp_ptr = optptr + 2;
354 goto error;
355 }
356 if (optptr[2] <= optlen) {
Al Viroe25d2ca2006-09-27 18:28:47 -0700357 __be32 *timeptr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (optptr[2]+3 > optptr[1]) {
359 pp_ptr = optptr + 2;
360 goto error;
361 }
362 switch (optptr[3]&0xF) {
363 case IPOPT_TS_TSONLY:
364 opt->ts = optptr - iph;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900365 if (skb)
Al Viroe25d2ca2006-09-27 18:28:47 -0700366 timeptr = (__be32*)&optptr[optptr[2]-1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 opt->ts_needtime = 1;
368 optptr[2] += 4;
369 break;
370 case IPOPT_TS_TSANDADDR:
371 if (optptr[2]+7 > optptr[1]) {
372 pp_ptr = optptr + 2;
373 goto error;
374 }
375 opt->ts = optptr - iph;
376 if (skb) {
377 memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
Al Viroe25d2ca2006-09-27 18:28:47 -0700378 timeptr = (__be32*)&optptr[optptr[2]+3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
380 opt->ts_needaddr = 1;
381 opt->ts_needtime = 1;
382 optptr[2] += 8;
383 break;
384 case IPOPT_TS_PRESPEC:
385 if (optptr[2]+7 > optptr[1]) {
386 pp_ptr = optptr + 2;
387 goto error;
388 }
389 opt->ts = optptr - iph;
390 {
Al Virofd683222006-09-26 22:17:51 -0700391 __be32 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 memcpy(&addr, &optptr[optptr[2]-1], 4);
Denis V. Lunev0e6bd4a2008-03-24 15:29:23 -0700393 if (inet_addr_type(net, addr) == RTN_UNICAST)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 break;
395 if (skb)
Al Viroe25d2ca2006-09-27 18:28:47 -0700396 timeptr = (__be32*)&optptr[optptr[2]+3];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
398 opt->ts_needtime = 1;
399 optptr[2] += 8;
400 break;
401 default:
402 if (!skb && !capable(CAP_NET_RAW)) {
403 pp_ptr = optptr + 3;
404 goto error;
405 }
406 break;
407 }
408 if (timeptr) {
409 struct timeval tv;
Al Viroe25d2ca2006-09-27 18:28:47 -0700410 __be32 midtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 do_gettimeofday(&tv);
412 midtime = htonl((tv.tv_sec % 86400) * 1000 + tv.tv_usec / 1000);
Al Viroe25d2ca2006-09-27 18:28:47 -0700413 memcpy(timeptr, &midtime, sizeof(__be32));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 opt->is_changed = 1;
415 }
416 } else {
417 unsigned overflow = optptr[3]>>4;
418 if (overflow == 15) {
419 pp_ptr = optptr + 3;
420 goto error;
421 }
422 opt->ts = optptr - iph;
423 if (skb) {
424 optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
425 opt->is_changed = 1;
426 }
427 }
428 break;
429 case IPOPT_RA:
430 if (optlen < 4) {
431 pp_ptr = optptr + 1;
432 goto error;
433 }
434 if (optptr[2] == 0 && optptr[3] == 0)
435 opt->router_alert = optptr - iph;
436 break;
Paul Moore11a03f72006-08-03 16:46:20 -0700437 case IPOPT_CIPSO:
Paul Mooref8687af2006-10-30 15:22:15 -0800438 if ((!skb && !capable(CAP_NET_RAW)) || opt->cipso) {
Paul Moore11a03f72006-08-03 16:46:20 -0700439 pp_ptr = optptr;
440 goto error;
441 }
442 opt->cipso = optptr - iph;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900443 if (cipso_v4_validate(&optptr)) {
Paul Moore11a03f72006-08-03 16:46:20 -0700444 pp_ptr = optptr;
445 goto error;
446 }
447 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 case IPOPT_SEC:
449 case IPOPT_SID:
450 default:
451 if (!skb && !capable(CAP_NET_RAW)) {
452 pp_ptr = optptr;
453 goto error;
454 }
455 break;
456 }
457 l -= optlen;
458 optptr += optlen;
459 }
460
461eol:
462 if (!pp_ptr)
463 return 0;
464
465error:
466 if (skb) {
467 icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));
468 }
469 return -EINVAL;
470}
471
472
473/*
474 * Undo all the changes done by ip_options_compile().
475 */
476
477void ip_options_undo(struct ip_options * opt)
478{
479 if (opt->srr) {
480 unsigned char * optptr = opt->__data+opt->srr-sizeof(struct iphdr);
481 memmove(optptr+7, optptr+3, optptr[1]-7);
482 memcpy(optptr+3, &opt->faddr, 4);
483 }
484 if (opt->rr_needaddr) {
485 unsigned char * optptr = opt->__data+opt->rr-sizeof(struct iphdr);
486 optptr[2] -= 4;
487 memset(&optptr[optptr[2]-1], 0, 4);
488 }
489 if (opt->ts) {
490 unsigned char * optptr = opt->__data+opt->ts-sizeof(struct iphdr);
491 if (opt->ts_needtime) {
492 optptr[2] -= 4;
493 memset(&optptr[optptr[2]-1], 0, 4);
494 if ((optptr[3]&0xF) == IPOPT_TS_PRESPEC)
495 optptr[2] -= 4;
496 }
497 if (opt->ts_needaddr) {
498 optptr[2] -= 4;
499 memset(&optptr[optptr[2]-1], 0, 4);
500 }
501 }
502}
503
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300504static struct ip_options *ip_options_get_alloc(const int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Mariusz Kozlowski37640702007-07-31 14:06:45 -0700506 return kzalloc(sizeof(struct ip_options) + ((optlen + 3) & ~3),
507 GFP_KERNEL);
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300508}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700510static int ip_options_get_finish(struct net *net, struct ip_options **optp,
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300511 struct ip_options *opt, int optlen)
512{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 while (optlen & 3)
514 opt->__data[optlen++] = IPOPT_END;
515 opt->optlen = optlen;
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700516 if (optlen && ip_options_compile(net, opt, NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 kfree(opt);
518 return -EINVAL;
519 }
Jesper Juhla51482b2005-11-08 09:41:34 -0800520 kfree(*optp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 *optp = opt;
522 return 0;
523}
524
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700525int ip_options_get_from_user(struct net *net, struct ip_options **optp,
526 unsigned char __user *data, int optlen)
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300527{
528 struct ip_options *opt = ip_options_get_alloc(optlen);
529
530 if (!opt)
531 return -ENOMEM;
532 if (optlen && copy_from_user(opt->__data, data, optlen)) {
533 kfree(opt);
534 return -EFAULT;
535 }
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700536 return ip_options_get_finish(net, optp, opt, optlen);
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300537}
538
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700539int ip_options_get(struct net *net, struct ip_options **optp,
540 unsigned char *data, int optlen)
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300541{
542 struct ip_options *opt = ip_options_get_alloc(optlen);
543
544 if (!opt)
545 return -ENOMEM;
546 if (optlen)
547 memcpy(opt->__data, data, optlen);
Denis V. Lunevf2c48022008-03-24 15:29:55 -0700548 return ip_options_get_finish(net, optp, opt, optlen);
Arnaldo Carvalho de Melo4c6ea292005-08-16 19:46:48 -0300549}
550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551void ip_forward_options(struct sk_buff *skb)
552{
553 struct ip_options * opt = &(IPCB(skb)->opt);
554 unsigned char * optptr;
Eric Dumazetee6b9672008-03-05 18:30:47 -0800555 struct rtable *rt = skb->rtable;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700556 unsigned char *raw = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558 if (opt->rr_needaddr) {
559 optptr = (unsigned char *)raw + opt->rr;
560 ip_rt_get_source(&optptr[optptr[2]-5], rt);
561 opt->is_changed = 1;
562 }
563 if (opt->srr_is_hit) {
564 int srrptr, srrspace;
565
566 optptr = raw + opt->srr;
567
568 for ( srrptr=optptr[2], srrspace = optptr[1];
569 srrptr <= srrspace;
570 srrptr += 4
571 ) {
572 if (srrptr + 3 > srrspace)
573 break;
574 if (memcmp(&rt->rt_dst, &optptr[srrptr-1], 4) == 0)
575 break;
576 }
577 if (srrptr + 3 <= srrspace) {
578 opt->is_changed = 1;
579 ip_rt_get_source(&optptr[srrptr-1], rt);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700580 ip_hdr(skb)->daddr = rt->rt_dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 optptr[2] = srrptr+4;
582 } else if (net_ratelimit())
583 printk(KERN_CRIT "ip_forward(): Argh! Destination lost!\n");
584 if (opt->ts_needaddr) {
585 optptr = raw + opt->ts;
586 ip_rt_get_source(&optptr[optptr[2]-9], rt);
587 opt->is_changed = 1;
588 }
589 }
590 if (opt->is_changed) {
591 opt->is_changed = 0;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700592 ip_send_check(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
594}
595
596int ip_options_rcv_srr(struct sk_buff *skb)
597{
598 struct ip_options *opt = &(IPCB(skb)->opt);
599 int srrspace, srrptr;
Al Viro9e12bb22006-09-26 21:25:20 -0700600 __be32 nexthop;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700601 struct iphdr *iph = ip_hdr(skb);
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700602 unsigned char *optptr = skb_network_header(skb) + opt->srr;
Eric Dumazetee6b9672008-03-05 18:30:47 -0800603 struct rtable *rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 struct rtable *rt2;
605 int err;
606
607 if (!opt->srr)
608 return 0;
609
610 if (skb->pkt_type != PACKET_HOST)
611 return -EINVAL;
612 if (rt->rt_type == RTN_UNICAST) {
613 if (!opt->is_strictroute)
614 return 0;
615 icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl(16<<24));
616 return -EINVAL;
617 }
618 if (rt->rt_type != RTN_LOCAL)
619 return -EINVAL;
620
621 for (srrptr=optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
622 if (srrptr + 3 > srrspace) {
623 icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
624 return -EINVAL;
625 }
626 memcpy(&nexthop, &optptr[srrptr-1], 4);
627
Eric Dumazetee6b9672008-03-05 18:30:47 -0800628 rt = skb->rtable;
629 skb->rtable = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
Eric Dumazetee6b9672008-03-05 18:30:47 -0800631 rt2 = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
633 ip_rt_put(rt2);
Eric Dumazetee6b9672008-03-05 18:30:47 -0800634 skb->rtable = rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 return -EINVAL;
636 }
637 ip_rt_put(rt);
638 if (rt2->rt_type != RTN_LOCAL)
639 break;
640 /* Superfast 8) loopback forward */
641 memcpy(&iph->daddr, &optptr[srrptr-1], 4);
642 opt->is_changed = 1;
643 }
644 if (srrptr <= srrspace) {
645 opt->srr_is_hit = 1;
646 opt->is_changed = 1;
647 }
648 return 0;
649}