projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[IPV6] ADDRCONF: Convert ipv6_get_saddr() to ipv6_dev_get_saddr().
[deliverable/linux.git] / net / ipv6 / ipv6_sockglue.c
CommitLineData
1da177e4
LT		 1/*
2 * IPv6 BSD socket options interface
1ab1457c 3 * Linux INET6 implementation
1da177e4
LT		 4 *
5 * Authors:
1ab1457c 6 * Pedro Roque <roque@di.fc.ul.pt>
1da177e4
LT		 7 *
8 * Based on linux/net/ipv4/ip_sockglue.c
9 *
10 * $Id: ipv6_sockglue.c,v 1.41 2002/02/01 22:01:04 davem Exp $
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 *
17 * FIXME: Make the setsockopt code POSIX compliant: That is
18 *
19 * o Return -EINVAL for setsockopt of short lengths
20 * o Truncate getsockopt returns
21 * o Return an optlen of the truncated length if need be
22 *
23 * Changes:
24 * David L Stevens <dlstevens@us.ibm.com>:
25 * - added multicast source filtering API for MLDv2
26 */
27
28#include <linux/module.h>
4fc268d2 29#include <linux/capability.h>
1da177e4
LT		 30#include <linux/errno.h>
31#include <linux/types.h>
32#include <linux/socket.h>
33#include <linux/sockios.h>
1da177e4
LT		 34#include <linux/net.h>
35#include <linux/in6.h>
36#include <linux/netdevice.h>
37#include <linux/if_arp.h>
38#include <linux/init.h>
39#include <linux/sysctl.h>
40#include <linux/netfilter.h>
41
42#include <net/sock.h>
43#include <net/snmp.h>
44#include <net/ipv6.h>
45#include <net/ndisc.h>
46#include <net/protocol.h>
47#include <net/transp_v6.h>
48#include <net/ip6_route.h>
49#include <net/addrconf.h>
50#include <net/inet_common.h>
51#include <net/tcp.h>
52#include <net/udp.h>
ba4e58ec 53#include <net/udplite.h>
1da177e4
LT		 54#include <net/xfrm.h>
55
56#include <asm/uaccess.h>
57
ba89966c 58DEFINE_SNMP_STAT(struct ipstats_mib, ipv6_statistics) __read_mostly;
1da177e4 59
1da177e4
LT		 60struct ip6_ra_chain *ip6_ra_chain;
61DEFINE_RWLOCK(ip6_ra_lock);
62
63int ip6_ra_control(struct sock *sk, int sel, void (*destructor)(struct sock *))
64{
65 struct ip6_ra_chain *ra, *new_ra, **rap;
66
67 /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
68 if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num != IPPROTO_RAW)
69 return -EINVAL;
70
71 new_ra = (sel>=0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
72
73 write_lock_bh(&ip6_ra_lock);
74 for (rap = &ip6_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
75 if (ra->sk == sk) {
76 if (sel>=0) {
77 write_unlock_bh(&ip6_ra_lock);
a51482bd 78 kfree(new_ra);
1da177e4
LT		 79 return -EADDRINUSE;
80 }
81
82 *rap = ra->next;
83 write_unlock_bh(&ip6_ra_lock);
84
85 if (ra->destructor)
86 ra->destructor(sk);
87 sock_put(sk);
88 kfree(ra);
89 return 0;
90 }
91 }
92 if (new_ra == NULL) {
93 write_unlock_bh(&ip6_ra_lock);
94 return -ENOBUFS;
95 }
96 new_ra->sk = sk;
97 new_ra->sel = sel;
98 new_ra->destructor = destructor;
99 new_ra->next = ra;
100 *rap = new_ra;
101 sock_hold(sk);
102 write_unlock_bh(&ip6_ra_lock);
103 return 0;
104}
105
3fdadf7d 106static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
1da177e4
LT		 107 char __user *optval, int optlen)
108{
109 struct ipv6_pinfo *np = inet6_sk(sk);
110 int val, valbool;
111 int retv = -ENOPROTOOPT;
112
1da177e4
LT		 113 if (optval == NULL)
114 val=0;
115 else if (get_user(val, (int __user *) optval))
116 return -EFAULT;
117
118 valbool = (val!=0);
119
120 lock_sock(sk);
121
122 switch (optname) {
123
124 case IPV6_ADDRFORM:
125 if (val == PF_INET) {
126 struct ipv6_txoptions *opt;
127 struct sk_buff *pktopt;
128
129 if (sk->sk_protocol != IPPROTO_UDP &&
e898d4db 130#ifdef CONFIG_IP_UDPLITE
ba4e58ec 131 sk->sk_protocol != IPPROTO_UDPLITE &&
e898d4db 132#endif
1da177e4
LT		 133 sk->sk_protocol != IPPROTO_TCP)
134 break;
135
136 if (sk->sk_state != TCP_ESTABLISHED) {
137 retv = -ENOTCONN;
138 break;
139 }
140
141 if (ipv6_only_sock(sk) ||
e773e4fa 142 !ipv6_addr_v4mapped(&np->daddr)) {
1da177e4
LT		 143 retv = -EADDRNOTAVAIL;
144 break;
145 }
146
147 fl6_free_socklist(sk);
148 ipv6_sock_mc_close(sk);
149
e6848976
ACM		 150 /*
151 * Sock is moving from IPv6 to IPv4 (sk_prot), so
152 * remove it from the refcnt debug socks count in the
153 * original family...
154 */
155 sk_refcnt_debug_dec(sk);
156
1da177e4 157 if (sk->sk_protocol == IPPROTO_TCP) {
d83d8461 158 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 159
160 local_bh_disable();
65f76517
ED		 161 sock_prot_inuse_add(sk->sk_prot, -1);
162 sock_prot_inuse_add(&tcp_prot, 1);
1da177e4
LT		 163 local_bh_enable();
164 sk->sk_prot = &tcp_prot;
d83d8461 165 icsk->icsk_af_ops = &ipv4_specific;
1da177e4
LT		 166 sk->sk_socket->ops = &inet_stream_ops;
167 sk->sk_family = PF_INET;
d83d8461 168 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
1da177e4 169 } else {
ba4e58ec
GR		 170 struct proto *prot = &udp_prot;
171
e898d4db 172 if (IS_PROTO_UDPLITE(sk->sk_protocol))
ba4e58ec 173 prot = &udplite_prot;
1da177e4 174 local_bh_disable();
65f76517
ED		 175 sock_prot_inuse_add(sk->sk_prot, -1);
176 sock_prot_inuse_add(prot, 1);
1da177e4 177 local_bh_enable();
ba4e58ec 178 sk->sk_prot = prot;
1da177e4
LT		 179 sk->sk_socket->ops = &inet_dgram_ops;
180 sk->sk_family = PF_INET;
181 }
182 opt = xchg(&np->opt, NULL);
183 if (opt)
184 sock_kfree_s(sk, opt, opt->tot_len);
185 pktopt = xchg(&np->pktoptions, NULL);
186 if (pktopt)
187 kfree_skb(pktopt);
188
189 sk->sk_destruct = inet_sock_destruct;
e6848976
ACM		 190 /*
191 * ... and add it to the refcnt debug socks count
192 * in the new family. -acme
193 */
194 sk_refcnt_debug_inc(sk);
1da177e4
LT		 195 module_put(THIS_MODULE);
196 retv = 0;
197 break;
198 }
199 goto e_inval;
200
201 case IPV6_V6ONLY:
202 if (inet_sk(sk)->num)
203 goto e_inval;
204 np->ipv6only = valbool;
205 retv = 0;
206 break;
207
333fad53 208 case IPV6_RECVPKTINFO:
1da177e4
LT		 209 np->rxopt.bits.rxinfo = valbool;
210 retv = 0;
211 break;
1ab1457c 212
333fad53
YH		 213 case IPV6_2292PKTINFO:
214 np->rxopt.bits.rxoinfo = valbool;
215 retv = 0;
216 break;
1da177e4 217
333fad53 218 case IPV6_RECVHOPLIMIT:
1da177e4
LT		 219 np->rxopt.bits.rxhlim = valbool;
220 retv = 0;
221 break;
222
333fad53
YH		 223 case IPV6_2292HOPLIMIT:
224 np->rxopt.bits.rxohlim = valbool;
225 retv = 0;
226 break;
227
228 case IPV6_RECVRTHDR:
4c752098 229 np->rxopt.bits.srcrt = valbool;
1da177e4
LT		 230 retv = 0;
231 break;
232
333fad53 233 case IPV6_2292RTHDR:
4c752098 234 np->rxopt.bits.osrcrt = valbool;
333fad53
YH		 235 retv = 0;
236 break;
237
238 case IPV6_RECVHOPOPTS:
1da177e4
LT		 239 np->rxopt.bits.hopopts = valbool;
240 retv = 0;
241 break;
242
333fad53
YH		 243 case IPV6_2292HOPOPTS:
244 np->rxopt.bits.ohopopts = valbool;
245 retv = 0;
246 break;
247
248 case IPV6_RECVDSTOPTS:
1da177e4
LT		 249 np->rxopt.bits.dstopts = valbool;
250 retv = 0;
251 break;
252
333fad53
YH		 253 case IPV6_2292DSTOPTS:
254 np->rxopt.bits.odstopts = valbool;
255 retv = 0;
256 break;
257
41a1f8ea 258 case IPV6_TCLASS:
d0ee011f 259 if (val < -1 || val > 0xff)
41a1f8ea
YH		 260 goto e_inval;
261 np->tclass = val;
262 retv = 0;
263 break;
1ab1457c 264
41a1f8ea
YH		 265 case IPV6_RECVTCLASS:
266 np->rxopt.bits.rxtclass = valbool;
267 retv = 0;
268 break;
269
1da177e4
LT		 270 case IPV6_FLOWINFO:
271 np->rxopt.bits.rxflow = valbool;
272 retv = 0;
273 break;
274
333fad53
YH		 275 case IPV6_HOPOPTS:
276 case IPV6_RTHDRDSTOPTS:
277 case IPV6_RTHDR:
278 case IPV6_DSTOPTS:
279 {
280 struct ipv6_txoptions *opt;
281 if (optlen == 0)
cb422c46 282 optval = NULL;
333fad53
YH		 283
284 /* hop-by-hop / destination options are privileged option */
285 retv = -EPERM;
286 if (optname != IPV6_RTHDR && !capable(CAP_NET_RAW))
287 break;
288
289 retv = -EINVAL;
290 if (optlen & 0x7 || optlen > 8 * 255)
291 break;
292
293 opt = ipv6_renew_options(sk, np->opt, optname,
294 (struct ipv6_opt_hdr __user *)optval,
295 optlen);
296 if (IS_ERR(opt)) {
297 retv = PTR_ERR(opt);
298 break;
299 }
300
301 /* routing header option needs extra check */
dfee0a72 302 if (optname == IPV6_RTHDR && opt && opt->srcrt) {
333fad53 303 struct ipv6_rt_hdr *rthdr = opt->srcrt;
280a9d34 304 switch (rthdr->type) {
59fbb3a6 305#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
280a9d34 306 case IPV6_SRCRT_TYPE_2:
280a9d34 307 break;
bb4dbf9e 308#endif
280a9d34 309 default:
333fad53 310 goto sticky_done;
280a9d34
MN		 311 }
312
333fad53
YH		 313 if ((rthdr->hdrlen & 1) ||
314 (rthdr->hdrlen >> 1) != rthdr->segments_left)
315 goto sticky_done;
316 }
317
318 retv = 0;
d83d8461 319 if (inet_sk(sk)->is_icsk) {
333fad53 320 if (opt) {
d83d8461 321 struct inet_connection_sock *icsk = inet_csk(sk);
333fad53
YH		 322 if (!((1 << sk->sk_state) &
323 (TCPF_LISTEN | TCPF_CLOSE))
324 && inet_sk(sk)->daddr != LOOPBACK4_IPV6) {
d83d8461
ACM		 325 icsk->icsk_ext_hdr_len =
326 opt->opt_flen + opt->opt_nflen;
327 icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
333fad53
YH		 328 }
329 }
330 opt = xchg(&np->opt, opt);
331 sk_dst_reset(sk);
332 } else {
333 write_lock(&sk->sk_dst_lock);
334 opt = xchg(&np->opt, opt);
335 write_unlock(&sk->sk_dst_lock);
336 sk_dst_reset(sk);
337 }
338sticky_done:
339 if (opt)
340 sock_kfree_s(sk, opt, opt->tot_len);
341 break;
342 }
343
344 case IPV6_2292PKTOPTIONS:
1da177e4
LT		 345 {
346 struct ipv6_txoptions *opt = NULL;
347 struct msghdr msg;
348 struct flowi fl;
349 int junk;
350
351 fl.fl6_flowlabel = 0;
352 fl.oif = sk->sk_bound_dev_if;
353
354 if (optlen == 0)
355 goto update;
356
357 /* 1K is probably excessive
358 * 1K is surely not enough, 2K per standard header is 16K.
359 */
360 retv = -EINVAL;
361 if (optlen > 64*1024)
362 break;
363
364 opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
365 retv = -ENOBUFS;
366 if (opt == NULL)
367 break;
368
369 memset(opt, 0, sizeof(*opt));
370 opt->tot_len = sizeof(*opt) + optlen;
371 retv = -EFAULT;
372 if (copy_from_user(opt+1, optval, optlen))
373 goto done;
374
375 msg.msg_controllen = optlen;
376 msg.msg_control = (void*)(opt+1);
377
41a1f8ea 378 retv = datagram_send_ctl(&msg, &fl, opt, &junk, &junk);
1da177e4
LT		 379 if (retv)
380 goto done;
381update:
382 retv = 0;
d83d8461 383 if (inet_sk(sk)->is_icsk) {
1da177e4 384 if (opt) {
d83d8461 385 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT		 386 if (!((1 << sk->sk_state) &
387 (TCPF_LISTEN | TCPF_CLOSE))
388 && inet_sk(sk)->daddr != LOOPBACK4_IPV6) {
d83d8461
ACM		 389 icsk->icsk_ext_hdr_len =
390 opt->opt_flen + opt->opt_nflen;
391 icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
1da177e4
LT		 392 }
393 }
394 opt = xchg(&np->opt, opt);
395 sk_dst_reset(sk);
396 } else {
397 write_lock(&sk->sk_dst_lock);
398 opt = xchg(&np->opt, opt);
399 write_unlock(&sk->sk_dst_lock);
400 sk_dst_reset(sk);
401 }
402
403done:
404 if (opt)
405 sock_kfree_s(sk, opt, opt->tot_len);
406 break;
407 }
408 case IPV6_UNICAST_HOPS:
409 if (val > 255 || val < -1)
410 goto e_inval;
411 np->hop_limit = val;
412 retv = 0;
413 break;
414
415 case IPV6_MULTICAST_HOPS:
416 if (sk->sk_type == SOCK_STREAM)
417 goto e_inval;
418 if (val > 255 || val < -1)
419 goto e_inval;
420 np->mcast_hops = val;
421 retv = 0;
422 break;
423
424 case IPV6_MULTICAST_LOOP:
425 np->mc_loop = valbool;
426 retv = 0;
427 break;
428
429 case IPV6_MULTICAST_IF:
430 if (sk->sk_type == SOCK_STREAM)
431 goto e_inval;
1da177e4 432
4953f0fc
BH		 433 if (val) {
434 if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != val)
435 goto e_inval;
436
437 if (__dev_get_by_index(&init_net, val) == NULL) {
438 retv = -ENODEV;
439 break;
440 }
1da177e4
LT		 441 }
442 np->mcast_oif = val;
443 retv = 0;
444 break;
445 case IPV6_ADD_MEMBERSHIP:
446 case IPV6_DROP_MEMBERSHIP:
447 {
448 struct ipv6_mreq mreq;
449
a96fb49b
FL		 450 retv = -EPROTO;
451 if (inet_sk(sk)->is_icsk)
452 break;
453
1da177e4
LT		 454 retv = -EFAULT;
455 if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
456 break;
457
458 if (optname == IPV6_ADD_MEMBERSHIP)
459 retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
460 else
461 retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
462 break;
463 }
464 case IPV6_JOIN_ANYCAST:
465 case IPV6_LEAVE_ANYCAST:
466 {
467 struct ipv6_mreq mreq;
468
469 if (optlen != sizeof(struct ipv6_mreq))
470 goto e_inval;
471
472 retv = -EFAULT;
473 if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
474 break;
475
476 if (optname == IPV6_JOIN_ANYCAST)
477 retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
478 else
479 retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
480 break;
481 }
482 case MCAST_JOIN_GROUP:
483 case MCAST_LEAVE_GROUP:
484 {
485 struct group_req greq;
486 struct sockaddr_in6 *psin6;
487
488 retv = -EFAULT;
489 if (copy_from_user(&greq, optval, sizeof(struct group_req)))
490 break;
491 if (greq.gr_group.ss_family != AF_INET6) {
492 retv = -EADDRNOTAVAIL;
493 break;
494 }
495 psin6 = (struct sockaddr_in6 *)&greq.gr_group;
496 if (optname == MCAST_JOIN_GROUP)
497 retv = ipv6_sock_mc_join(sk, greq.gr_interface,
498 &psin6->sin6_addr);
499 else
500 retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
501 &psin6->sin6_addr);
502 break;
503 }
504 case MCAST_JOIN_SOURCE_GROUP:
505 case MCAST_LEAVE_SOURCE_GROUP:
506 case MCAST_BLOCK_SOURCE:
507 case MCAST_UNBLOCK_SOURCE:
508 {
509 struct group_source_req greqs;
510 int omode, add;
511
512 if (optlen != sizeof(struct group_source_req))
513 goto e_inval;
514 if (copy_from_user(&greqs, optval, sizeof(greqs))) {
515 retv = -EFAULT;
516 break;
517 }
518 if (greqs.gsr_group.ss_family != AF_INET6 ||
519 greqs.gsr_source.ss_family != AF_INET6) {
520 retv = -EADDRNOTAVAIL;
521 break;
522 }
523 if (optname == MCAST_BLOCK_SOURCE) {
524 omode = MCAST_EXCLUDE;
525 add = 1;
526 } else if (optname == MCAST_UNBLOCK_SOURCE) {
527 omode = MCAST_EXCLUDE;
528 add = 0;
529 } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
530 struct sockaddr_in6 *psin6;
531
532 psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
533 retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,
534 &psin6->sin6_addr);
c9e3e8b6
DS		 535 /* prior join w/ different source is ok */
536 if (retv && retv != -EADDRINUSE)
1da177e4
LT		 537 break;
538 omode = MCAST_INCLUDE;
539 add = 1;
c9e3e8b6 540 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
1da177e4
LT		 541 omode = MCAST_INCLUDE;
542 add = 0;
543 }
544 retv = ip6_mc_source(add, omode, sk, &greqs);
545 break;
546 }
547 case MCAST_MSFILTER:
548 {
1da177e4
LT		 549 extern int sysctl_mld_max_msf;
550 struct group_filter *gsf;
551
552 if (optlen < GROUP_FILTER_SIZE(0))
553 goto e_inval;
554 if (optlen > sysctl_optmem_max) {
555 retv = -ENOBUFS;
556 break;
557 }
8b3a7005 558 gsf = kmalloc(optlen,GFP_KERNEL);
cfcabdcc 559 if (!gsf) {
1da177e4
LT		 560 retv = -ENOBUFS;
561 break;
562 }
563 retv = -EFAULT;
564 if (copy_from_user(gsf, optval, optlen)) {
565 kfree(gsf);
566 break;
567 }
568 /* numsrc >= (4G-140)/128 overflow in 32 bits */
569 if (gsf->gf_numsrc >= 0x1ffffffU ||
570 gsf->gf_numsrc > sysctl_mld_max_msf) {
571 kfree(gsf);
572 retv = -ENOBUFS;
573 break;
574 }
575 if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
576 kfree(gsf);
577 retv = -EINVAL;
578 break;
579 }
580 retv = ip6_mc_msfilter(sk, gsf);
581 kfree(gsf);
582
583 break;
584 }
585 case IPV6_ROUTER_ALERT:
586 retv = ip6_ra_control(sk, val, NULL);
587 break;
588 case IPV6_MTU_DISCOVER:
628a5c56 589 if (val<0 || val>3)
1da177e4
LT		 590 goto e_inval;
591 np->pmtudisc = val;
592 retv = 0;
593 break;
594 case IPV6_MTU:
595 if (val && val < IPV6_MIN_MTU)
596 goto e_inval;
597 np->frag_size = val;
598 retv = 0;
599 break;
600 case IPV6_RECVERR:
601 np->recverr = valbool;
602 if (!val)
603 skb_queue_purge(&sk->sk_error_queue);
604 retv = 0;
605 break;
606 case IPV6_FLOWINFO_SEND:
607 np->sndflow = valbool;
608 retv = 0;
609 break;
610 case IPV6_FLOWLABEL_MGR:
611 retv = ipv6_flowlabel_opt(sk, optval, optlen);
612 break;
613 case IPV6_IPSEC_POLICY:
614 case IPV6_XFRM_POLICY:
6fc0b4a7
HX		 615 retv = -EPERM;
616 if (!capable(CAP_NET_ADMIN))
617 break;
1da177e4
LT		 618 retv = xfrm_user_policy(sk, optname, optval, optlen);
619 break;
620
1da177e4
LT		 621 }
622 release_sock(sk);
623
1da177e4
LT		 624 return retv;
625
626e_inval:
627 release_sock(sk);
628 return -EINVAL;
629}
630
3fdadf7d
DM		 631int ipv6_setsockopt(struct sock *sk, int level, int optname,
632 char __user *optval, int optlen)
633{
634 int err;
635
636 if (level == SOL_IP && sk->sk_type != SOCK_RAW)
637 return udp_prot.setsockopt(sk, level, optname, optval, optlen);
638
639 if (level != SOL_IPV6)
640 return -ENOPROTOOPT;
641
642 err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
643#ifdef CONFIG_NETFILTER
644 /* we need to exclude all possible ENOPROTOOPTs except default case */
645 if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
646 optname != IPV6_XFRM_POLICY) {
647 lock_sock(sk);
648 err = nf_setsockopt(sk, PF_INET6, optname, optval,
649 optlen);
650 release_sock(sk);
651 }
652#endif
653 return err;
654}
655
7159039a 656EXPORT_SYMBOL(ipv6_setsockopt);
3fdadf7d
DM		 657
658#ifdef CONFIG_COMPAT
659int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
543d9cfe 660 char __user *optval, int optlen)
3fdadf7d
DM		 661{
662 int err;
663
664 if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
543d9cfe
ACM		 665 if (udp_prot.compat_setsockopt != NULL)
666 return udp_prot.compat_setsockopt(sk, level, optname,
667 optval, optlen);
668 return udp_prot.setsockopt(sk, level, optname, optval, optlen);
3fdadf7d
DM		 669 }
670
671 if (level != SOL_IPV6)
672 return -ENOPROTOOPT;
673
674 err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
675#ifdef CONFIG_NETFILTER
676 /* we need to exclude all possible ENOPROTOOPTs except default case */
677 if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
543d9cfe 678 optname != IPV6_XFRM_POLICY) {
3fdadf7d 679 lock_sock(sk);
543d9cfe
ACM		 680 err = compat_nf_setsockopt(sk, PF_INET6, optname,
681 optval, optlen);
3fdadf7d
DM		 682 release_sock(sk);
683 }
684#endif
685 return err;
686}
543d9cfe
ACM		 687
688EXPORT_SYMBOL(compat_ipv6_setsockopt);
3fdadf7d
DM		 689#endif
690
28693079 691static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
4c6510a7 692 int optname, char __user *optval, int len)
333fad53 693{
28693079
DM		 694 struct ipv6_opt_hdr *hdr;
695
4c6510a7
YH		 696 if (!opt)
697 return 0;
698
699 switch(optname) {
700 case IPV6_HOPOPTS:
701 hdr = opt->hopopt;
702 break;
703 case IPV6_RTHDRDSTOPTS:
704 hdr = opt->dst0opt;
705 break;
706 case IPV6_RTHDR:
707 hdr = (struct ipv6_opt_hdr *)opt->srcrt;
708 break;
709 case IPV6_DSTOPTS:
710 hdr = opt->dst1opt;
711 break;
712 default:
713 return -EINVAL; /* should not happen */
714 }
715
716 if (!hdr)
333fad53 717 return 0;
28693079 718
d2b02ed9 719 len = min_t(unsigned int, len, ipv6_optlen(hdr));
660adc6e 720 if (copy_to_user(optval, hdr, len))
333fad53 721 return -EFAULT;
e5268f12 722 return ipv6_optlen(hdr);
333fad53
YH		 723}
724
3fdadf7d 725static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
1da177e4
LT		 726 char __user *optval, int __user *optlen)
727{
728 struct ipv6_pinfo *np = inet6_sk(sk);
729 int len;
730 int val;
731
1da177e4
LT		 732 if (get_user(len, optlen))
733 return -EFAULT;
734 switch (optname) {
735 case IPV6_ADDRFORM:
736 if (sk->sk_protocol != IPPROTO_UDP &&
e898d4db 737#ifdef CONFIG_IP_UDPLITE
ba4e58ec 738 sk->sk_protocol != IPPROTO_UDPLITE &&
e898d4db 739#endif
1da177e4
LT		 740 sk->sk_protocol != IPPROTO_TCP)
741 return -EINVAL;
742 if (sk->sk_state != TCP_ESTABLISHED)
743 return -ENOTCONN;
744 val = sk->sk_family;
745 break;
746 case MCAST_MSFILTER:
747 {
748 struct group_filter gsf;
749 int err;
750
751 if (len < GROUP_FILTER_SIZE(0))
752 return -EINVAL;
753 if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))
754 return -EFAULT;
755 lock_sock(sk);
756 err = ip6_mc_msfget(sk, &gsf,
757 (struct group_filter __user *)optval, optlen);
758 release_sock(sk);
759 return err;
760 }
761
333fad53 762 case IPV6_2292PKTOPTIONS:
1da177e4
LT		 763 {
764 struct msghdr msg;
765 struct sk_buff *skb;
766
767 if (sk->sk_type != SOCK_STREAM)
768 return -ENOPROTOOPT;
769
770 msg.msg_control = optval;
771 msg.msg_controllen = len;
772 msg.msg_flags = 0;
773
774 lock_sock(sk);
775 skb = np->pktoptions;
776 if (skb)
777 atomic_inc(&skb->users);
778 release_sock(sk);
779
780 if (skb) {
781 int err = datagram_recv_ctl(sk, &msg, skb);
782 kfree_skb(skb);
783 if (err)
784 return err;
785 } else {
786 if (np->rxopt.bits.rxinfo) {
787 struct in6_pktinfo src_info;
788 src_info.ipi6_ifindex = np->mcast_oif;
789 ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);
790 put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
791 }
792 if (np->rxopt.bits.rxhlim) {
793 int hlim = np->mcast_hops;
794 put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
795 }
333fad53
YH		 796 if (np->rxopt.bits.rxoinfo) {
797 struct in6_pktinfo src_info;
798 src_info.ipi6_ifindex = np->mcast_oif;
799 ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);
800 put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
801 }
802 if (np->rxopt.bits.rxohlim) {
803 int hlim = np->mcast_hops;
804 put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
805 }
1da177e4
LT		 806 }
807 len -= msg.msg_controllen;
808 return put_user(len, optlen);
809 }
810 case IPV6_MTU:
811 {
812 struct dst_entry *dst;
1ab1457c 813 val = 0;
1da177e4
LT		 814 lock_sock(sk);
815 dst = sk_dst_get(sk);
816 if (dst) {
817 val = dst_mtu(dst);
818 dst_release(dst);
819 }
820 release_sock(sk);
821 if (!val)
822 return -ENOTCONN;
823 break;
824 }
825
826 case IPV6_V6ONLY:
827 val = np->ipv6only;
828 break;
829
333fad53 830 case IPV6_RECVPKTINFO:
1da177e4
LT		 831 val = np->rxopt.bits.rxinfo;
832 break;
833
333fad53
YH		 834 case IPV6_2292PKTINFO:
835 val = np->rxopt.bits.rxoinfo;
836 break;
837
838 case IPV6_RECVHOPLIMIT:
1da177e4
LT		 839 val = np->rxopt.bits.rxhlim;
840 break;
841
333fad53
YH		 842 case IPV6_2292HOPLIMIT:
843 val = np->rxopt.bits.rxohlim;
844 break;
845
846 case IPV6_RECVRTHDR:
1da177e4
LT		 847 val = np->rxopt.bits.srcrt;
848 break;
849
333fad53
YH		 850 case IPV6_2292RTHDR:
851 val = np->rxopt.bits.osrcrt;
852 break;
853
1da177e4 854 case IPV6_HOPOPTS:
333fad53
YH		 855 case IPV6_RTHDRDSTOPTS:
856 case IPV6_RTHDR:
857 case IPV6_DSTOPTS:
858 {
859
860 lock_sock(sk);
28693079 861 len = ipv6_getsockopt_sticky(sk, np->opt,
4c6510a7 862 optname, optval, len);
333fad53
YH		 863 release_sock(sk);
864 return put_user(len, optlen);
865 }
866
867 case IPV6_RECVHOPOPTS:
1da177e4
LT		 868 val = np->rxopt.bits.hopopts;
869 break;
870
333fad53
YH		 871 case IPV6_2292HOPOPTS:
872 val = np->rxopt.bits.ohopopts;
873 break;
874
875 case IPV6_RECVDSTOPTS:
1da177e4
LT		 876 val = np->rxopt.bits.dstopts;
877 break;
878
333fad53
YH		 879 case IPV6_2292DSTOPTS:
880 val = np->rxopt.bits.odstopts;
881 break;
882
41a1f8ea
YH		 883 case IPV6_TCLASS:
884 val = np->tclass;
d0ee011f
RDC		 885 if (val < 0)
886 val = 0;
41a1f8ea
YH		 887 break;
888
889 case IPV6_RECVTCLASS:
890 val = np->rxopt.bits.rxtclass;
891 break;
892
1da177e4
LT		 893 case IPV6_FLOWINFO:
894 val = np->rxopt.bits.rxflow;
895 break;
896
897 case IPV6_UNICAST_HOPS:
1da177e4 898 case IPV6_MULTICAST_HOPS:
befffe90
BH		 899 {
900 struct dst_entry *dst;
901
902 if (optname == IPV6_UNICAST_HOPS)
903 val = np->hop_limit;
904 else
905 val = np->mcast_hops;
906
907 dst = sk_dst_get(sk);
908 if (dst) {
909 if (val < 0)
910 val = dst_metric(dst, RTAX_HOPLIMIT);
911 if (val < 0)
912 val = ipv6_get_hoplimit(dst->dev);
913 dst_release(dst);
914 }
915 if (val < 0)
916 val = ipv6_devconf.hop_limit;
1da177e4 917 break;
befffe90 918 }
1da177e4
LT		 919
920 case IPV6_MULTICAST_LOOP:
921 val = np->mc_loop;
922 break;
923
924 case IPV6_MULTICAST_IF:
925 val = np->mcast_oif;
926 break;
927
928 case IPV6_MTU_DISCOVER:
929 val = np->pmtudisc;
930 break;
931
932 case IPV6_RECVERR:
933 val = np->recverr;
934 break;
935
936 case IPV6_FLOWINFO_SEND:
937 val = np->sndflow;
938 break;
939
940 default:
cf6fc4a9 941 return -ENOPROTOOPT;
1da177e4
LT		 942 }
943 len = min_t(unsigned int, sizeof(int), len);
944 if(put_user(len, optlen))
945 return -EFAULT;
946 if(copy_to_user(optval,&val,len))
947 return -EFAULT;
948 return 0;
949}
950
3fdadf7d
DM		 951int ipv6_getsockopt(struct sock *sk, int level, int optname,
952 char __user *optval, int __user *optlen)
953{
954 int err;
955
956 if (level == SOL_IP && sk->sk_type != SOCK_RAW)
957 return udp_prot.getsockopt(sk, level, optname, optval, optlen);
958
959 if(level != SOL_IPV6)
960 return -ENOPROTOOPT;
961
962 err = do_ipv6_getsockopt(sk, level, optname, optval, optlen);
963#ifdef CONFIG_NETFILTER
cf6fc4a9
WY		 964 /* we need to exclude all possible ENOPROTOOPTs except default case */
965 if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
3fdadf7d
DM		 966 int len;
967
968 if (get_user(len, optlen))
969 return -EFAULT;
970
971 lock_sock(sk);
972 err = nf_getsockopt(sk, PF_INET6, optname, optval,
973 &len);
974 release_sock(sk);
975 if (err >= 0)
976 err = put_user(len, optlen);
977 }
978#endif
979 return err;
980}
981
7159039a
YH		 982EXPORT_SYMBOL(ipv6_getsockopt);
983
3fdadf7d
DM		 984#ifdef CONFIG_COMPAT
985int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
543d9cfe 986 char __user *optval, int __user *optlen)
3fdadf7d
DM		 987{
988 int err;
989
990 if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
543d9cfe
ACM		 991 if (udp_prot.compat_getsockopt != NULL)
992 return udp_prot.compat_getsockopt(sk, level, optname,
993 optval, optlen);
994 return udp_prot.getsockopt(sk, level, optname, optval, optlen);
3fdadf7d
DM		 995 }
996
543d9cfe 997 if (level != SOL_IPV6)
3fdadf7d
DM		 998 return -ENOPROTOOPT;
999
1000 err = do_ipv6_getsockopt(sk, level, optname, optval, optlen);
1001#ifdef CONFIG_NETFILTER
cf6fc4a9
WY		 1002 /* we need to exclude all possible ENOPROTOOPTs except default case */
1003 if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
3fdadf7d
DM		 1004 int len;
1005
1006 if (get_user(len, optlen))
1007 return -EFAULT;
1008
1009 lock_sock(sk);
543d9cfe
ACM		 1010 err = compat_nf_getsockopt(sk, PF_INET6,
1011 optname, optval, &len);
3fdadf7d
DM		 1012 release_sock(sk);
1013 if (err >= 0)
1014 err = put_user(len, optlen);
1015 }
1016#endif
1017 return err;
1018}
543d9cfe
ACM		 1019
1020EXPORT_SYMBOL(compat_ipv6_getsockopt);
3fdadf7d
DM		 1021#endif
1022
Linux kernel - Deliverables
This page took 0.443797 seconds and 5 git commands to generate.