?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of arch/mips64/kernel. 9116 lines of code gone.
[linux-2.6/linux-mips.git] / net / ipv4 / ip_sockglue.c
blob78b600d5d1258e742bb456f0d8edf4ceb7278c1c
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/config.h>
21 #include <linux/types.h>
22 #include <linux/mm.h>
23 #include <linux/sched.h>
24 #include <linux/skbuff.h>
25 #include <linux/ip.h>
26 #include <linux/icmp.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.h>
32 #include <linux/tcp.h>
33 #include <linux/udp.h>
34 #include <linux/igmp.h>
35 #include <linux/netfilter.h>
36 #include <linux/route.h>
37 #include <linux/mroute.h>
38 #include <net/route.h>
39 #include <net/xfrm.h>
40 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
41 #include <net/transp_v6.h>
42 #endif
43
44 #include <linux/errqueue.h>
45 #include <asm/uaccess.h>
46
47 #define IP_CMSG_PKTINFO 1
48 #define IP_CMSG_TTL 2
49 #define IP_CMSG_TOS 4
50 #define IP_CMSG_RECVOPTS 8
51 #define IP_CMSG_RETOPTS 16
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 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
112 void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
113 {
114 struct inet_opt *inet = inet_sk(skb->sk);
115 unsigned flags = inet->cmsg_flags;
116
117 /* Ordered by supposed usage frequency */
118 if (flags & 1)
119 ip_cmsg_recv_pktinfo(msg, skb);
120 if ((flags>>=1) == 0)
121 return;
122
123 if (flags & 1)
124 ip_cmsg_recv_ttl(msg, skb);
125 if ((flags>>=1) == 0)
126 return;
127
128 if (flags & 1)
129 ip_cmsg_recv_tos(msg, skb);
130 if ((flags>>=1) == 0)
131 return;
132
133 if (flags & 1)
134 ip_cmsg_recv_opts(msg, skb);
135 if ((flags>>=1) == 0)
136 return;
137
138 if (flags & 1)
139 ip_cmsg_recv_retopts(msg, skb);
140 }
141
142 int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc)
143 {
144 int err;
145 struct cmsghdr *cmsg;
146
147 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
148 if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
149 (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
150 + cmsg->cmsg_len) > msg->msg_controllen) {
151 return -EINVAL;
152 }
153 if (cmsg->cmsg_level != SOL_IP)
154 continue;
155 switch (cmsg->cmsg_type) {
156 case IP_RETOPTS:
157 err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
158 err = ip_options_get(&ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40, 0);
159 if (err)
160 return err;
161 break;
162 case IP_PKTINFO:
163 {
164 struct in_pktinfo *info;
165 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
166 return -EINVAL;
167 info = (struct in_pktinfo *)CMSG_DATA(cmsg);
168 ipc->oif = info->ipi_ifindex;
169 ipc->addr = info->ipi_spec_dst.s_addr;
170 break;
171 }
172 default:
173 return -EINVAL;
174 }
175 }
176 return 0;
177 }
178
179
180 /* Special input handler for packets caught by router alert option.
181 They are selected only by protocol field, and then processed likely
182 local ones; but only if someone wants them! Otherwise, router
183 not running rsvpd will kill RSVP.
184
185 It is user level problem, what it will make with them.
186 I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
187 but receiver should be enough clever f.e. to forward mtrace requests,
188 sent to multicast group to reach destination designated router.
189 */
190 struct ip_ra_chain *ip_ra_chain;
191 rwlock_t ip_ra_lock = RW_LOCK_UNLOCKED;
192
193 int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
194 {
195 struct ip_ra_chain *ra, *new_ra, **rap;
196
197 if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num == IPPROTO_RAW)
198 return -EINVAL;
199
200 new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
201
202 write_lock_bh(&ip_ra_lock);
203 for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
204 if (ra->sk == sk) {
205 if (on) {
206 write_unlock_bh(&ip_ra_lock);
207 if (new_ra)
208 kfree(new_ra);
209 return -EADDRINUSE;
210 }
211 *rap = ra->next;
212 write_unlock_bh(&ip_ra_lock);
213
214 if (ra->destructor)
215 ra->destructor(sk);
216 sock_put(sk);
217 kfree(ra);
218 return 0;
219 }
220 }
221 if (new_ra == NULL) {
222 write_unlock_bh(&ip_ra_lock);
223 return -ENOBUFS;
224 }
225 new_ra->sk = sk;
226 new_ra->destructor = destructor;
227
228 new_ra->next = ra;
229 *rap = new_ra;
230 sock_hold(sk);
231 write_unlock_bh(&ip_ra_lock);
232
233 return 0;
234 }
235
236 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
237 u16 port, u32 info, u8 *payload)
238 {
239 struct inet_opt *inet = inet_sk(sk);
240 struct sock_exterr_skb *serr;
241
242 if (!inet->recverr)
243 return;
244
245 skb = skb_clone(skb, GFP_ATOMIC);
246 if (!skb)
247 return;
248
249 serr = SKB_EXT_ERR(skb);
250 serr->ee.ee_errno = err;
251 serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
252 serr->ee.ee_type = skb->h.icmph->type;
253 serr->ee.ee_code = skb->h.icmph->code;
254 serr->ee.ee_pad = 0;
255 serr->ee.ee_info = info;
256 serr->ee.ee_data = 0;
257 serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw;
258 serr->port = port;
259
260 skb->h.raw = payload;
261 if (!skb_pull(skb, payload - skb->data) ||
262 sock_queue_err_skb(sk, skb))
263 kfree_skb(skb);
264 }
265
266 void ip_local_error(struct sock *sk, int err, u32 daddr, u16 port, u32 info)
267 {
268 struct inet_opt *inet = inet_sk(sk);
269 struct sock_exterr_skb *serr;
270 struct iphdr *iph;
271 struct sk_buff *skb;
272
273 if (!inet->recverr)
274 return;
275
276 skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
277 if (!skb)
278 return;
279
280 iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr));
281 skb->nh.iph = iph;
282 iph->daddr = daddr;
283
284 serr = SKB_EXT_ERR(skb);
285 serr->ee.ee_errno = err;
286 serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
287 serr->ee.ee_type = 0;
288 serr->ee.ee_code = 0;
289 serr->ee.ee_pad = 0;
290 serr->ee.ee_info = info;
291 serr->ee.ee_data = 0;
292 serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
293 serr->port = port;
294
295 skb->h.raw = skb->tail;
296 __skb_pull(skb, skb->tail - skb->data);
297
298 if (sock_queue_err_skb(sk, skb))
299 kfree_skb(skb);
300 }
301
302 /*
303 * Handle MSG_ERRQUEUE
304 */
305 int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
306 {
307 struct sock_exterr_skb *serr;
308 struct sk_buff *skb, *skb2;
309 struct sockaddr_in *sin;
310 struct {
311 struct sock_extended_err ee;
312 struct sockaddr_in offender;
313 } errhdr;
314 int err;
315 int copied;
316
317 err = -EAGAIN;
318 skb = skb_dequeue(&sk->sk_error_queue);
319 if (skb == NULL)
320 goto out;
321
322 copied = skb->len;
323 if (copied > len) {
324 msg->msg_flags |= MSG_TRUNC;
325 copied = len;
326 }
327 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
328 if (err)
329 goto out_free_skb;
330
331 sock_recv_timestamp(msg, sk, skb);
332
333 serr = SKB_EXT_ERR(skb);
334
335 sin = (struct sockaddr_in *)msg->msg_name;
336 if (sin) {
337 sin->sin_family = AF_INET;
338 sin->sin_addr.s_addr = *(u32*)(skb->nh.raw + serr->addr_offset);
339 sin->sin_port = serr->port;
340 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
341 }
342
343 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
344 sin = &errhdr.offender;
345 sin->sin_family = AF_UNSPEC;
346 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
347 struct inet_opt *inet = inet_sk(sk);
348
349 sin->sin_family = AF_INET;
350 sin->sin_addr.s_addr = skb->nh.iph->saddr;
351 sin->sin_port = 0;
352 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
353 if (inet->cmsg_flags)
354 ip_cmsg_recv(msg, skb);
355 }
356
357 put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
358
359 /* Now we could try to dump offended packet options */
360
361 msg->msg_flags |= MSG_ERRQUEUE;
362 err = copied;
363
364 /* Reset and regenerate socket error */
365 spin_lock_irq(&sk->sk_error_queue.lock);
366 sk->sk_err = 0;
367 if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
368 sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
369 spin_unlock_irq(&sk->sk_error_queue.lock);
370 sk->sk_error_report(sk);
371 } else
372 spin_unlock_irq(&sk->sk_error_queue.lock);
373
374 out_free_skb:
375 kfree_skb(skb);
376 out:
377 return err;
378 }
379
380
381 /*
382 * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
383 * an IP socket.
384 */
385
386 int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
387 {
388 struct inet_opt *inet = inet_sk(sk);
389 int val=0,err;
390
391 if (level != SOL_IP)
392 return -ENOPROTOOPT;
393
394 if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) |
395 (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) |
396 (1<<IP_RETOPTS) | (1<<IP_TOS) |
397 (1<<IP_TTL) | (1<<IP_HDRINCL) |
398 (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) |
399 (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND))) ||
400 optname == IP_MULTICAST_TTL ||
401 optname == IP_MULTICAST_LOOP) {
402 if (optlen >= sizeof(int)) {
403 if (get_user(val, (int *) optval))
404 return -EFAULT;
405 } else if (optlen >= sizeof(char)) {
406 unsigned char ucval;
407
408 if (get_user(ucval, (unsigned char *) optval))
409 return -EFAULT;
410 val = (int) ucval;
411 }
412 }
413
414 /* If optlen==0, it is equivalent to val == 0 */
415
416 #ifdef CONFIG_IP_MROUTE
417 if (optname >= MRT_BASE && optname <= (MRT_BASE + 10))
418 return ip_mroute_setsockopt(sk,optname,optval,optlen);
419 #endif
420
421 err = 0;
422 lock_sock(sk);
423
424 switch (optname) {
425 case IP_OPTIONS:
426 {
427 struct ip_options * opt = NULL;
428 if (optlen > 40 || optlen < 0)
429 goto e_inval;
430 err = ip_options_get(&opt, optval, optlen, 1);
431 if (err)
432 break;
433 if (sk->sk_type == SOCK_STREAM) {
434 struct tcp_opt *tp = tcp_sk(sk);
435 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
436 if (sk->sk_family == PF_INET ||
437 (!((1 << sk->sk_state) &
438 (TCPF_LISTEN | TCPF_CLOSE)) &&
439 inet->daddr != LOOPBACK4_IPV6)) {
440 #endif
441 if (inet->opt)
442 tp->ext_header_len -= inet->opt->optlen;
443 if (opt)
444 tp->ext_header_len += opt->optlen;
445 tcp_sync_mss(sk, tp->pmtu_cookie);
446 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
447 }
448 #endif
449 }
450 opt = xchg(&inet->opt, opt);
451 if (opt)
452 kfree(opt);
453 break;
454 }
455 case IP_PKTINFO:
456 if (val)
457 inet->cmsg_flags |= IP_CMSG_PKTINFO;
458 else
459 inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
460 break;
461 case IP_RECVTTL:
462 if (val)
463 inet->cmsg_flags |= IP_CMSG_TTL;
464 else
465 inet->cmsg_flags &= ~IP_CMSG_TTL;
466 break;
467 case IP_RECVTOS:
468 if (val)
469 inet->cmsg_flags |= IP_CMSG_TOS;
470 else
471 inet->cmsg_flags &= ~IP_CMSG_TOS;
472 break;
473 case IP_RECVOPTS:
474 if (val)
475 inet->cmsg_flags |= IP_CMSG_RECVOPTS;
476 else
477 inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
478 break;
479 case IP_RETOPTS:
480 if (val)
481 inet->cmsg_flags |= IP_CMSG_RETOPTS;
482 else
483 inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
484 break;
485 case IP_TOS: /* This sets both TOS and Precedence */
486 if (sk->sk_type == SOCK_STREAM) {
487 val &= ~3;
488 val |= inet->tos & 3;
489 }
490 if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP &&
491 !capable(CAP_NET_ADMIN)) {
492 err = -EPERM;
493 break;
494 }
495 if (inet->tos != val) {
496 inet->tos = val;
497 sk->sk_priority = rt_tos2priority(val);
498 sk_dst_reset(sk);
499 }
500 break;
501 case IP_TTL:
502 if (optlen<1)
503 goto e_inval;
504 if (val != -1 && (val < 1 || val>255))
505 goto e_inval;
506 inet->uc_ttl = val;
507 break;
508 case IP_HDRINCL:
509 if (sk->sk_type != SOCK_RAW) {
510 err = -ENOPROTOOPT;
511 break;
512 }
513 inet->hdrincl = val ? 1 : 0;
514 break;
515 case IP_MTU_DISCOVER:
516 if (val<0 || val>2)
517 goto e_inval;
518 inet->pmtudisc = val;
519 break;
520 case IP_RECVERR:
521 inet->recverr = !!val;
522 if (!val)
523 skb_queue_purge(&sk->sk_error_queue);
524 break;
525 case IP_MULTICAST_TTL:
526 if (sk->sk_type == SOCK_STREAM)
527 goto e_inval;
528 if (optlen<1)
529 goto e_inval;
530 if (val==-1)
531 val = 1;
532 if (val < 0 || val > 255)
533 goto e_inval;
534 inet->mc_ttl = val;
535 break;
536 case IP_MULTICAST_LOOP:
537 if (optlen<1)
538 goto e_inval;
539 inet->mc_loop = !!val;
540 break;
541 case IP_MULTICAST_IF:
542 {
543 struct ip_mreqn mreq;
544 struct net_device *dev = NULL;
545
546 if (sk->sk_type == SOCK_STREAM)
547 goto e_inval;
548 /*
549 * Check the arguments are allowable
550 */
551
552 err = -EFAULT;
553 if (optlen >= sizeof(struct ip_mreqn)) {
554 if (copy_from_user(&mreq,optval,sizeof(mreq)))
555 break;
556 } else {
557 memset(&mreq, 0, sizeof(mreq));
558 if (optlen >= sizeof(struct in_addr) &&
559 copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr)))
560 break;
561 }
562
563 if (!mreq.imr_ifindex) {
564 if (mreq.imr_address.s_addr == INADDR_ANY) {
565 inet->mc_index = 0;
566 inet->mc_addr = 0;
567 err = 0;
568 break;
569 }
570 dev = ip_dev_find(mreq.imr_address.s_addr);
571 if (dev) {
572 mreq.imr_ifindex = dev->ifindex;
573 dev_put(dev);
574 }
575 } else
576 dev = __dev_get_by_index(mreq.imr_ifindex);
577
578
579 err = -EADDRNOTAVAIL;
580 if (!dev)
581 break;
582
583 err = -EINVAL;
584 if (sk->sk_bound_dev_if &&
585 mreq.imr_ifindex != sk->sk_bound_dev_if)
586 break;
587
588 inet->mc_index = mreq.imr_ifindex;
589 inet->mc_addr = mreq.imr_address.s_addr;
590 err = 0;
591 break;
592 }
593
594 case IP_ADD_MEMBERSHIP:
595 case IP_DROP_MEMBERSHIP:
596 {
597 struct ip_mreqn mreq;
598
599 if (optlen < sizeof(struct ip_mreq))
600 goto e_inval;
601 err = -EFAULT;
602 if (optlen >= sizeof(struct ip_mreqn)) {
603 if(copy_from_user(&mreq,optval,sizeof(mreq)))
604 break;
605 } else {
606 memset(&mreq, 0, sizeof(mreq));
607 if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
608 break;
609 }
610
611 if (optname == IP_ADD_MEMBERSHIP)
612 err = ip_mc_join_group(sk, &mreq);
613 else
614 err = ip_mc_leave_group(sk, &mreq);
615 break;
616 }
617 case IP_MSFILTER:
618 {
619 struct ip_msfilter *msf;
620
621 if (optlen < IP_MSFILTER_SIZE(0))
622 goto e_inval;
623 msf = (struct ip_msfilter *)kmalloc(optlen, GFP_KERNEL);
624 if (msf == 0) {
625 err = -ENOBUFS;
626 break;
627 }
628 err = -EFAULT;
629 if (copy_from_user(msf, optval, optlen)) {
630 kfree(msf);
631 break;
632 }
633 err = ip_mc_msfilter(sk, msf, 0);
634 kfree(msf);
635 break;
636 }
637 case IP_BLOCK_SOURCE:
638 case IP_UNBLOCK_SOURCE:
639 case IP_ADD_SOURCE_MEMBERSHIP:
640 case IP_DROP_SOURCE_MEMBERSHIP:
641 {
642 struct ip_mreq_source mreqs;
643 int omode, add;
644
645 if (optlen != sizeof(struct ip_mreq_source))
646 goto e_inval;
647 if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
648 err = -EFAULT;
649 break;
650 }
651 if (optname == IP_BLOCK_SOURCE) {
652 omode = MCAST_EXCLUDE;
653 add = 1;
654 } else if (optname == IP_UNBLOCK_SOURCE) {
655 omode = MCAST_EXCLUDE;
656 add = 0;
657 } else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
658 struct ip_mreqn mreq;
659
660 mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
661 mreq.imr_address.s_addr = mreqs.imr_interface;
662 mreq.imr_ifindex = 0;
663 err = ip_mc_join_group(sk, &mreq);
664 if (err)
665 break;
666 omode = MCAST_INCLUDE;
667 add = 1;
668 } else /*IP_DROP_SOURCE_MEMBERSHIP */ {
669 omode = MCAST_INCLUDE;
670 add = 0;
671 }
672 err = ip_mc_source(add, omode, sk, &mreqs, 0);
673 break;
674 }
675 case MCAST_JOIN_GROUP:
676 case MCAST_LEAVE_GROUP:
677 {
678 struct group_req greq;
679 struct sockaddr_in *psin;
680 struct ip_mreqn mreq;
681
682 if (optlen < sizeof(struct group_req))
683 goto e_inval;
684 err = -EFAULT;
685 if(copy_from_user(&greq, optval, sizeof(greq)))
686 break;
687 psin = (struct sockaddr_in *)&greq.gr_group;
688 if (psin->sin_family != AF_INET)
689 goto e_inval;
690 memset(&mreq, 0, sizeof(mreq));
691 mreq.imr_multiaddr = psin->sin_addr;
692 mreq.imr_ifindex = greq.gr_interface;
693
694 if (optname == MCAST_JOIN_GROUP)
695 err = ip_mc_join_group(sk, &mreq);
696 else
697 err = ip_mc_leave_group(sk, &mreq);
698 break;
699 }
700 case MCAST_JOIN_SOURCE_GROUP:
701 case MCAST_LEAVE_SOURCE_GROUP:
702 case MCAST_BLOCK_SOURCE:
703 case MCAST_UNBLOCK_SOURCE:
704 {
705 struct group_source_req greqs;
706 struct ip_mreq_source mreqs;
707 struct sockaddr_in *psin;
708 int omode, add;
709
710 if (optlen != sizeof(struct group_source_req))
711 goto e_inval;
712 if (copy_from_user(&greqs, optval, sizeof(greqs))) {
713 err = -EFAULT;
714 break;
715 }
716 if (greqs.gsr_group.ss_family != AF_INET ||
717 greqs.gsr_source.ss_family != AF_INET) {
718 err = -EADDRNOTAVAIL;
719 break;
720 }
721 psin = (struct sockaddr_in *)&greqs.gsr_group;
722 mreqs.imr_multiaddr = psin->sin_addr.s_addr;
723 psin = (struct sockaddr_in *)&greqs.gsr_source;
724 mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
725 mreqs.imr_interface = 0; /* use index for mc_source */
726
727 if (optname == MCAST_BLOCK_SOURCE) {
728 omode = MCAST_EXCLUDE;
729 add = 1;
730 } else if (optname == MCAST_UNBLOCK_SOURCE) {
731 omode = MCAST_EXCLUDE;
732 add = 0;
733 } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
734 struct ip_mreqn mreq;
735
736 psin = (struct sockaddr_in *)&greqs.gsr_group;
737 mreq.imr_multiaddr = psin->sin_addr;
738 mreq.imr_address.s_addr = 0;
739 mreq.imr_ifindex = greqs.gsr_interface;
740 err = ip_mc_join_group(sk, &mreq);
741 if (err)
742 break;
743 omode = MCAST_INCLUDE;
744 add = 1;
745 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
746 omode = MCAST_INCLUDE;
747 add = 0;
748 }
749 err = ip_mc_source(add, omode, sk, &mreqs,
750 greqs.gsr_interface);
751 break;
752 }
753 case MCAST_MSFILTER:
754 {
755 struct sockaddr_in *psin;
756 struct ip_msfilter *msf = 0;
757 struct group_filter *gsf = 0;
758 int msize, i, ifindex;
759
760 if (optlen < GROUP_FILTER_SIZE(0))
761 goto e_inval;
762 gsf = (struct group_filter *)kmalloc(optlen,GFP_KERNEL);
763 if (gsf == 0) {
764 err = -ENOBUFS;
765 break;
766 }
767 err = -EFAULT;
768 if (copy_from_user(gsf, optval, optlen)) {
769 goto mc_msf_out;
770 }
771 if (GROUP_FILTER_SIZE(gsf->gf_numsrc) < optlen) {
772 err = EINVAL;
773 goto mc_msf_out;
774 }
775 msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
776 msf = (struct ip_msfilter *)kmalloc(msize,GFP_KERNEL);
777 if (msf == 0) {
778 err = -ENOBUFS;
779 goto mc_msf_out;
780 }
781 ifindex = gsf->gf_interface;
782 psin = (struct sockaddr_in *)&gsf->gf_group;
783 if (psin->sin_family != AF_INET) {
784 err = -EADDRNOTAVAIL;
785 goto mc_msf_out;
786 }
787 msf->imsf_multiaddr = psin->sin_addr.s_addr;
788 msf->imsf_interface = 0;
789 msf->imsf_fmode = gsf->gf_fmode;
790 msf->imsf_numsrc = gsf->gf_numsrc;
791 err = -EADDRNOTAVAIL;
792 for (i=0; i<gsf->gf_numsrc; ++i) {
793 psin = (struct sockaddr_in *)&gsf->gf_slist[i];
794
795 if (psin->sin_family != AF_INET)
796 goto mc_msf_out;
797 msf->imsf_slist[i] = psin->sin_addr.s_addr;
798 }
799 kfree(gsf);
800 gsf = 0;
801
802 err = ip_mc_msfilter(sk, msf, ifindex);
803 mc_msf_out:
804 if (msf)
805 kfree(msf);
806 if (gsf)
807 kfree(gsf);
808 break;
809 }
810 case IP_ROUTER_ALERT:
811 err = ip_ra_control(sk, val ? 1 : 0, NULL);
812 break;
813
814 case IP_FREEBIND:
815 if (optlen<1)
816 goto e_inval;
817 inet->freebind = !!val;
818 break;
819
820 case IP_IPSEC_POLICY:
821 case IP_XFRM_POLICY:
822 err = xfrm_user_policy(sk, optname, optval, optlen);
823 break;
824
825 default:
826 #ifdef CONFIG_NETFILTER
827 err = nf_setsockopt(sk, PF_INET, optname, optval,
828 optlen);
829 #else
830 err = -ENOPROTOOPT;
831 #endif
832 break;
833 }
834 release_sock(sk);
835 return err;
836
837 e_inval:
838 release_sock(sk);
839 return -EINVAL;
840 }
841
842 /*
843 * Get the options. Note for future reference. The GET of IP options gets the
844 * _received_ ones. The set sets the _sent_ ones.
845 */
846
847 int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
848 {
849 struct inet_opt *inet = inet_sk(sk);
850 int val;
851 int len;
852
853 if(level!=SOL_IP)
854 return -EOPNOTSUPP;
855
856 #ifdef CONFIG_IP_MROUTE
857 if(optname>=MRT_BASE && optname <=MRT_BASE+10)
858 {
859 return ip_mroute_getsockopt(sk,optname,optval,optlen);
860 }
861 #endif
862
863 if(get_user(len,optlen))
864 return -EFAULT;
865 if(len < 0)
866 return -EINVAL;
867
868 lock_sock(sk);
869
870 switch(optname) {
871 case IP_OPTIONS:
872 {
873 unsigned char optbuf[sizeof(struct ip_options)+40];
874 struct ip_options * opt = (struct ip_options*)optbuf;
875 opt->optlen = 0;
876 if (inet->opt)
877 memcpy(optbuf, inet->opt,
878 sizeof(struct ip_options)+
879 inet->opt->optlen);
880 release_sock(sk);
881
882 if (opt->optlen == 0)
883 return put_user(0, optlen);
884
885 ip_options_undo(opt);
886
887 len = min_t(unsigned int, len, opt->optlen);
888 if(put_user(len, optlen))
889 return -EFAULT;
890 if(copy_to_user(optval, opt->__data, len))
891 return -EFAULT;
892 return 0;
893 }
894 case IP_PKTINFO:
895 val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
896 break;
897 case IP_RECVTTL:
898 val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
899 break;
900 case IP_RECVTOS:
901 val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
902 break;
903 case IP_RECVOPTS:
904 val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
905 break;
906 case IP_RETOPTS:
907 val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
908 break;
909 case IP_TOS:
910 val = inet->tos;
911 break;
912 case IP_TTL:
913 val = (inet->uc_ttl == -1 ?
914 sysctl_ip_default_ttl :
915 inet->uc_ttl);
916 break;
917 case IP_HDRINCL:
918 val = inet->hdrincl;
919 break;
920 case IP_MTU_DISCOVER:
921 val = inet->pmtudisc;
922 break;
923 case IP_MTU:
924 {
925 struct dst_entry *dst;
926 val = 0;
927 dst = sk_dst_get(sk);
928 if (dst) {
929 val = dst_pmtu(dst) - dst->header_len;
930 dst_release(dst);
931 }
932 if (!val) {
933 release_sock(sk);
934 return -ENOTCONN;
935 }
936 break;
937 }
938 case IP_RECVERR:
939 val = inet->recverr;
940 break;
941 case IP_MULTICAST_TTL:
942 val = inet->mc_ttl;
943 break;
944 case IP_MULTICAST_LOOP:
945 val = inet->mc_loop;
946 break;
947 case IP_MULTICAST_IF:
948 {
949 struct in_addr addr;
950 len = min_t(unsigned int, len, sizeof(struct in_addr));
951 addr.s_addr = inet->mc_addr;
952 release_sock(sk);
953
954 if(put_user(len, optlen))
955 return -EFAULT;
956 if(copy_to_user((void *)optval, &addr, len))
957 return -EFAULT;
958 return 0;
959 }
960 case IP_MSFILTER:
961 {
962 struct ip_msfilter msf;
963 int err;
964
965 if (len < IP_MSFILTER_SIZE(0)) {
966 release_sock(sk);
967 return -EINVAL;
968 }
969 if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
970 release_sock(sk);
971 return -EFAULT;
972 }
973 err = ip_mc_msfget(sk, &msf,
974 (struct ip_msfilter *)optval, optlen);
975 release_sock(sk);
976 return err;
977 }
978 case MCAST_MSFILTER:
979 {
980 struct group_filter gsf;
981 int err;
982
983 if (len < GROUP_FILTER_SIZE(0)) {
984 release_sock(sk);
985 return -EINVAL;
986 }
987 if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
988 release_sock(sk);
989 return -EFAULT;
990 }
991 err = ip_mc_gsfget(sk, &gsf,
992 (struct group_filter *)optval, optlen);
993 release_sock(sk);
994 return err;
995 }
996 case IP_PKTOPTIONS:
997 {
998 struct msghdr msg;
999
1000 release_sock(sk);
1001
1002 if (sk->sk_type != SOCK_STREAM)
1003 return -ENOPROTOOPT;
1004
1005 msg.msg_control = optval;
1006 msg.msg_controllen = len;
1007 msg.msg_flags = 0;
1008
1009 if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
1010 struct in_pktinfo info;
1011
1012 info.ipi_addr.s_addr = inet->rcv_saddr;
1013 info.ipi_spec_dst.s_addr = inet->rcv_saddr;
1014 info.ipi_ifindex = inet->mc_index;
1015 put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
1016 }
1017 if (inet->cmsg_flags & IP_CMSG_TTL) {
1018 int hlim = inet->mc_ttl;
1019 put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
1020 }
1021 len -= msg.msg_controllen;
1022 return put_user(len, optlen);
1023 }
1024 case IP_FREEBIND:
1025 val = inet->freebind;
1026 break;
1027 default:
1028 #ifdef CONFIG_NETFILTER
1029 val = nf_getsockopt(sk, PF_INET, optname, optval,
1030 &len);
1031 release_sock(sk);
1032 if (val >= 0)
1033 val = put_user(len, optlen);
1034 return val;
1035 #else
1036 release_sock(sk);
1037 return -ENOPROTOOPT;
1038 #endif
1039 }
1040 release_sock(sk);
1041
1042 if (len < sizeof(int) && len > 0 && val>=0 && val<255) {
1043 unsigned char ucval = (unsigned char)val;
1044 len = 1;
1045 if(put_user(len, optlen))
1046 return -EFAULT;
1047 if(copy_to_user(optval,&ucval,1))
1048 return -EFAULT;
1049 } else {
1050 len = min_t(unsigned int, sizeof(int), len);
1051 if(put_user(len, optlen))
1052 return -EFAULT;
1053 if(copy_to_user(optval,&val,len))
1054 return -EFAULT;
1055 }
1056 return 0;
1057 }
Mirror of the linux-mips.org kernel tree