Branch data Line data Source code
1 : : /*
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 : : * Authors: A.N.Kuznetsov
9 : : *
10 : : */
11 : :
12 : : #define pr_fmt(fmt) "IPv4: " fmt
13 : :
14 : : #include <linux/capability.h>
15 : : #include <linux/module.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/types.h>
18 : : #include <asm/uaccess.h>
19 : : #include <asm/unaligned.h>
20 : : #include <linux/skbuff.h>
21 : : #include <linux/ip.h>
22 : : #include <linux/icmp.h>
23 : : #include <linux/netdevice.h>
24 : : #include <linux/rtnetlink.h>
25 : : #include <net/sock.h>
26 : : #include <net/ip.h>
27 : : #include <net/icmp.h>
28 : : #include <net/route.h>
29 : : #include <net/cipso_ipv4.h>
30 : : #include <net/ip_fib.h>
31 : :
32 : : /*
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.
38 : : *
39 : : * daddr is real destination address, next hop is recorded in IP header.
40 : : * saddr is address of outgoing interface.
41 : : */
42 : :
43 : 0 : void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
44 : : __be32 daddr, struct rtable *rt, int is_frag)
45 : : {
46 : : unsigned char *iph = skb_network_header(skb);
47 : :
48 : 0 : memcpy(&(IPCB(skb)->opt), opt, sizeof(struct ip_options));
49 : 0 : memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
50 : : opt = &(IPCB(skb)->opt);
51 : :
52 [ # # ]: 0 : if (opt->srr)
53 : 0 : memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
54 : :
55 [ # # ]: 0 : if (!is_frag) {
56 [ # # ]: 0 : if (opt->rr_needaddr)
57 : 0 : ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, skb, rt);
58 [ # # ]: 0 : if (opt->ts_needaddr)
59 : 0 : ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, skb, rt);
60 [ # # ]: 0 : if (opt->ts_needtime) {
61 : : struct timespec tv;
62 : : __be32 midtime;
63 : 0 : getnstimeofday(&tv);
64 [ # # ]: 0 : midtime = htonl((tv.tv_sec % 86400) * MSEC_PER_SEC + tv.tv_nsec / NSEC_PER_MSEC);
65 : 0 : memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
66 : : }
67 : 0 : return;
68 : : }
69 [ # # ]: 0 : if (opt->rr) {
70 [ # # ]: 0 : memset(iph+opt->rr, IPOPT_NOP, iph[opt->rr+1]);
71 : 0 : opt->rr = 0;
72 : 0 : opt->rr_needaddr = 0;
73 : : }
74 [ # # ]: 0 : if (opt->ts) {
75 [ # # ]: 0 : memset(iph+opt->ts, IPOPT_NOP, iph[opt->ts+1]);
76 : 0 : opt->ts = 0;
77 : 0 : opt->ts_needaddr = opt->ts_needtime = 0;
78 : : }
79 : : }
80 : :
81 : : /*
82 : : * Provided (sopt, skb) points to received options,
83 : : * build in dopt compiled option set appropriate for answering.
84 : : * i.e. invert SRR option, copy anothers,
85 : : * and grab room in RR/TS options.
86 : : *
87 : : * NOTE: dopt cannot point to skb.
88 : : */
89 : :
90 : 0 : int ip_options_echo(struct ip_options *dopt, struct sk_buff *skb)
91 : : {
92 : : const struct ip_options *sopt;
93 : : unsigned char *sptr, *dptr;
94 : : int soffset, doffset;
95 : : int optlen;
96 : :
97 : 1 : memset(dopt, 0, sizeof(struct ip_options));
98 : :
99 : : sopt = &(IPCB(skb)->opt);
100 : :
101 [ + - ]: 1 : if (sopt->optlen == 0)
102 : : return 0;
103 : :
104 : : sptr = skb_network_header(skb);
105 : 1 : dptr = dopt->__data;
106 : :
107 [ - + ]: 1 : if (sopt->rr) {
108 : 0 : optlen = sptr[sopt->rr+1];
109 : 0 : soffset = sptr[sopt->rr+2];
110 : 0 : dopt->rr = dopt->optlen + sizeof(struct iphdr);
111 : 0 : memcpy(dptr, sptr+sopt->rr, optlen);
112 [ # # ][ # # ]: 0 : if (sopt->rr_needaddr && soffset <= optlen) {
113 [ # # ]: 0 : if (soffset + 3 > optlen)
114 : : return -EINVAL;
115 : 0 : dptr[2] = soffset + 4;
116 : 0 : dopt->rr_needaddr = 1;
117 : : }
118 : 0 : dptr += optlen;
119 : 0 : dopt->optlen += optlen;
120 : : }
121 [ - + ]: 1 : if (sopt->ts) {
122 : 0 : optlen = sptr[sopt->ts+1];
123 : 0 : soffset = sptr[sopt->ts+2];
124 : 0 : dopt->ts = dopt->optlen + sizeof(struct iphdr);
125 : 0 : memcpy(dptr, sptr+sopt->ts, optlen);
126 [ # # ]: 0 : if (soffset <= optlen) {
127 [ # # ]: 0 : if (sopt->ts_needaddr) {
128 [ # # ]: 0 : if (soffset + 3 > optlen)
129 : : return -EINVAL;
130 : 0 : dopt->ts_needaddr = 1;
131 : 0 : soffset += 4;
132 : : }
133 [ # # ]: 0 : if (sopt->ts_needtime) {
134 [ # # ]: 0 : if (soffset + 3 > optlen)
135 : : return -EINVAL;
136 [ # # ]: 0 : if ((dptr[3]&0xF) != IPOPT_TS_PRESPEC) {
137 : 0 : dopt->ts_needtime = 1;
138 : 0 : soffset += 4;
139 : : } else {
140 : 0 : dopt->ts_needtime = 0;
141 : :
142 [ # # ]: 0 : if (soffset + 7 <= optlen) {
143 : : __be32 addr;
144 : :
145 : 0 : memcpy(&addr, dptr+soffset-1, 4);
146 [ # # ]: 0 : if (inet_addr_type(dev_net(skb_dst(skb)->dev), addr) != RTN_UNICAST) {
147 : 0 : dopt->ts_needtime = 1;
148 : 0 : soffset += 8;
149 : : }
150 : : }
151 : : }
152 : : }
153 : 0 : dptr[2] = soffset;
154 : : }
155 : 0 : dptr += optlen;
156 : 0 : dopt->optlen += optlen;
157 : : }
158 [ # # ]: 1 : if (sopt->srr) {
159 : 0 : unsigned char *start = sptr+sopt->srr;
160 : : __be32 faddr;
161 : :
162 : 0 : optlen = start[1];
163 : 0 : soffset = start[2];
164 : : doffset = 0;
165 [ # # ]: 0 : if (soffset > optlen)
166 : 0 : soffset = optlen + 1;
167 : 0 : soffset -= 4;
168 [ # # ]: 0 : if (soffset > 3) {
169 : 0 : memcpy(&faddr, &start[soffset-1], 4);
170 [ # # ]: 0 : for (soffset -= 4, doffset = 4; soffset > 3; soffset -= 4, doffset += 4)
171 : 0 : memcpy(&dptr[doffset-1], &start[soffset-1], 4);
172 : : /*
173 : : * RFC1812 requires to fix illegal source routes.
174 : : */
175 [ # # ]: 0 : if (memcmp(&ip_hdr(skb)->saddr,
176 : 0 : &start[soffset + 3], 4) == 0)
177 : 0 : doffset -= 4;
178 : : }
179 [ # # ]: 0 : if (doffset > 3) {
180 : 0 : __be32 daddr = fib_compute_spec_dst(skb);
181 : :
182 : 0 : memcpy(&start[doffset-1], &daddr, 4);
183 : 0 : dopt->faddr = faddr;
184 : 0 : dptr[0] = start[0];
185 : 0 : dptr[1] = doffset+3;
186 : 0 : dptr[2] = 4;
187 : 0 : dptr += doffset+3;
188 : 0 : dopt->srr = dopt->optlen + sizeof(struct iphdr);
189 : 0 : dopt->optlen += doffset+3;
190 : 0 : dopt->is_strictroute = sopt->is_strictroute;
191 : : }
192 : : }
193 [ # # ]: 0 : if (sopt->cipso) {
194 : 0 : optlen = sptr[sopt->cipso+1];
195 : 0 : dopt->cipso = dopt->optlen+sizeof(struct iphdr);
196 : 0 : memcpy(dptr, sptr+sopt->cipso, optlen);
197 : 0 : dptr += optlen;
198 : 0 : dopt->optlen += optlen;
199 : : }
200 [ # # ]: 0 : while (dopt->optlen & 3) {
201 : 0 : *dptr++ = IPOPT_END;
202 : 0 : 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 : :
213 : 0 : void ip_options_fragment(struct sk_buff *skb)
214 : : {
215 : 0 : unsigned char *optptr = skb_network_header(skb) + sizeof(struct iphdr);
216 : : struct ip_options *opt = &(IPCB(skb)->opt);
217 : 0 : int l = opt->optlen;
218 : : int optlen;
219 : :
220 [ # # ]: 0 : while (l > 0) {
221 [ # # # ]: 0 : switch (*optptr) {
222 : : case IPOPT_END:
223 : : return;
224 : : case IPOPT_NOOP:
225 : 0 : l--;
226 : 0 : optptr++;
227 : 0 : continue;
228 : : }
229 : 0 : optlen = optptr[1];
230 [ # # ]: 0 : if (optlen < 2 || optlen > l)
231 : : return;
232 [ # # ]: 0 : if (!IPOPT_COPIED(*optptr))
233 [ # # ]: 0 : memset(optptr, IPOPT_NOOP, optlen);
234 : 0 : l -= optlen;
235 : 0 : optptr += optlen;
236 : : }
237 : 0 : opt->ts = 0;
238 : 0 : opt->rr = 0;
239 : 0 : opt->rr_needaddr = 0;
240 : 0 : opt->ts_needaddr = 0;
241 : 0 : opt->ts_needtime = 0;
242 : : }
243 : :
244 : : /* helper used by ip_options_compile() to call fib_compute_spec_dst()
245 : : * at most one time.
246 : : */
247 : : static void spec_dst_fill(__be32 *spec_dst, struct sk_buff *skb)
248 : : {
249 [ # # ][ # # ]: 0 : if (*spec_dst == htonl(INADDR_ANY))
250 : 0 : *spec_dst = fib_compute_spec_dst(skb);
251 : : }
252 : :
253 : : /*
254 : : * Verify options and fill pointers in struct options.
255 : : * Caller should clear *opt, and set opt->data.
256 : : * If opt == NULL, then skb->data should point to IP header.
257 : : */
258 : :
259 : 0 : int ip_options_compile(struct net *net,
260 : : struct ip_options *opt, struct sk_buff *skb)
261 : : {
262 : 0 : __be32 spec_dst = htonl(INADDR_ANY);
263 : : unsigned char *pp_ptr = NULL;
264 : : struct rtable *rt = NULL;
265 : : unsigned char *optptr;
266 : : unsigned char *iph;
267 : : int optlen, l;
268 : :
269 [ # # ]: 0 : if (skb != NULL) {
270 : : rt = skb_rtable(skb);
271 : 0 : optptr = (unsigned char *)&(ip_hdr(skb)[1]);
272 : : } else
273 : 0 : optptr = opt->__data;
274 : 0 : iph = optptr - sizeof(struct iphdr);
275 : :
276 [ # # ]: 0 : for (l = opt->optlen; l > 0; ) {
277 [ # # # ]: 0 : switch (*optptr) {
278 : : case IPOPT_END:
279 [ # # ]: 0 : for (optptr++, l--; l > 0; optptr++, l--) {
280 [ # # ]: 0 : if (*optptr != IPOPT_END) {
281 : 0 : *optptr = IPOPT_END;
282 : 0 : opt->is_changed = 1;
283 : : }
284 : : }
285 : : goto eol;
286 : : case IPOPT_NOOP:
287 : 0 : l--;
288 : 0 : optptr++;
289 : 0 : continue;
290 : : }
291 : 0 : optlen = optptr[1];
292 [ # # ]: 0 : if (optlen < 2 || optlen > l) {
293 : : pp_ptr = optptr;
294 : : goto error;
295 : : }
296 [ # # # # : 0 : switch (*optptr) {
# # ]
297 : : case IPOPT_SSRR:
298 : : case IPOPT_LSRR:
299 [ # # ]: 0 : if (optlen < 3) {
300 : 0 : pp_ptr = optptr + 1;
301 : 0 : goto error;
302 : : }
303 [ # # ]: 0 : if (optptr[2] < 4) {
304 : 0 : pp_ptr = optptr + 2;
305 : 0 : goto error;
306 : : }
307 : : /* NB: cf RFC-1812 5.2.4.1 */
308 [ # # ]: 0 : if (opt->srr) {
309 : : pp_ptr = optptr;
310 : : goto error;
311 : : }
312 [ # # ]: 0 : if (!skb) {
313 [ # # ][ # # ]: 0 : if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
[ # # ]
314 : 0 : pp_ptr = optptr + 1;
315 : 0 : goto error;
316 : : }
317 : 0 : memcpy(&opt->faddr, &optptr[3], 4);
318 [ # # ]: 0 : if (optlen > 7)
319 : 0 : memmove(&optptr[3], &optptr[7], optlen-7);
320 : : }
321 : 0 : opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
322 : 0 : opt->srr = optptr - iph;
323 : 0 : break;
324 : : case IPOPT_RR:
325 [ # # ]: 0 : if (opt->rr) {
326 : : pp_ptr = optptr;
327 : : goto error;
328 : : }
329 [ # # ]: 0 : if (optlen < 3) {
330 : 0 : pp_ptr = optptr + 1;
331 : 0 : goto error;
332 : : }
333 [ # # ]: 0 : if (optptr[2] < 4) {
334 : 0 : pp_ptr = optptr + 2;
335 : 0 : goto error;
336 : : }
337 [ # # ]: 0 : if (optptr[2] <= optlen) {
338 [ # # ]: 0 : if (optptr[2]+3 > optlen) {
339 : 0 : pp_ptr = optptr + 2;
340 : 0 : goto error;
341 : : }
342 [ # # ]: 0 : if (rt) {
343 : : spec_dst_fill(&spec_dst, skb);
344 : 0 : memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
345 : 0 : opt->is_changed = 1;
346 : : }
347 : 0 : optptr[2] += 4;
348 : 0 : opt->rr_needaddr = 1;
349 : : }
350 : 0 : opt->rr = optptr - iph;
351 : 0 : break;
352 : : case IPOPT_TIMESTAMP:
353 [ # # ]: 0 : if (opt->ts) {
354 : : pp_ptr = optptr;
355 : : goto error;
356 : : }
357 [ # # ]: 0 : if (optlen < 4) {
358 : 0 : pp_ptr = optptr + 1;
359 : 0 : goto error;
360 : : }
361 [ # # ]: 0 : if (optptr[2] < 5) {
362 : 0 : pp_ptr = optptr + 2;
363 : 0 : goto error;
364 : : }
365 [ # # ]: 0 : if (optptr[2] <= optlen) {
366 : : unsigned char *timeptr = NULL;
367 [ # # ]: 0 : if (optptr[2]+3 > optptr[1]) {
368 : 0 : pp_ptr = optptr + 2;
369 : 0 : goto error;
370 : : }
371 [ # # # # ]: 0 : switch (optptr[3]&0xF) {
372 : : case IPOPT_TS_TSONLY:
373 [ # # ]: 0 : if (skb)
374 : 0 : timeptr = &optptr[optptr[2]-1];
375 : 0 : opt->ts_needtime = 1;
376 : 0 : optptr[2] += 4;
377 : 0 : break;
378 : : case IPOPT_TS_TSANDADDR:
379 [ # # ]: 0 : if (optptr[2]+7 > optptr[1]) {
380 : 0 : pp_ptr = optptr + 2;
381 : 0 : goto error;
382 : : }
383 [ # # ]: 0 : if (rt) {
384 : : spec_dst_fill(&spec_dst, skb);
385 : 0 : memcpy(&optptr[optptr[2]-1], &spec_dst, 4);
386 : 0 : timeptr = &optptr[optptr[2]+3];
387 : : }
388 : 0 : opt->ts_needaddr = 1;
389 : 0 : opt->ts_needtime = 1;
390 : 0 : optptr[2] += 8;
391 : 0 : break;
392 : : case IPOPT_TS_PRESPEC:
393 [ # # ]: 0 : if (optptr[2]+7 > optptr[1]) {
394 : 0 : pp_ptr = optptr + 2;
395 : 0 : goto error;
396 : : }
397 : : {
398 : : __be32 addr;
399 : 0 : memcpy(&addr, &optptr[optptr[2]-1], 4);
400 [ # # ]: 0 : if (inet_addr_type(net, addr) == RTN_UNICAST)
401 : : break;
402 [ # # ]: 0 : if (skb)
403 : 0 : timeptr = &optptr[optptr[2]+3];
404 : : }
405 : 0 : opt->ts_needtime = 1;
406 : 0 : optptr[2] += 8;
407 : 0 : break;
408 : : default:
409 [ # # ][ # # ]: 0 : if (!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) {
410 : 0 : pp_ptr = optptr + 3;
411 : 0 : goto error;
412 : : }
413 : : break;
414 : : }
415 [ # # ]: 0 : if (timeptr) {
416 : : struct timespec tv;
417 : : u32 midtime;
418 : 0 : getnstimeofday(&tv);
419 : 0 : midtime = (tv.tv_sec % 86400) * MSEC_PER_SEC + tv.tv_nsec / NSEC_PER_MSEC;
420 : : put_unaligned_be32(midtime, timeptr);
421 : 0 : opt->is_changed = 1;
422 : : }
423 [ # # ]: 0 : } else if ((optptr[3]&0xF) != IPOPT_TS_PRESPEC) {
424 : 0 : unsigned int overflow = optptr[3]>>4;
425 [ # # ]: 0 : if (overflow == 15) {
426 : 0 : pp_ptr = optptr + 3;
427 : 0 : goto error;
428 : : }
429 [ # # ]: 0 : if (skb) {
430 : 0 : optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
431 : 0 : opt->is_changed = 1;
432 : : }
433 : : }
434 : 0 : opt->ts = optptr - iph;
435 : 0 : break;
436 : : case IPOPT_RA:
437 [ # # ]: 0 : if (optlen < 4) {
438 : 0 : pp_ptr = optptr + 1;
439 : 0 : goto error;
440 : : }
441 [ # # ][ # # ]: 0 : if (optptr[2] == 0 && optptr[3] == 0)
442 : 0 : opt->router_alert = optptr - iph;
443 : : break;
444 : : case IPOPT_CIPSO:
445 [ # # ][ # # ]: 0 : if ((!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) || opt->cipso) {
[ # # ]
446 : 0 : pp_ptr = optptr;
447 : 0 : goto error;
448 : : }
449 : 0 : opt->cipso = optptr - iph;
450 [ # # ]: 0 : if (cipso_v4_validate(skb, &optptr)) {
451 : 0 : pp_ptr = optptr;
452 : 0 : goto error;
453 : : }
454 : : break;
455 : : case IPOPT_SEC:
456 : : case IPOPT_SID:
457 : : default:
458 [ # # ][ # # ]: 0 : if (!skb && !ns_capable(net->user_ns, CAP_NET_RAW)) {
459 : 0 : pp_ptr = optptr;
460 : 0 : goto error;
461 : : }
462 : : break;
463 : : }
464 : 0 : l -= optlen;
465 : 0 : optptr += optlen;
466 : : }
467 : :
468 : : eol:
469 : : if (!pp_ptr)
470 : : return 0;
471 : :
472 : : error:
473 [ # # ]: 0 : if (skb) {
474 [ # # ]: 0 : icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));
475 : : }
476 : : return -EINVAL;
477 : : }
478 : : EXPORT_SYMBOL(ip_options_compile);
479 : :
480 : : /*
481 : : * Undo all the changes done by ip_options_compile().
482 : : */
483 : :
484 : 0 : void ip_options_undo(struct ip_options *opt)
485 : : {
486 [ # # ]: 0 : if (opt->srr) {
487 : 0 : unsigned char *optptr = opt->__data+opt->srr-sizeof(struct iphdr);
488 : 0 : memmove(optptr+7, optptr+3, optptr[1]-7);
489 : 0 : memcpy(optptr+3, &opt->faddr, 4);
490 : : }
491 [ # # ]: 0 : if (opt->rr_needaddr) {
492 : 0 : unsigned char *optptr = opt->__data+opt->rr-sizeof(struct iphdr);
493 : 0 : optptr[2] -= 4;
494 : 0 : memset(&optptr[optptr[2]-1], 0, 4);
495 : : }
496 [ # # ]: 0 : if (opt->ts) {
497 : 0 : unsigned char *optptr = opt->__data+opt->ts-sizeof(struct iphdr);
498 [ # # ]: 0 : if (opt->ts_needtime) {
499 : 0 : optptr[2] -= 4;
500 : 0 : memset(&optptr[optptr[2]-1], 0, 4);
501 [ # # ]: 0 : if ((optptr[3]&0xF) == IPOPT_TS_PRESPEC)
502 : 0 : optptr[2] -= 4;
503 : : }
504 [ # # ]: 0 : if (opt->ts_needaddr) {
505 : 0 : optptr[2] -= 4;
506 : 0 : memset(&optptr[optptr[2]-1], 0, 4);
507 : : }
508 : : }
509 : 0 : }
510 : :
511 : 0 : static struct ip_options_rcu *ip_options_get_alloc(const int optlen)
512 : : {
513 : 0 : return kzalloc(sizeof(struct ip_options_rcu) + ((optlen + 3) & ~3),
514 : : GFP_KERNEL);
515 : : }
516 : :
517 : 0 : static int ip_options_get_finish(struct net *net, struct ip_options_rcu **optp,
518 : : struct ip_options_rcu *opt, int optlen)
519 : : {
520 [ # # ]: 0 : while (optlen & 3)
521 : 0 : opt->opt.__data[optlen++] = IPOPT_END;
522 : 0 : opt->opt.optlen = optlen;
523 [ # # ][ # # ]: 0 : if (optlen && ip_options_compile(net, &opt->opt, NULL)) {
524 : 0 : kfree(opt);
525 : 0 : return -EINVAL;
526 : : }
527 : 0 : kfree(*optp);
528 : 0 : *optp = opt;
529 : 0 : return 0;
530 : : }
531 : :
532 : 0 : int ip_options_get_from_user(struct net *net, struct ip_options_rcu **optp,
533 : : unsigned char __user *data, int optlen)
534 : : {
535 : 0 : struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
536 : :
537 [ # # ]: 0 : if (!opt)
538 : : return -ENOMEM;
539 [ # # ][ # # ]: 0 : if (optlen && copy_from_user(opt->opt.__data, data, optlen)) {
540 : 0 : kfree(opt);
541 : 0 : return -EFAULT;
542 : : }
543 : 0 : return ip_options_get_finish(net, optp, opt, optlen);
544 : : }
545 : :
546 : 0 : int ip_options_get(struct net *net, struct ip_options_rcu **optp,
547 : : unsigned char *data, int optlen)
548 : : {
549 : 0 : struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
550 : :
551 [ # # ]: 0 : if (!opt)
552 : : return -ENOMEM;
553 [ # # ]: 0 : if (optlen)
554 : 0 : memcpy(opt->opt.__data, data, optlen);
555 : 0 : return ip_options_get_finish(net, optp, opt, optlen);
556 : : }
557 : :
558 : 0 : void ip_forward_options(struct sk_buff *skb)
559 : : {
560 : : struct ip_options *opt = &(IPCB(skb)->opt);
561 : : unsigned char *optptr;
562 : : struct rtable *rt = skb_rtable(skb);
563 : : unsigned char *raw = skb_network_header(skb);
564 : :
565 [ # # ]: 0 : if (opt->rr_needaddr) {
566 : 0 : optptr = (unsigned char *)raw + opt->rr;
567 : 0 : ip_rt_get_source(&optptr[optptr[2]-5], skb, rt);
568 : 0 : opt->is_changed = 1;
569 : : }
570 [ # # ]: 0 : if (opt->srr_is_hit) {
571 : : int srrptr, srrspace;
572 : :
573 : 0 : optptr = raw + opt->srr;
574 : :
575 [ # # ]: 0 : for ( srrptr = optptr[2], srrspace = optptr[1];
576 : : srrptr <= srrspace;
577 : 0 : srrptr += 4
578 : : ) {
579 [ # # ]: 0 : if (srrptr + 3 > srrspace)
580 : : break;
581 [ # # ]: 0 : if (memcmp(&opt->nexthop, &optptr[srrptr-1], 4) == 0)
582 : : break;
583 : : }
584 [ # # ]: 0 : if (srrptr + 3 <= srrspace) {
585 : 0 : opt->is_changed = 1;
586 : 0 : ip_hdr(skb)->daddr = opt->nexthop;
587 : 0 : ip_rt_get_source(&optptr[srrptr-1], skb, rt);
588 : 0 : optptr[2] = srrptr+4;
589 : : } else {
590 [ # # ]: 0 : net_crit_ratelimited("%s(): Argh! Destination lost!\n",
591 : : __func__);
592 : : }
593 [ # # ]: 0 : if (opt->ts_needaddr) {
594 : 0 : optptr = raw + opt->ts;
595 : 0 : ip_rt_get_source(&optptr[optptr[2]-9], skb, rt);
596 : 0 : opt->is_changed = 1;
597 : : }
598 : : }
599 [ # # ]: 0 : if (opt->is_changed) {
600 : 0 : opt->is_changed = 0;
601 : 0 : ip_send_check(ip_hdr(skb));
602 : : }
603 : 0 : }
604 : :
605 : 0 : int ip_options_rcv_srr(struct sk_buff *skb)
606 : : {
607 : : struct ip_options *opt = &(IPCB(skb)->opt);
608 : : int srrspace, srrptr;
609 : : __be32 nexthop;
610 : : struct iphdr *iph = ip_hdr(skb);
611 : 0 : unsigned char *optptr = skb_network_header(skb) + opt->srr;
612 : : struct rtable *rt = skb_rtable(skb);
613 : : struct rtable *rt2;
614 : : unsigned long orefdst;
615 : : int err;
616 : :
617 [ # # ]: 0 : if (!rt)
618 : : return 0;
619 : :
620 [ # # ]: 0 : if (skb->pkt_type != PACKET_HOST)
621 : : return -EINVAL;
622 [ # # ]: 0 : if (rt->rt_type == RTN_UNICAST) {
623 [ # # ]: 0 : if (!opt->is_strictroute)
624 : : return 0;
625 : 0 : icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl(16<<24));
626 : 0 : return -EINVAL;
627 : : }
628 [ # # ]: 0 : if (rt->rt_type != RTN_LOCAL)
629 : : return -EINVAL;
630 : :
631 [ # # ]: 0 : for (srrptr = optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
632 [ # # ]: 0 : if (srrptr + 3 > srrspace) {
633 [ # # ]: 0 : icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
634 : 0 : return -EINVAL;
635 : : }
636 : 0 : memcpy(&nexthop, &optptr[srrptr-1], 4);
637 : :
638 : 0 : orefdst = skb->_skb_refdst;
639 : : skb_dst_set(skb, NULL);
640 : 0 : err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
641 : : rt2 = skb_rtable(skb);
642 [ # # ][ # # ]: 0 : if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
643 : : skb_dst_drop(skb);
644 : 0 : skb->_skb_refdst = orefdst;
645 : 0 : return -EINVAL;
646 : : }
647 : : refdst_drop(orefdst);
648 [ # # ]: 0 : if (rt2->rt_type != RTN_LOCAL)
649 : : break;
650 : : /* Superfast 8) loopback forward */
651 : 0 : iph->daddr = nexthop;
652 : 0 : opt->is_changed = 1;
653 : : }
654 [ # # ]: 0 : if (srrptr <= srrspace) {
655 : 0 : opt->srr_is_hit = 1;
656 : 0 : opt->nexthop = nexthop;
657 : 0 : opt->is_changed = 1;
658 : : }
659 : : return 0;
660 : : }
661 : : EXPORT_SYMBOL(ip_options_rcv_srr);
|
