projects / deliverable / linux.git / blob
? search:


23048d9f3584b199164a42a21e467c054975d8c5
[deliverable/linux.git] / net / ipv4 / ip_sockglue.c
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 IP to API glue.
7 *
8 * Version: $Id: ip_sockglue.c,v 1.62 2002/02/01 22:01:04 davem Exp $
9 *
10 * Authors: see ip.c
11 *
12 * Fixes:
13 * Many : Split from ip.c , see ip.c for history.
14 * Martin Mares : TOS setting fixed.
15 * Alan Cox : Fixed a couple of oopses in Martin's
16 * TOS tweaks.
17 * Mike McLagan : Routing by source
18 */
19
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/mm.h>
23 #include <linux/skbuff.h>
24 #include <linux/ip.h>
25 #include <linux/icmp.h>
26 #include <linux/inetdevice.h>
27 #include <linux/netdevice.h>
28 #include <net/sock.h>
29 #include <net/ip.h>
30 #include <net/icmp.h>
31 #include <net/tcp_states.h>
32 #include <linux/udp.h>
33 #include <linux/igmp.h>
34 #include <linux/netfilter.h>
35 #include <linux/route.h>
36 #include <linux/mroute.h>
37 #include <net/route.h>
38 #include <net/xfrm.h>
39 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
40 #include <net/transp_v6.h>
41 #endif
42
43 #include <linux/errqueue.h>
44 #include <asm/uaccess.h>
45
46 #define IP_CMSG_PKTINFO 1
47 #define IP_CMSG_TTL 2
48 #define IP_CMSG_TOS 4
49 #define IP_CMSG_RECVOPTS 8
50 #define IP_CMSG_RETOPTS 16
51 #define IP_CMSG_PASSSEC 32
52
53 /*
54 * SOL_IP control messages.
55 */
56
57 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
58 {
59 struct in_pktinfo info;
60 struct rtable *rt = (struct rtable *)skb->dst;
61
62 info.ipi_addr.s_addr = skb->nh.iph->daddr;
63 if (rt) {
64 info.ipi_ifindex = rt->rt_iif;
65 info.ipi_spec_dst.s_addr = rt->rt_spec_dst;
66 } else {
67 info.ipi_ifindex = 0;
68 info.ipi_spec_dst.s_addr = 0;
69 }
70
71 put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
72 }
73
74 static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
75 {
76 int ttl = skb->nh.iph->ttl;
77 put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
78 }
79
80 static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
81 {
82 put_cmsg(msg, SOL_IP, IP_TOS, 1, &skb->nh.iph->tos);
83 }
84
85 static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
86 {
87 if (IPCB(skb)->opt.optlen == 0)
88 return;
89
90 put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen, skb->nh.iph+1);
91 }
92
93
94 static void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
95 {
96 unsigned char optbuf[sizeof(struct ip_options) + 40];
97 struct ip_options * opt = (struct ip_options*)optbuf;
98
99 if (IPCB(skb)->opt.optlen == 0)
100 return;
101
102 if (ip_options_echo(opt, skb)) {
103 msg->msg_flags |= MSG_CTRUNC;
104 return;
105 }
106 ip_options_undo(opt);
107
108 put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
109 }
110
111 static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
112 {
113 char *secdata;
114 u32 seclen, secid;
115 int err;
116
117 err = security_socket_getpeersec_dgram(NULL, skb, &secid);
118 if (err)
119 return;
120
121 err = security_secid_to_secctx(secid, &secdata, &seclen);
122 if (err)
123 return;
124
125 put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
126 security_release_secctx(secdata, seclen);
127 }
128
129
130 void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
131 {
132 struct inet_sock *inet = inet_sk(skb->sk);
133 unsigned flags = inet->cmsg_flags;
134
135 /* Ordered by supposed usage frequency */
136 if (flags & 1)
137 ip_cmsg_recv_pktinfo(msg, skb);
138 if ((flags>>=1) == 0)
139 return;
140
141 if (flags & 1)
142 ip_cmsg_recv_ttl(msg, skb);
143 if ((flags>>=1) == 0)
144 return;
145
146 if (flags & 1)
147 ip_cmsg_recv_tos(msg, skb);
148 if ((flags>>=1) == 0)
149 return;
150
151 if (flags & 1)
152 ip_cmsg_recv_opts(msg, skb);
153 if ((flags>>=1) == 0)
154 return;
155
156 if (flags & 1)
157 ip_cmsg_recv_retopts(msg, skb);
158 if ((flags>>=1) == 0)
159 return;
160
161 if (flags & 1)
162 ip_cmsg_recv_security(msg, skb);
163 }
164
165 int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc)
166 {
167 int err;
168 struct cmsghdr *cmsg;
169
170 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
171 if (!CMSG_OK(msg, cmsg))
172 return -EINVAL;
173 if (cmsg->cmsg_level != SOL_IP)
174 continue;
175 switch (cmsg->cmsg_type) {
176 case IP_RETOPTS:
177 err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
178 err = ip_options_get(&ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40);
179 if (err)
180 return err;
181 break;
182 case IP_PKTINFO:
183 {
184 struct in_pktinfo *info;
185 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
186 return -EINVAL;
187 info = (struct in_pktinfo *)CMSG_DATA(cmsg);
188 ipc->oif = info->ipi_ifindex;
189 ipc->addr = info->ipi_spec_dst.s_addr;
190 break;
191 }
192 default:
193 return -EINVAL;
194 }
195 }
196 return 0;
197 }
198
199
200 /* Special input handler for packets caught by router alert option.
201 They are selected only by protocol field, and then processed likely
202 local ones; but only if someone wants them! Otherwise, router
203 not running rsvpd will kill RSVP.
204
205 It is user level problem, what it will make with them.
206 I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
207 but receiver should be enough clever f.e. to forward mtrace requests,
208 sent to multicast group to reach destination designated router.
209 */
210 struct ip_ra_chain *ip_ra_chain;
211 DEFINE_RWLOCK(ip_ra_lock);
212
213 int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
214 {
215 struct ip_ra_chain *ra, *new_ra, **rap;
216
217 if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num == IPPROTO_RAW)
218 return -EINVAL;
219
220 new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
221
222 write_lock_bh(&ip_ra_lock);
223 for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
224 if (ra->sk == sk) {
225 if (on) {
226 write_unlock_bh(&ip_ra_lock);
227 kfree(new_ra);
228 return -EADDRINUSE;
229 }
230 *rap = ra->next;
231 write_unlock_bh(&ip_ra_lock);
232
233 if (ra->destructor)
234 ra->destructor(sk);
235 sock_put(sk);
236 kfree(ra);
237 return 0;
238 }
239 }
240 if (new_ra == NULL) {
241 write_unlock_bh(&ip_ra_lock);
242 return -ENOBUFS;
243 }
244 new_ra->sk = sk;
245 new_ra->destructor = destructor;
246
247 new_ra->next = ra;
248 *rap = new_ra;
249 sock_hold(sk);
250 write_unlock_bh(&ip_ra_lock);
251
252 return 0;
253 }
254
255 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
256 __be16 port, u32 info, u8 *payload)
257 {
258 struct inet_sock *inet = inet_sk(sk);
259 struct sock_exterr_skb *serr;
260
261 if (!inet->recverr)
262 return;
263
264 skb = skb_clone(skb, GFP_ATOMIC);
265 if (!skb)
266 return;
267
268 serr = SKB_EXT_ERR(skb);
269 serr->ee.ee_errno = err;
270 serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
271 serr->ee.ee_type = skb->h.icmph->type;
272 serr->ee.ee_code = skb->h.icmph->code;
273 serr->ee.ee_pad = 0;
274 serr->ee.ee_info = info;
275 serr->ee.ee_data = 0;
276 serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw;
277 serr->port = port;
278
279 skb->h.raw = payload;
280 if (!skb_pull(skb, payload - skb->data) ||
281 sock_queue_err_skb(sk, skb))
282 kfree_skb(skb);
283 }
284
285 void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
286 {
287 struct inet_sock *inet = inet_sk(sk);
288 struct sock_exterr_skb *serr;
289 struct iphdr *iph;
290 struct sk_buff *skb;
291
292 if (!inet->recverr)
293 return;
294
295 skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
296 if (!skb)
297 return;
298
299 iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr));
300 skb->nh.iph = iph;
301 iph->daddr = daddr;
302
303 serr = SKB_EXT_ERR(skb);
304 serr->ee.ee_errno = err;
305 serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
306 serr->ee.ee_type = 0;
307 serr->ee.ee_code = 0;
308 serr->ee.ee_pad = 0;
309 serr->ee.ee_info = info;
310 serr->ee.ee_data = 0;
311 serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
312 serr->port = port;
313
314 skb->h.raw = skb->tail;
315 __skb_pull(skb, skb->tail - skb->data);
316
317 if (sock_queue_err_skb(sk, skb))
318 kfree_skb(skb);
319 }
320
321 /*
322 * Handle MSG_ERRQUEUE
323 */
324 int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
325 {
326 struct sock_exterr_skb *serr;
327 struct sk_buff *skb, *skb2;
328 struct sockaddr_in *sin;
329 struct {
330 struct sock_extended_err ee;
331 struct sockaddr_in offender;
332 } errhdr;
333 int err;
334 int copied;
335
336 err = -EAGAIN;
337 skb = skb_dequeue(&sk->sk_error_queue);
338 if (skb == NULL)
339 goto out;
340
341 copied = skb->len;
342 if (copied > len) {
343 msg->msg_flags |= MSG_TRUNC;
344 copied = len;
345 }
346 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
347 if (err)
348 goto out_free_skb;
349
350 sock_recv_timestamp(msg, sk, skb);
351
352 serr = SKB_EXT_ERR(skb);
353
354 sin = (struct sockaddr_in *)msg->msg_name;
355 if (sin) {
356 sin->sin_family = AF_INET;
357 sin->sin_addr.s_addr = *(__be32*)(skb->nh.raw + serr->addr_offset);
358 sin->sin_port = serr->port;
359 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
360 }
361
362 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
363 sin = &errhdr.offender;
364 sin->sin_family = AF_UNSPEC;
365 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
366 struct inet_sock *inet = inet_sk(sk);
367
368 sin->sin_family = AF_INET;
369 sin->sin_addr.s_addr = skb->nh.iph->saddr;
370 sin->sin_port = 0;
371 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
372 if (inet->cmsg_flags)
373 ip_cmsg_recv(msg, skb);
374 }
375
376 put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
377
378 /* Now we could try to dump offended packet options */
379
380 msg->msg_flags |= MSG_ERRQUEUE;
381 err = copied;
382
383 /* Reset and regenerate socket error */
384 spin_lock_bh(&sk->sk_error_queue.lock);
385 sk->sk_err = 0;
386 if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
387 sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
388 spin_unlock_bh(&sk->sk_error_queue.lock);
389 sk->sk_error_report(sk);
390 } else
391 spin_unlock_bh(&sk->sk_error_queue.lock);
392
393 out_free_skb:
394 kfree_skb(skb);
395 out:
396 return err;
397 }
398
399
400 /*
401 * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
402 * an IP socket.
403 */
404
405 static int do_ip_setsockopt(struct sock *sk, int level,
406 int optname, char __user *optval, int optlen)
407 {
408 struct inet_sock *inet = inet_sk(sk);
409 int val=0,err;
410
411 if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) |
412 (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) |
413 (1<<IP_RETOPTS) | (1<<IP_TOS) |
414 (1<<IP_TTL) | (1<<IP_HDRINCL) |
415 (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) |
416 (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND) |
417 (1<<IP_PASSSEC))) ||
418 optname == IP_MULTICAST_TTL ||
419 optname == IP_MULTICAST_LOOP) {
420 if (optlen >= sizeof(int)) {
421 if (get_user(val, (int __user *) optval))
422 return -EFAULT;
423 } else if (optlen >= sizeof(char)) {
424 unsigned char ucval;
425
426 if (get_user(ucval, (unsigned char __user *) optval))
427 return -EFAULT;
428 val = (int) ucval;
429 }
430 }
431
432 /* If optlen==0, it is equivalent to val == 0 */
433
434 #ifdef CONFIG_IP_MROUTE
435 if (optname >= MRT_BASE && optname <= (MRT_BASE + 10))
436 return ip_mroute_setsockopt(sk,optname,optval,optlen);
437 #endif
438
439 err = 0;
440 lock_sock(sk);
441
442 switch (optname) {
443 case IP_OPTIONS:
444 {
445 struct ip_options * opt = NULL;
446 if (optlen > 40 || optlen < 0)
447 goto e_inval;
448 err = ip_options_get_from_user(&opt, optval, optlen);
449 if (err)
450 break;
451 if (inet->is_icsk) {
452 struct inet_connection_sock *icsk = inet_csk(sk);
453 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
454 if (sk->sk_family == PF_INET ||
455 (!((1 << sk->sk_state) &
456 (TCPF_LISTEN | TCPF_CLOSE)) &&
457 inet->daddr != LOOPBACK4_IPV6)) {
458 #endif
459 if (inet->opt)
460 icsk->icsk_ext_hdr_len -= inet->opt->optlen;
461 if (opt)
462 icsk->icsk_ext_hdr_len += opt->optlen;
463 icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
464 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
465 }
466 #endif
467 }
468 opt = xchg(&inet->opt, opt);
469 kfree(opt);
470 break;
471 }
472 case IP_PKTINFO:
473 if (val)
474 inet->cmsg_flags |= IP_CMSG_PKTINFO;
475 else
476 inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
477 break;
478 case IP_RECVTTL:
479 if (val)
480 inet->cmsg_flags |= IP_CMSG_TTL;
481 else
482 inet->cmsg_flags &= ~IP_CMSG_TTL;
483 break;
484 case IP_RECVTOS:
485 if (val)
486 inet->cmsg_flags |= IP_CMSG_TOS;
487 else
488 inet->cmsg_flags &= ~IP_CMSG_TOS;
489 break;
490 case IP_RECVOPTS:
491 if (val)
492 inet->cmsg_flags |= IP_CMSG_RECVOPTS;
493 else
494 inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
495 break;
496 case IP_RETOPTS:
497 if (val)
498 inet->cmsg_flags |= IP_CMSG_RETOPTS;
499 else
500 inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
501 break;
502 case IP_PASSSEC:
503 if (val)
504 inet->cmsg_flags |= IP_CMSG_PASSSEC;
505 else
506 inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
507 break;
508 case IP_TOS: /* This sets both TOS and Precedence */
509 if (sk->sk_type == SOCK_STREAM) {
510 val &= ~3;
511 val |= inet->tos & 3;
512 }
513 if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP &&
514 !capable(CAP_NET_ADMIN)) {
515 err = -EPERM;
516 break;
517 }
518 if (inet->tos != val) {
519 inet->tos = val;
520 sk->sk_priority = rt_tos2priority(val);
521 sk_dst_reset(sk);
522 }
523 break;
524 case IP_TTL:
525 if (optlen<1)
526 goto e_inval;
527 if (val != -1 && (val < 1 || val>255))
528 goto e_inval;
529 inet->uc_ttl = val;
530 break;
531 case IP_HDRINCL:
532 if (sk->sk_type != SOCK_RAW) {
533 err = -ENOPROTOOPT;
534 break;
535 }
536 inet->hdrincl = val ? 1 : 0;
537 break;
538 case IP_MTU_DISCOVER:
539 if (val<0 || val>2)
540 goto e_inval;
541 inet->pmtudisc = val;
542 break;
543 case IP_RECVERR:
544 inet->recverr = !!val;
545 if (!val)
546 skb_queue_purge(&sk->sk_error_queue);
547 break;
548 case IP_MULTICAST_TTL:
549 if (sk->sk_type == SOCK_STREAM)
550 goto e_inval;
551 if (optlen<1)
552 goto e_inval;
553 if (val==-1)
554 val = 1;
555 if (val < 0 || val > 255)
556 goto e_inval;
557 inet->mc_ttl = val;
558 break;
559 case IP_MULTICAST_LOOP:
560 if (optlen<1)
561 goto e_inval;
562 inet->mc_loop = !!val;
563 break;
564 case IP_MULTICAST_IF:
565 {
566 struct ip_mreqn mreq;
567 struct net_device *dev = NULL;
568
569 if (sk->sk_type == SOCK_STREAM)
570 goto e_inval;
571 /*
572 * Check the arguments are allowable
573 */
574
575 err = -EFAULT;
576 if (optlen >= sizeof(struct ip_mreqn)) {
577 if (copy_from_user(&mreq,optval,sizeof(mreq)))
578 break;
579 } else {
580 memset(&mreq, 0, sizeof(mreq));
581 if (optlen >= sizeof(struct in_addr) &&
582 copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr)))
583 break;
584 }
585
586 if (!mreq.imr_ifindex) {
587 if (mreq.imr_address.s_addr == INADDR_ANY) {
588 inet->mc_index = 0;
589 inet->mc_addr = 0;
590 err = 0;
591 break;
592 }
593 dev = ip_dev_find(mreq.imr_address.s_addr);
594 if (dev) {
595 mreq.imr_ifindex = dev->ifindex;
596 dev_put(dev);
597 }
598 } else
599 dev = __dev_get_by_index(mreq.imr_ifindex);
600
601
602 err = -EADDRNOTAVAIL;
603 if (!dev)
604 break;
605
606 err = -EINVAL;
607 if (sk->sk_bound_dev_if &&
608 mreq.imr_ifindex != sk->sk_bound_dev_if)
609 break;
610
611 inet->mc_index = mreq.imr_ifindex;
612 inet->mc_addr = mreq.imr_address.s_addr;
613 err = 0;
614 break;
615 }
616
617 case IP_ADD_MEMBERSHIP:
618 case IP_DROP_MEMBERSHIP:
619 {
620 struct ip_mreqn mreq;
621
622 if (optlen < sizeof(struct ip_mreq))
623 goto e_inval;
624 err = -EFAULT;
625 if (optlen >= sizeof(struct ip_mreqn)) {
626 if(copy_from_user(&mreq,optval,sizeof(mreq)))
627 break;
628 } else {
629 memset(&mreq, 0, sizeof(mreq));
630 if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
631 break;
632 }
633
634 if (optname == IP_ADD_MEMBERSHIP)
635 err = ip_mc_join_group(sk, &mreq);
636 else
637 err = ip_mc_leave_group(sk, &mreq);
638 break;
639 }
640 case IP_MSFILTER:
641 {
642 extern int sysctl_igmp_max_msf;
643 struct ip_msfilter *msf;
644
645 if (optlen < IP_MSFILTER_SIZE(0))
646 goto e_inval;
647 if (optlen > sysctl_optmem_max) {
648 err = -ENOBUFS;
649 break;
650 }
651 msf = kmalloc(optlen, GFP_KERNEL);
652 if (msf == 0) {
653 err = -ENOBUFS;
654 break;
655 }
656 err = -EFAULT;
657 if (copy_from_user(msf, optval, optlen)) {
658 kfree(msf);
659 break;
660 }
661 /* numsrc >= (1G-4) overflow in 32 bits */
662 if (msf->imsf_numsrc >= 0x3ffffffcU ||
663 msf->imsf_numsrc > sysctl_igmp_max_msf) {
664 kfree(msf);
665 err = -ENOBUFS;
666 break;
667 }
668 if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
669 kfree(msf);
670 err = -EINVAL;
671 break;
672 }
673 err = ip_mc_msfilter(sk, msf, 0);
674 kfree(msf);
675 break;
676 }
677 case IP_BLOCK_SOURCE:
678 case IP_UNBLOCK_SOURCE:
679 case IP_ADD_SOURCE_MEMBERSHIP:
680 case IP_DROP_SOURCE_MEMBERSHIP:
681 {
682 struct ip_mreq_source mreqs;
683 int omode, add;
684
685 if (optlen != sizeof(struct ip_mreq_source))
686 goto e_inval;
687 if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
688 err = -EFAULT;
689 break;
690 }
691 if (optname == IP_BLOCK_SOURCE) {
692 omode = MCAST_EXCLUDE;
693 add = 1;
694 } else if (optname == IP_UNBLOCK_SOURCE) {
695 omode = MCAST_EXCLUDE;
696 add = 0;
697 } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
698 struct ip_mreqn mreq;
699
700 mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
701 mreq.imr_address.s_addr = mreqs.imr_interface;
702 mreq.imr_ifindex = 0;
703 err = ip_mc_join_group(sk, &mreq);
704 if (err && err != -EADDRINUSE)
705 break;
706 omode = MCAST_INCLUDE;
707 add = 1;
708 } else /* IP_DROP_SOURCE_MEMBERSHIP */ {
709 omode = MCAST_INCLUDE;
710 add = 0;
711 }
712 err = ip_mc_source(add, omode, sk, &mreqs, 0);
713 break;
714 }
715 case MCAST_JOIN_GROUP:
716 case MCAST_LEAVE_GROUP:
717 {
718 struct group_req greq;
719 struct sockaddr_in *psin;
720 struct ip_mreqn mreq;
721
722 if (optlen < sizeof(struct group_req))
723 goto e_inval;
724 err = -EFAULT;
725 if(copy_from_user(&greq, optval, sizeof(greq)))
726 break;
727 psin = (struct sockaddr_in *)&greq.gr_group;
728 if (psin->sin_family != AF_INET)
729 goto e_inval;
730 memset(&mreq, 0, sizeof(mreq));
731 mreq.imr_multiaddr = psin->sin_addr;
732 mreq.imr_ifindex = greq.gr_interface;
733
734 if (optname == MCAST_JOIN_GROUP)
735 err = ip_mc_join_group(sk, &mreq);
736 else
737 err = ip_mc_leave_group(sk, &mreq);
738 break;
739 }
740 case MCAST_JOIN_SOURCE_GROUP:
741 case MCAST_LEAVE_SOURCE_GROUP:
742 case MCAST_BLOCK_SOURCE:
743 case MCAST_UNBLOCK_SOURCE:
744 {
745 struct group_source_req greqs;
746 struct ip_mreq_source mreqs;
747 struct sockaddr_in *psin;
748 int omode, add;
749
750 if (optlen != sizeof(struct group_source_req))
751 goto e_inval;
752 if (copy_from_user(&greqs, optval, sizeof(greqs))) {
753 err = -EFAULT;
754 break;
755 }
756 if (greqs.gsr_group.ss_family != AF_INET ||
757 greqs.gsr_source.ss_family != AF_INET) {
758 err = -EADDRNOTAVAIL;
759 break;
760 }
761 psin = (struct sockaddr_in *)&greqs.gsr_group;
762 mreqs.imr_multiaddr = psin->sin_addr.s_addr;
763 psin = (struct sockaddr_in *)&greqs.gsr_source;
764 mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
765 mreqs.imr_interface = 0; /* use index for mc_source */
766
767 if (optname == MCAST_BLOCK_SOURCE) {
768 omode = MCAST_EXCLUDE;
769 add = 1;
770 } else if (optname == MCAST_UNBLOCK_SOURCE) {
771 omode = MCAST_EXCLUDE;
772 add = 0;
773 } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
774 struct ip_mreqn mreq;
775
776 psin = (struct sockaddr_in *)&greqs.gsr_group;
777 mreq.imr_multiaddr = psin->sin_addr;
778 mreq.imr_address.s_addr = 0;
779 mreq.imr_ifindex = greqs.gsr_interface;
780 err = ip_mc_join_group(sk, &mreq);
781 if (err && err != -EADDRINUSE)
782 break;
783 greqs.gsr_interface = mreq.imr_ifindex;
784 omode = MCAST_INCLUDE;
785 add = 1;
786 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
787 omode = MCAST_INCLUDE;
788 add = 0;
789 }
790 err = ip_mc_source(add, omode, sk, &mreqs,
791 greqs.gsr_interface);
792 break;
793 }
794 case MCAST_MSFILTER:
795 {
796 extern int sysctl_igmp_max_msf;
797 struct sockaddr_in *psin;
798 struct ip_msfilter *msf = NULL;
799 struct group_filter *gsf = NULL;
800 int msize, i, ifindex;
801
802 if (optlen < GROUP_FILTER_SIZE(0))
803 goto e_inval;
804 if (optlen > sysctl_optmem_max) {
805 err = -ENOBUFS;
806 break;
807 }
808 gsf = kmalloc(optlen,GFP_KERNEL);
809 if (gsf == 0) {
810 err = -ENOBUFS;
811 break;
812 }
813 err = -EFAULT;
814 if (copy_from_user(gsf, optval, optlen)) {
815 goto mc_msf_out;
816 }
817 /* numsrc >= (4G-140)/128 overflow in 32 bits */
818 if (gsf->gf_numsrc >= 0x1ffffff ||
819 gsf->gf_numsrc > sysctl_igmp_max_msf) {
820 err = -ENOBUFS;
821 goto mc_msf_out;
822 }
823 if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
824 err = -EINVAL;
825 goto mc_msf_out;
826 }
827 msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
828 msf = kmalloc(msize,GFP_KERNEL);
829 if (msf == 0) {
830 err = -ENOBUFS;
831 goto mc_msf_out;
832 }
833 ifindex = gsf->gf_interface;
834 psin = (struct sockaddr_in *)&gsf->gf_group;
835 if (psin->sin_family != AF_INET) {
836 err = -EADDRNOTAVAIL;
837 goto mc_msf_out;
838 }
839 msf->imsf_multiaddr = psin->sin_addr.s_addr;
840 msf->imsf_interface = 0;
841 msf->imsf_fmode = gsf->gf_fmode;
842 msf->imsf_numsrc = gsf->gf_numsrc;
843 err = -EADDRNOTAVAIL;
844 for (i=0; i<gsf->gf_numsrc; ++i) {
845 psin = (struct sockaddr_in *)&gsf->gf_slist[i];
846
847 if (psin->sin_family != AF_INET)
848 goto mc_msf_out;
849 msf->imsf_slist[i] = psin->sin_addr.s_addr;
850 }
851 kfree(gsf);
852 gsf = NULL;
853
854 err = ip_mc_msfilter(sk, msf, ifindex);
855 mc_msf_out:
856 kfree(msf);
857 kfree(gsf);
858 break;
859 }
860 case IP_ROUTER_ALERT:
861 err = ip_ra_control(sk, val ? 1 : 0, NULL);
862 break;
863
864 case IP_FREEBIND:
865 if (optlen<1)
866 goto e_inval;
867 inet->freebind = !!val;
868 break;
869
870 case IP_IPSEC_POLICY:
871 case IP_XFRM_POLICY:
872 err = -EPERM;
873 if (!capable(CAP_NET_ADMIN))
874 break;
875 err = xfrm_user_policy(sk, optname, optval, optlen);
876 break;
877
878 default:
879 err = -ENOPROTOOPT;
880 break;
881 }
882 release_sock(sk);
883 return err;
884
885 e_inval:
886 release_sock(sk);
887 return -EINVAL;
888 }
889
890 int ip_setsockopt(struct sock *sk, int level,
891 int optname, char __user *optval, int optlen)
892 {
893 int err;
894
895 if (level != SOL_IP)
896 return -ENOPROTOOPT;
897
898 err = do_ip_setsockopt(sk, level, optname, optval, optlen);
899 #ifdef CONFIG_NETFILTER
900 /* we need to exclude all possible ENOPROTOOPTs except default case */
901 if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
902 optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
903 #ifdef CONFIG_IP_MROUTE
904 && (optname < MRT_BASE || optname > (MRT_BASE + 10))
905 #endif
906 ) {
907 lock_sock(sk);
908 err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
909 release_sock(sk);
910 }
911 #endif
912 return err;
913 }
914
915 #ifdef CONFIG_COMPAT
916 int compat_ip_setsockopt(struct sock *sk, int level, int optname,
917 char __user *optval, int optlen)
918 {
919 int err;
920
921 if (level != SOL_IP)
922 return -ENOPROTOOPT;
923
924 err = do_ip_setsockopt(sk, level, optname, optval, optlen);
925 #ifdef CONFIG_NETFILTER
926 /* we need to exclude all possible ENOPROTOOPTs except default case */
927 if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
928 optname != IP_IPSEC_POLICY && optname != IP_XFRM_POLICY
929 #ifdef CONFIG_IP_MROUTE
930 && (optname < MRT_BASE || optname > (MRT_BASE + 10))
931 #endif
932 ) {
933 lock_sock(sk);
934 err = compat_nf_setsockopt(sk, PF_INET, optname,
935 optval, optlen);
936 release_sock(sk);
937 }
938 #endif
939 return err;
940 }
941
942 EXPORT_SYMBOL(compat_ip_setsockopt);
943 #endif
944
945 /*
946 * Get the options. Note for future reference. The GET of IP options gets the
947 * _received_ ones. The set sets the _sent_ ones.
948 */
949
950 static int do_ip_getsockopt(struct sock *sk, int level, int optname,
951 char __user *optval, int __user *optlen)
952 {
953 struct inet_sock *inet = inet_sk(sk);
954 int val;
955 int len;
956
957 if(level!=SOL_IP)
958 return -EOPNOTSUPP;
959
960 #ifdef CONFIG_IP_MROUTE
961 if(optname>=MRT_BASE && optname <=MRT_BASE+10)
962 {
963 return ip_mroute_getsockopt(sk,optname,optval,optlen);
964 }
965 #endif
966
967 if(get_user(len,optlen))
968 return -EFAULT;
969 if(len < 0)
970 return -EINVAL;
971
972 lock_sock(sk);
973
974 switch(optname) {
975 case IP_OPTIONS:
976 {
977 unsigned char optbuf[sizeof(struct ip_options)+40];
978 struct ip_options * opt = (struct ip_options*)optbuf;
979 opt->optlen = 0;
980 if (inet->opt)
981 memcpy(optbuf, inet->opt,
982 sizeof(struct ip_options)+
983 inet->opt->optlen);
984 release_sock(sk);
985
986 if (opt->optlen == 0)
987 return put_user(0, optlen);
988
989 ip_options_undo(opt);
990
991 len = min_t(unsigned int, len, opt->optlen);
992 if(put_user(len, optlen))
993 return -EFAULT;
994 if(copy_to_user(optval, opt->__data, len))
995 return -EFAULT;
996 return 0;
997 }
998 case IP_PKTINFO:
999 val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
1000 break;
1001 case IP_RECVTTL:
1002 val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
1003 break;
1004 case IP_RECVTOS:
1005 val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
1006 break;
1007 case IP_RECVOPTS:
1008 val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
1009 break;
1010 case IP_RETOPTS:
1011 val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
1012 break;
1013 case IP_PASSSEC:
1014 val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
1015 break;
1016 case IP_TOS:
1017 val = inet->tos;
1018 break;
1019 case IP_TTL:
1020 val = (inet->uc_ttl == -1 ?
1021 sysctl_ip_default_ttl :
1022 inet->uc_ttl);
1023 break;
1024 case IP_HDRINCL:
1025 val = inet->hdrincl;
1026 break;
1027 case IP_MTU_DISCOVER:
1028 val = inet->pmtudisc;
1029 break;
1030 case IP_MTU:
1031 {
1032 struct dst_entry *dst;
1033 val = 0;
1034 dst = sk_dst_get(sk);
1035 if (dst) {
1036 val = dst_mtu(dst);
1037 dst_release(dst);
1038 }
1039 if (!val) {
1040 release_sock(sk);
1041 return -ENOTCONN;
1042 }
1043 break;
1044 }
1045 case IP_RECVERR:
1046 val = inet->recverr;
1047 break;
1048 case IP_MULTICAST_TTL:
1049 val = inet->mc_ttl;
1050 break;
1051 case IP_MULTICAST_LOOP:
1052 val = inet->mc_loop;
1053 break;
1054 case IP_MULTICAST_IF:
1055 {
1056 struct in_addr addr;
1057 len = min_t(unsigned int, len, sizeof(struct in_addr));
1058 addr.s_addr = inet->mc_addr;
1059 release_sock(sk);
1060
1061 if(put_user(len, optlen))
1062 return -EFAULT;
1063 if(copy_to_user(optval, &addr, len))
1064 return -EFAULT;
1065 return 0;
1066 }
1067 case IP_MSFILTER:
1068 {
1069 struct ip_msfilter msf;
1070 int err;
1071
1072 if (len < IP_MSFILTER_SIZE(0)) {
1073 release_sock(sk);
1074 return -EINVAL;
1075 }
1076 if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
1077 release_sock(sk);
1078 return -EFAULT;
1079 }
1080 err = ip_mc_msfget(sk, &msf,
1081 (struct ip_msfilter __user *)optval, optlen);
1082 release_sock(sk);
1083 return err;
1084 }
1085 case MCAST_MSFILTER:
1086 {
1087 struct group_filter gsf;
1088 int err;
1089
1090 if (len < GROUP_FILTER_SIZE(0)) {
1091 release_sock(sk);
1092 return -EINVAL;
1093 }
1094 if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
1095 release_sock(sk);
1096 return -EFAULT;
1097 }
1098 err = ip_mc_gsfget(sk, &gsf,
1099 (struct group_filter __user *)optval, optlen);
1100 release_sock(sk);
1101 return err;
1102 }
1103 case IP_PKTOPTIONS:
1104 {
1105 struct msghdr msg;
1106
1107 release_sock(sk);
1108
1109 if (sk->sk_type != SOCK_STREAM)
1110 return -ENOPROTOOPT;
1111
1112 msg.msg_control = optval;
1113 msg.msg_controllen = len;
1114 msg.msg_flags = 0;
1115
1116 if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
1117 struct in_pktinfo info;
1118
1119 info.ipi_addr.s_addr = inet->rcv_saddr;
1120 info.ipi_spec_dst.s_addr = inet->rcv_saddr;
1121 info.ipi_ifindex = inet->mc_index;
1122 put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
1123 }
1124 if (inet->cmsg_flags & IP_CMSG_TTL) {
1125 int hlim = inet->mc_ttl;
1126 put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
1127 }
1128 len -= msg.msg_controllen;
1129 return put_user(len, optlen);
1130 }
1131 case IP_FREEBIND:
1132 val = inet->freebind;
1133 break;
1134 default:
1135 release_sock(sk);
1136 return -ENOPROTOOPT;
1137 }
1138 release_sock(sk);
1139
1140 if (len < sizeof(int) && len > 0 && val>=0 && val<255) {
1141 unsigned char ucval = (unsigned char)val;
1142 len = 1;
1143 if(put_user(len, optlen))
1144 return -EFAULT;
1145 if(copy_to_user(optval,&ucval,1))
1146 return -EFAULT;
1147 } else {
1148 len = min_t(unsigned int, sizeof(int), len);
1149 if(put_user(len, optlen))
1150 return -EFAULT;
1151 if(copy_to_user(optval,&val,len))
1152 return -EFAULT;
1153 }
1154 return 0;
1155 }
1156
1157 int ip_getsockopt(struct sock *sk, int level,
1158 int optname, char __user *optval, int __user *optlen)
1159 {
1160 int err;
1161
1162 err = do_ip_getsockopt(sk, level, optname, optval, optlen);
1163 #ifdef CONFIG_NETFILTER
1164 /* we need to exclude all possible ENOPROTOOPTs except default case */
1165 if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS
1166 #ifdef CONFIG_IP_MROUTE
1167 && (optname < MRT_BASE || optname > MRT_BASE+10)
1168 #endif
1169 ) {
1170 int len;
1171
1172 if(get_user(len,optlen))
1173 return -EFAULT;
1174
1175 lock_sock(sk);
1176 err = nf_getsockopt(sk, PF_INET, optname, optval,
1177 &len);
1178 release_sock(sk);
1179 if (err >= 0)
1180 err = put_user(len, optlen);
1181 return err;
1182 }
1183 #endif
1184 return err;
1185 }
1186
1187 #ifdef CONFIG_COMPAT
1188 int compat_ip_getsockopt(struct sock *sk, int level, int optname,
1189 char __user *optval, int __user *optlen)
1190 {
1191 int err = do_ip_getsockopt(sk, level, optname, optval, optlen);
1192 #ifdef CONFIG_NETFILTER
1193 /* we need to exclude all possible ENOPROTOOPTs except default case */
1194 if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS
1195 #ifdef CONFIG_IP_MROUTE
1196 && (optname < MRT_BASE || optname > MRT_BASE+10)
1197 #endif
1198 ) {
1199 int len;
1200
1201 if (get_user(len, optlen))
1202 return -EFAULT;
1203
1204 lock_sock(sk);
1205 err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
1206 release_sock(sk);
1207 if (err >= 0)
1208 err = put_user(len, optlen);
1209 return err;
1210 }
1211 #endif
1212 return err;
1213 }
1214
1215 EXPORT_SYMBOL(compat_ip_getsockopt);
1216 #endif
1217
1218 EXPORT_SYMBOL(ip_cmsg_recv);
1219
1220 EXPORT_SYMBOL(ip_getsockopt);
1221 EXPORT_SYMBOL(ip_setsockopt);
Linux kernel - Deliverables
This page took 0.055654 seconds and 4 git commands to generate.