xref: /openbmc/linux/net/ipv6/exthdrs.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2  *	Extension Header handling for IPv6
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *	Andi Kleen		<ak@muc.de>
8  *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
9  *
10  *	This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License
12  *      as published by the Free Software Foundation; either version
13  *      2 of the License, or (at your option) any later version.
14  */
15 
16 /* Changes:
17  *	yoshfuji		: ensure not to overrun while parsing
18  *				  tlv options.
19  *	Mitsuru KANDA @USAGI and: Remove ipv6_parse_exthdrs().
20  *	YOSHIFUJI Hideaki @USAGI  Register inbound extension header
21  *				  handlers as inet6_protocol{}.
22  */
23 
24 #include <linux/errno.h>
25 #include <linux/types.h>
26 #include <linux/socket.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
29 #include <linux/netdevice.h>
30 #include <linux/in6.h>
31 #include <linux/icmpv6.h>
32 
33 #include <net/dst.h>
34 #include <net/sock.h>
35 #include <net/snmp.h>
36 
37 #include <net/ipv6.h>
38 #include <net/protocol.h>
39 #include <net/transp_v6.h>
40 #include <net/rawv6.h>
41 #include <net/ndisc.h>
42 #include <net/ip6_route.h>
43 #include <net/addrconf.h>
44 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
45 #include <net/xfrm.h>
46 #endif
47 
48 #include <asm/uaccess.h>
49 
50 int ipv6_find_tlv(struct sk_buff *skb, int offset, int type)
51 {
52 	const unsigned char *nh = skb_network_header(skb);
53 	int packet_len = skb->tail - skb->network_header;
54 	struct ipv6_opt_hdr *hdr;
55 	int len;
56 
57 	if (offset + 2 > packet_len)
58 		goto bad;
59 	hdr = (struct ipv6_opt_hdr *)(nh + offset);
60 	len = ((hdr->hdrlen + 1) << 3);
61 
62 	if (offset + len > packet_len)
63 		goto bad;
64 
65 	offset += 2;
66 	len -= 2;
67 
68 	while (len > 0) {
69 		int opttype = nh[offset];
70 		int optlen;
71 
72 		if (opttype == type)
73 			return offset;
74 
75 		switch (opttype) {
76 		case IPV6_TLV_PAD0:
77 			optlen = 1;
78 			break;
79 		default:
80 			optlen = nh[offset + 1] + 2;
81 			if (optlen > len)
82 				goto bad;
83 			break;
84 		}
85 		offset += optlen;
86 		len -= optlen;
87 	}
88 	/* not_found */
89  bad:
90 	return -1;
91 }
92 EXPORT_SYMBOL_GPL(ipv6_find_tlv);
93 
94 /*
95  *	Parsing tlv encoded headers.
96  *
97  *	Parsing function "func" returns 1, if parsing succeed
98  *	and 0, if it failed.
99  *	It MUST NOT touch skb->h.
100  */
101 
102 struct tlvtype_proc {
103 	int	type;
104 	int	(*func)(struct sk_buff *skb, int offset);
105 };
106 
107 /*********************
108   Generic functions
109  *********************/
110 
111 /* An unknown option is detected, decide what to do */
112 
113 static int ip6_tlvopt_unknown(struct sk_buff *skb, int optoff)
114 {
115 	switch ((skb_network_header(skb)[optoff] & 0xC0) >> 6) {
116 	case 0: /* ignore */
117 		return 1;
118 
119 	case 1: /* drop packet */
120 		break;
121 
122 	case 3: /* Send ICMP if not a multicast address and drop packet */
123 		/* Actually, it is redundant check. icmp_send
124 		   will recheck in any case.
125 		 */
126 		if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr))
127 			break;
128 	case 2: /* send ICMP PARM PROB regardless and drop packet */
129 		icmpv6_param_prob(skb, ICMPV6_UNK_OPTION, optoff);
130 		return 0;
131 	}
132 
133 	kfree_skb(skb);
134 	return 0;
135 }
136 
137 /* Parse tlv encoded option header (hop-by-hop or destination) */
138 
139 static int ip6_parse_tlv(struct tlvtype_proc *procs, struct sk_buff *skb)
140 {
141 	struct tlvtype_proc *curr;
142 	const unsigned char *nh = skb_network_header(skb);
143 	int off = skb_network_header_len(skb);
144 	int len = (skb_transport_header(skb)[1] + 1) << 3;
145 
146 	if (skb_transport_offset(skb) + len > skb_headlen(skb))
147 		goto bad;
148 
149 	off += 2;
150 	len -= 2;
151 
152 	while (len > 0) {
153 		int optlen = nh[off + 1] + 2;
154 
155 		switch (nh[off]) {
156 		case IPV6_TLV_PAD0:
157 			optlen = 1;
158 			break;
159 
160 		case IPV6_TLV_PADN:
161 			break;
162 
163 		default: /* Other TLV code so scan list */
164 			if (optlen > len)
165 				goto bad;
166 			for (curr=procs; curr->type >= 0; curr++) {
167 				if (curr->type == nh[off]) {
168 					/* type specific length/alignment
169 					   checks will be performed in the
170 					   func(). */
171 					if (curr->func(skb, off) == 0)
172 						return 0;
173 					break;
174 				}
175 			}
176 			if (curr->type < 0) {
177 				if (ip6_tlvopt_unknown(skb, off) == 0)
178 					return 0;
179 			}
180 			break;
181 		}
182 		off += optlen;
183 		len -= optlen;
184 	}
185 	if (len == 0)
186 		return 1;
187 bad:
188 	kfree_skb(skb);
189 	return 0;
190 }
191 
192 /*****************************
193   Destination options header.
194  *****************************/
195 
196 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
197 static int ipv6_dest_hao(struct sk_buff *skb, int optoff)
198 {
199 	struct ipv6_destopt_hao *hao;
200 	struct inet6_skb_parm *opt = IP6CB(skb);
201 	struct ipv6hdr *ipv6h = ipv6_hdr(skb);
202 	struct in6_addr tmp_addr;
203 	int ret;
204 
205 	if (opt->dsthao) {
206 		LIMIT_NETDEBUG(KERN_DEBUG "hao duplicated\n");
207 		goto discard;
208 	}
209 	opt->dsthao = opt->dst1;
210 	opt->dst1 = 0;
211 
212 	hao = (struct ipv6_destopt_hao *)(skb_network_header(skb) + optoff);
213 
214 	if (hao->length != 16) {
215 		LIMIT_NETDEBUG(
216 			KERN_DEBUG "hao invalid option length = %d\n", hao->length);
217 		goto discard;
218 	}
219 
220 	if (!(ipv6_addr_type(&hao->addr) & IPV6_ADDR_UNICAST)) {
221 		LIMIT_NETDEBUG(
222 			KERN_DEBUG "hao is not an unicast addr: %pI6\n", &hao->addr);
223 		goto discard;
224 	}
225 
226 	ret = xfrm6_input_addr(skb, (xfrm_address_t *)&ipv6h->daddr,
227 			       (xfrm_address_t *)&hao->addr, IPPROTO_DSTOPTS);
228 	if (unlikely(ret < 0))
229 		goto discard;
230 
231 	if (skb_cloned(skb)) {
232 		if (pskb_expand_head(skb, 0, 0, GFP_ATOMIC))
233 			goto discard;
234 
235 		/* update all variable using below by copied skbuff */
236 		hao = (struct ipv6_destopt_hao *)(skb_network_header(skb) +
237 						  optoff);
238 		ipv6h = ipv6_hdr(skb);
239 	}
240 
241 	if (skb->ip_summed == CHECKSUM_COMPLETE)
242 		skb->ip_summed = CHECKSUM_NONE;
243 
244 	ipv6_addr_copy(&tmp_addr, &ipv6h->saddr);
245 	ipv6_addr_copy(&ipv6h->saddr, &hao->addr);
246 	ipv6_addr_copy(&hao->addr, &tmp_addr);
247 
248 	if (skb->tstamp.tv64 == 0)
249 		__net_timestamp(skb);
250 
251 	return 1;
252 
253  discard:
254 	kfree_skb(skb);
255 	return 0;
256 }
257 #endif
258 
259 static struct tlvtype_proc tlvprocdestopt_lst[] = {
260 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
261 	{
262 		.type	= IPV6_TLV_HAO,
263 		.func	= ipv6_dest_hao,
264 	},
265 #endif
266 	{-1,			NULL}
267 };
268 
269 static int ipv6_destopt_rcv(struct sk_buff *skb)
270 {
271 	struct inet6_skb_parm *opt = IP6CB(skb);
272 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
273 	__u16 dstbuf;
274 #endif
275 	struct dst_entry *dst;
276 
277 	if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
278 	    !pskb_may_pull(skb, (skb_transport_offset(skb) +
279 				 ((skb_transport_header(skb)[1] + 1) << 3)))) {
280 		IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
281 				 IPSTATS_MIB_INHDRERRORS);
282 		kfree_skb(skb);
283 		return -1;
284 	}
285 
286 	opt->lastopt = opt->dst1 = skb_network_header_len(skb);
287 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
288 	dstbuf = opt->dst1;
289 #endif
290 
291 	dst = dst_clone(skb_dst(skb));
292 	if (ip6_parse_tlv(tlvprocdestopt_lst, skb)) {
293 		dst_release(dst);
294 		skb->transport_header += (skb_transport_header(skb)[1] + 1) << 3;
295 		opt = IP6CB(skb);
296 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
297 		opt->nhoff = dstbuf;
298 #else
299 		opt->nhoff = opt->dst1;
300 #endif
301 		return 1;
302 	}
303 
304 	IP6_INC_STATS_BH(dev_net(dst->dev),
305 			 ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS);
306 	dst_release(dst);
307 	return -1;
308 }
309 
310 /********************************
311   Routing header.
312  ********************************/
313 
314 static int ipv6_rthdr_rcv(struct sk_buff *skb)
315 {
316 	struct inet6_skb_parm *opt = IP6CB(skb);
317 	struct in6_addr *addr = NULL;
318 	struct in6_addr daddr;
319 	struct inet6_dev *idev;
320 	int n, i;
321 	struct ipv6_rt_hdr *hdr;
322 	struct rt0_hdr *rthdr;
323 	struct net *net = dev_net(skb->dev);
324 	int accept_source_route = net->ipv6.devconf_all->accept_source_route;
325 
326 	idev = in6_dev_get(skb->dev);
327 	if (idev) {
328 		if (accept_source_route > idev->cnf.accept_source_route)
329 			accept_source_route = idev->cnf.accept_source_route;
330 		in6_dev_put(idev);
331 	}
332 
333 	if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
334 	    !pskb_may_pull(skb, (skb_transport_offset(skb) +
335 				 ((skb_transport_header(skb)[1] + 1) << 3)))) {
336 		IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
337 				 IPSTATS_MIB_INHDRERRORS);
338 		kfree_skb(skb);
339 		return -1;
340 	}
341 
342 	hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb);
343 
344 	if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ||
345 	    skb->pkt_type != PACKET_HOST) {
346 		IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
347 				 IPSTATS_MIB_INADDRERRORS);
348 		kfree_skb(skb);
349 		return -1;
350 	}
351 
352 looped_back:
353 	if (hdr->segments_left == 0) {
354 		switch (hdr->type) {
355 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
356 		case IPV6_SRCRT_TYPE_2:
357 			/* Silently discard type 2 header unless it was
358 			 * processed by own
359 			 */
360 			if (!addr) {
361 				IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
362 						 IPSTATS_MIB_INADDRERRORS);
363 				kfree_skb(skb);
364 				return -1;
365 			}
366 			break;
367 #endif
368 		default:
369 			break;
370 		}
371 
372 		opt->lastopt = opt->srcrt = skb_network_header_len(skb);
373 		skb->transport_header += (hdr->hdrlen + 1) << 3;
374 		opt->dst0 = opt->dst1;
375 		opt->dst1 = 0;
376 		opt->nhoff = (&hdr->nexthdr) - skb_network_header(skb);
377 		return 1;
378 	}
379 
380 	switch (hdr->type) {
381 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
382 	case IPV6_SRCRT_TYPE_2:
383 		if (accept_source_route < 0)
384 			goto unknown_rh;
385 		/* Silently discard invalid RTH type 2 */
386 		if (hdr->hdrlen != 2 || hdr->segments_left != 1) {
387 			IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
388 					 IPSTATS_MIB_INHDRERRORS);
389 			kfree_skb(skb);
390 			return -1;
391 		}
392 		break;
393 #endif
394 	default:
395 		goto unknown_rh;
396 	}
397 
398 	/*
399 	 *	This is the routing header forwarding algorithm from
400 	 *	RFC 2460, page 16.
401 	 */
402 
403 	n = hdr->hdrlen >> 1;
404 
405 	if (hdr->segments_left > n) {
406 		IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
407 				 IPSTATS_MIB_INHDRERRORS);
408 		icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
409 				  ((&hdr->segments_left) -
410 				   skb_network_header(skb)));
411 		return -1;
412 	}
413 
414 	/* We are about to mangle packet header. Be careful!
415 	   Do not damage packets queued somewhere.
416 	 */
417 	if (skb_cloned(skb)) {
418 		/* the copy is a forwarded packet */
419 		if (pskb_expand_head(skb, 0, 0, GFP_ATOMIC)) {
420 			IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
421 					 IPSTATS_MIB_OUTDISCARDS);
422 			kfree_skb(skb);
423 			return -1;
424 		}
425 		hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb);
426 	}
427 
428 	if (skb->ip_summed == CHECKSUM_COMPLETE)
429 		skb->ip_summed = CHECKSUM_NONE;
430 
431 	i = n - --hdr->segments_left;
432 
433 	rthdr = (struct rt0_hdr *) hdr;
434 	addr = rthdr->addr;
435 	addr += i - 1;
436 
437 	switch (hdr->type) {
438 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
439 	case IPV6_SRCRT_TYPE_2:
440 		if (xfrm6_input_addr(skb, (xfrm_address_t *)addr,
441 				     (xfrm_address_t *)&ipv6_hdr(skb)->saddr,
442 				     IPPROTO_ROUTING) < 0) {
443 			IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
444 					 IPSTATS_MIB_INADDRERRORS);
445 			kfree_skb(skb);
446 			return -1;
447 		}
448 		if (!ipv6_chk_home_addr(dev_net(skb_dst(skb)->dev), addr)) {
449 			IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
450 					 IPSTATS_MIB_INADDRERRORS);
451 			kfree_skb(skb);
452 			return -1;
453 		}
454 		break;
455 #endif
456 	default:
457 		break;
458 	}
459 
460 	if (ipv6_addr_is_multicast(addr)) {
461 		IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
462 				 IPSTATS_MIB_INADDRERRORS);
463 		kfree_skb(skb);
464 		return -1;
465 	}
466 
467 	ipv6_addr_copy(&daddr, addr);
468 	ipv6_addr_copy(addr, &ipv6_hdr(skb)->daddr);
469 	ipv6_addr_copy(&ipv6_hdr(skb)->daddr, &daddr);
470 
471 	skb_dst_drop(skb);
472 	ip6_route_input(skb);
473 	if (skb_dst(skb)->error) {
474 		skb_push(skb, skb->data - skb_network_header(skb));
475 		dst_input(skb);
476 		return -1;
477 	}
478 
479 	if (skb_dst(skb)->dev->flags&IFF_LOOPBACK) {
480 		if (ipv6_hdr(skb)->hop_limit <= 1) {
481 			IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)),
482 					 IPSTATS_MIB_INHDRERRORS);
483 			icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
484 				    0, skb->dev);
485 			kfree_skb(skb);
486 			return -1;
487 		}
488 		ipv6_hdr(skb)->hop_limit--;
489 		goto looped_back;
490 	}
491 
492 	skb_push(skb, skb->data - skb_network_header(skb));
493 	dst_input(skb);
494 	return -1;
495 
496 unknown_rh:
497 	IP6_INC_STATS_BH(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_INHDRERRORS);
498 	icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
499 			  (&hdr->type) - skb_network_header(skb));
500 	return -1;
501 }
502 
503 static const struct inet6_protocol rthdr_protocol = {
504 	.handler	=	ipv6_rthdr_rcv,
505 	.flags		=	INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
506 };
507 
508 static const struct inet6_protocol destopt_protocol = {
509 	.handler	=	ipv6_destopt_rcv,
510 	.flags		=	INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
511 };
512 
513 static const struct inet6_protocol nodata_protocol = {
514 	.handler	=	dst_discard,
515 	.flags		=	INET6_PROTO_NOPOLICY,
516 };
517 
518 int __init ipv6_exthdrs_init(void)
519 {
520 	int ret;
521 
522 	ret = inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING);
523 	if (ret)
524 		goto out;
525 
526 	ret = inet6_add_protocol(&destopt_protocol, IPPROTO_DSTOPTS);
527 	if (ret)
528 		goto out_rthdr;
529 
530 	ret = inet6_add_protocol(&nodata_protocol, IPPROTO_NONE);
531 	if (ret)
532 		goto out_destopt;
533 
534 out:
535 	return ret;
536 out_rthdr:
537 	inet6_del_protocol(&rthdr_protocol, IPPROTO_ROUTING);
538 out_destopt:
539 	inet6_del_protocol(&destopt_protocol, IPPROTO_DSTOPTS);
540 	goto out;
541 };
542 
543 void ipv6_exthdrs_exit(void)
544 {
545 	inet6_del_protocol(&nodata_protocol, IPPROTO_NONE);
546 	inet6_del_protocol(&destopt_protocol, IPPROTO_DSTOPTS);
547 	inet6_del_protocol(&rthdr_protocol, IPPROTO_ROUTING);
548 }
549 
550 /**********************************
551   Hop-by-hop options.
552  **********************************/
553 
554 /*
555  * Note: we cannot rely on skb_dst(skb) before we assign it in ip6_route_input().
556  */
557 static inline struct inet6_dev *ipv6_skb_idev(struct sk_buff *skb)
558 {
559 	return skb_dst(skb) ? ip6_dst_idev(skb_dst(skb)) : __in6_dev_get(skb->dev);
560 }
561 
562 static inline struct net *ipv6_skb_net(struct sk_buff *skb)
563 {
564 	return skb_dst(skb) ? dev_net(skb_dst(skb)->dev) : dev_net(skb->dev);
565 }
566 
567 /* Router Alert as of RFC 2711 */
568 
569 static int ipv6_hop_ra(struct sk_buff *skb, int optoff)
570 {
571 	const unsigned char *nh = skb_network_header(skb);
572 
573 	if (nh[optoff + 1] == 2) {
574 		IP6CB(skb)->ra = optoff;
575 		return 1;
576 	}
577 	LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_ra: wrong RA length %d\n",
578 		       nh[optoff + 1]);
579 	kfree_skb(skb);
580 	return 0;
581 }
582 
583 /* Jumbo payload */
584 
585 static int ipv6_hop_jumbo(struct sk_buff *skb, int optoff)
586 {
587 	const unsigned char *nh = skb_network_header(skb);
588 	struct net *net = ipv6_skb_net(skb);
589 	u32 pkt_len;
590 
591 	if (nh[optoff + 1] != 4 || (optoff & 3) != 2) {
592 		LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n",
593 			       nh[optoff+1]);
594 		IP6_INC_STATS_BH(net, ipv6_skb_idev(skb),
595 				 IPSTATS_MIB_INHDRERRORS);
596 		goto drop;
597 	}
598 
599 	pkt_len = ntohl(*(__be32 *)(nh + optoff + 2));
600 	if (pkt_len <= IPV6_MAXPLEN) {
601 		IP6_INC_STATS_BH(net, ipv6_skb_idev(skb),
602 				 IPSTATS_MIB_INHDRERRORS);
603 		icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff+2);
604 		return 0;
605 	}
606 	if (ipv6_hdr(skb)->payload_len) {
607 		IP6_INC_STATS_BH(net, ipv6_skb_idev(skb),
608 				 IPSTATS_MIB_INHDRERRORS);
609 		icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff);
610 		return 0;
611 	}
612 
613 	if (pkt_len > skb->len - sizeof(struct ipv6hdr)) {
614 		IP6_INC_STATS_BH(net, ipv6_skb_idev(skb),
615 				 IPSTATS_MIB_INTRUNCATEDPKTS);
616 		goto drop;
617 	}
618 
619 	if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr)))
620 		goto drop;
621 
622 	return 1;
623 
624 drop:
625 	kfree_skb(skb);
626 	return 0;
627 }
628 
629 static struct tlvtype_proc tlvprochopopt_lst[] = {
630 	{
631 		.type	= IPV6_TLV_ROUTERALERT,
632 		.func	= ipv6_hop_ra,
633 	},
634 	{
635 		.type	= IPV6_TLV_JUMBO,
636 		.func	= ipv6_hop_jumbo,
637 	},
638 	{ -1, }
639 };
640 
641 int ipv6_parse_hopopts(struct sk_buff *skb)
642 {
643 	struct inet6_skb_parm *opt = IP6CB(skb);
644 
645 	/*
646 	 * skb_network_header(skb) is equal to skb->data, and
647 	 * skb_network_header_len(skb) is always equal to
648 	 * sizeof(struct ipv6hdr) by definition of
649 	 * hop-by-hop options.
650 	 */
651 	if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + 8) ||
652 	    !pskb_may_pull(skb, (sizeof(struct ipv6hdr) +
653 				 ((skb_transport_header(skb)[1] + 1) << 3)))) {
654 		kfree_skb(skb);
655 		return -1;
656 	}
657 
658 	opt->hop = sizeof(struct ipv6hdr);
659 	if (ip6_parse_tlv(tlvprochopopt_lst, skb)) {
660 		skb->transport_header += (skb_transport_header(skb)[1] + 1) << 3;
661 		opt = IP6CB(skb);
662 		opt->nhoff = sizeof(struct ipv6hdr);
663 		return 1;
664 	}
665 	return -1;
666 }
667 
668 /*
669  *	Creating outbound headers.
670  *
671  *	"build" functions work when skb is filled from head to tail (datagram)
672  *	"push"	functions work when headers are added from tail to head (tcp)
673  *
674  *	In both cases we assume, that caller reserved enough room
675  *	for headers.
676  */
677 
678 static void ipv6_push_rthdr(struct sk_buff *skb, u8 *proto,
679 			    struct ipv6_rt_hdr *opt,
680 			    struct in6_addr **addr_p)
681 {
682 	struct rt0_hdr *phdr, *ihdr;
683 	int hops;
684 
685 	ihdr = (struct rt0_hdr *) opt;
686 
687 	phdr = (struct rt0_hdr *) skb_push(skb, (ihdr->rt_hdr.hdrlen + 1) << 3);
688 	memcpy(phdr, ihdr, sizeof(struct rt0_hdr));
689 
690 	hops = ihdr->rt_hdr.hdrlen >> 1;
691 
692 	if (hops > 1)
693 		memcpy(phdr->addr, ihdr->addr + 1,
694 		       (hops - 1) * sizeof(struct in6_addr));
695 
696 	ipv6_addr_copy(phdr->addr + (hops - 1), *addr_p);
697 	*addr_p = ihdr->addr;
698 
699 	phdr->rt_hdr.nexthdr = *proto;
700 	*proto = NEXTHDR_ROUTING;
701 }
702 
703 static void ipv6_push_exthdr(struct sk_buff *skb, u8 *proto, u8 type, struct ipv6_opt_hdr *opt)
704 {
705 	struct ipv6_opt_hdr *h = (struct ipv6_opt_hdr *)skb_push(skb, ipv6_optlen(opt));
706 
707 	memcpy(h, opt, ipv6_optlen(opt));
708 	h->nexthdr = *proto;
709 	*proto = type;
710 }
711 
712 void ipv6_push_nfrag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt,
713 			  u8 *proto,
714 			  struct in6_addr **daddr)
715 {
716 	if (opt->srcrt) {
717 		ipv6_push_rthdr(skb, proto, opt->srcrt, daddr);
718 		/*
719 		 * IPV6_RTHDRDSTOPTS is ignored
720 		 * unless IPV6_RTHDR is set (RFC3542).
721 		 */
722 		if (opt->dst0opt)
723 			ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst0opt);
724 	}
725 	if (opt->hopopt)
726 		ipv6_push_exthdr(skb, proto, NEXTHDR_HOP, opt->hopopt);
727 }
728 
729 EXPORT_SYMBOL(ipv6_push_nfrag_opts);
730 
731 void ipv6_push_frag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt, u8 *proto)
732 {
733 	if (opt->dst1opt)
734 		ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst1opt);
735 }
736 
737 struct ipv6_txoptions *
738 ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt)
739 {
740 	struct ipv6_txoptions *opt2;
741 
742 	opt2 = sock_kmalloc(sk, opt->tot_len, GFP_ATOMIC);
743 	if (opt2) {
744 		long dif = (char*)opt2 - (char*)opt;
745 		memcpy(opt2, opt, opt->tot_len);
746 		if (opt2->hopopt)
747 			*((char**)&opt2->hopopt) += dif;
748 		if (opt2->dst0opt)
749 			*((char**)&opt2->dst0opt) += dif;
750 		if (opt2->dst1opt)
751 			*((char**)&opt2->dst1opt) += dif;
752 		if (opt2->srcrt)
753 			*((char**)&opt2->srcrt) += dif;
754 	}
755 	return opt2;
756 }
757 
758 EXPORT_SYMBOL_GPL(ipv6_dup_options);
759 
760 static int ipv6_renew_option(void *ohdr,
761 			     struct ipv6_opt_hdr __user *newopt, int newoptlen,
762 			     int inherit,
763 			     struct ipv6_opt_hdr **hdr,
764 			     char **p)
765 {
766 	if (inherit) {
767 		if (ohdr) {
768 			memcpy(*p, ohdr, ipv6_optlen((struct ipv6_opt_hdr *)ohdr));
769 			*hdr = (struct ipv6_opt_hdr *)*p;
770 			*p += CMSG_ALIGN(ipv6_optlen(*(struct ipv6_opt_hdr **)hdr));
771 		}
772 	} else {
773 		if (newopt) {
774 			if (copy_from_user(*p, newopt, newoptlen))
775 				return -EFAULT;
776 			*hdr = (struct ipv6_opt_hdr *)*p;
777 			if (ipv6_optlen(*(struct ipv6_opt_hdr **)hdr) > newoptlen)
778 				return -EINVAL;
779 			*p += CMSG_ALIGN(newoptlen);
780 		}
781 	}
782 	return 0;
783 }
784 
785 struct ipv6_txoptions *
786 ipv6_renew_options(struct sock *sk, struct ipv6_txoptions *opt,
787 		   int newtype,
788 		   struct ipv6_opt_hdr __user *newopt, int newoptlen)
789 {
790 	int tot_len = 0;
791 	char *p;
792 	struct ipv6_txoptions *opt2;
793 	int err;
794 
795 	if (opt) {
796 		if (newtype != IPV6_HOPOPTS && opt->hopopt)
797 			tot_len += CMSG_ALIGN(ipv6_optlen(opt->hopopt));
798 		if (newtype != IPV6_RTHDRDSTOPTS && opt->dst0opt)
799 			tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst0opt));
800 		if (newtype != IPV6_RTHDR && opt->srcrt)
801 			tot_len += CMSG_ALIGN(ipv6_optlen(opt->srcrt));
802 		if (newtype != IPV6_DSTOPTS && opt->dst1opt)
803 			tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst1opt));
804 	}
805 
806 	if (newopt && newoptlen)
807 		tot_len += CMSG_ALIGN(newoptlen);
808 
809 	if (!tot_len)
810 		return NULL;
811 
812 	tot_len += sizeof(*opt2);
813 	opt2 = sock_kmalloc(sk, tot_len, GFP_ATOMIC);
814 	if (!opt2)
815 		return ERR_PTR(-ENOBUFS);
816 
817 	memset(opt2, 0, tot_len);
818 
819 	opt2->tot_len = tot_len;
820 	p = (char *)(opt2 + 1);
821 
822 	err = ipv6_renew_option(opt ? opt->hopopt : NULL, newopt, newoptlen,
823 				newtype != IPV6_HOPOPTS,
824 				&opt2->hopopt, &p);
825 	if (err)
826 		goto out;
827 
828 	err = ipv6_renew_option(opt ? opt->dst0opt : NULL, newopt, newoptlen,
829 				newtype != IPV6_RTHDRDSTOPTS,
830 				&opt2->dst0opt, &p);
831 	if (err)
832 		goto out;
833 
834 	err = ipv6_renew_option(opt ? opt->srcrt : NULL, newopt, newoptlen,
835 				newtype != IPV6_RTHDR,
836 				(struct ipv6_opt_hdr **)&opt2->srcrt, &p);
837 	if (err)
838 		goto out;
839 
840 	err = ipv6_renew_option(opt ? opt->dst1opt : NULL, newopt, newoptlen,
841 				newtype != IPV6_DSTOPTS,
842 				&opt2->dst1opt, &p);
843 	if (err)
844 		goto out;
845 
846 	opt2->opt_nflen = (opt2->hopopt ? ipv6_optlen(opt2->hopopt) : 0) +
847 			  (opt2->dst0opt ? ipv6_optlen(opt2->dst0opt) : 0) +
848 			  (opt2->srcrt ? ipv6_optlen(opt2->srcrt) : 0);
849 	opt2->opt_flen = (opt2->dst1opt ? ipv6_optlen(opt2->dst1opt) : 0);
850 
851 	return opt2;
852 out:
853 	sock_kfree_s(sk, opt2, opt2->tot_len);
854 	return ERR_PTR(err);
855 }
856 
857 struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space,
858 					  struct ipv6_txoptions *opt)
859 {
860 	/*
861 	 * ignore the dest before srcrt unless srcrt is being included.
862 	 * --yoshfuji
863 	 */
864 	if (opt && opt->dst0opt && !opt->srcrt) {
865 		if (opt_space != opt) {
866 			memcpy(opt_space, opt, sizeof(*opt_space));
867 			opt = opt_space;
868 		}
869 		opt->opt_nflen -= ipv6_optlen(opt->dst0opt);
870 		opt->dst0opt = NULL;
871 	}
872 
873 	return opt;
874 }
875 
876