Linux Audio

Check our new training course

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