?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pre-2.3.4..
[davej-history.git] / net / ipv4 / ip_sockglue.c
blob369a6770cc5e5a249a4ab4a4499a7af1e00c9d9a
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.42 1999/04/22 10:07:34 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/firewall.h>
36 #include <linux/ip_fw.h>
37 #include <linux/route.h>
38 #include <linux/mroute.h>
39 #include <net/route.h>
40 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
41 #include <net/transp_v6.h>
42 #endif
43
44 #ifdef CONFIG_IP_MASQUERADE
45 #include <linux/ip_masq.h>
46 #endif
47
48 #include <linux/errqueue.h>
49 #include <asm/uaccess.h>
50
51 #define MAX(a,b) ((a)>(b)?(a):(b))
52
53 #define IP_CMSG_PKTINFO 1
54 #define IP_CMSG_TTL 2
55 #define IP_CMSG_TOS 4
56 #define IP_CMSG_RECVOPTS 8
57 #define IP_CMSG_RETOPTS 16
58
59 /*
60 * SOL_IP control messages.
61 */
62
63 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
64 {
65 struct in_pktinfo info;
66 struct rtable *rt = (struct rtable *)skb->dst;
67
68 info.ipi_addr.s_addr = skb->nh.iph->daddr;
69 if (rt) {
70 info.ipi_ifindex = rt->rt_iif;
71 info.ipi_spec_dst.s_addr = rt->rt_spec_dst;
72 } else {
73 info.ipi_ifindex = 0;
74 info.ipi_spec_dst.s_addr = 0;
75 }
76
77 put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
78 }
79
80 static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
81 {
82 int ttl = skb->nh.iph->ttl;
83 put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
84 }
85
86 static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
87 {
88 put_cmsg(msg, SOL_IP, IP_TOS, 1, &skb->nh.iph->tos);
89 }
90
91 static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
92 {
93 if (IPCB(skb)->opt.optlen == 0)
94 return;
95
96 put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen, skb->nh.iph+1);
97 }
98
99
100 void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
101 {
102 unsigned char optbuf[sizeof(struct ip_options) + 40];
103 struct ip_options * opt = (struct ip_options*)optbuf;
104
105 if (IPCB(skb)->opt.optlen == 0)
106 return;
107
108 if (ip_options_echo(opt, skb)) {
109 msg->msg_flags |= MSG_CTRUNC;
110 return;
111 }
112 ip_options_undo(opt);
113
114 put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
115 }
116
117
118 void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
119 {
120 unsigned flags = skb->sk->ip_cmsg_flags;
121
122 /* Ordered by supposed usage frequency */
123 if (flags & 1)
124 ip_cmsg_recv_pktinfo(msg, skb);
125 if ((flags>>=1) == 0)
126 return;
127
128 if (flags & 1)
129 ip_cmsg_recv_ttl(msg, skb);
130 if ((flags>>=1) == 0)
131 return;
132
133 if (flags & 1)
134 ip_cmsg_recv_tos(msg, skb);
135 if ((flags>>=1) == 0)
136 return;
137
138 if (flags & 1)
139 ip_cmsg_recv_opts(msg, skb);
140 if ((flags>>=1) == 0)
141 return;
142
143 if (flags & 1)
144 ip_cmsg_recv_retopts(msg, skb);
145 }
146
147 int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc)
148 {
149 int err;
150 struct cmsghdr *cmsg;
151
152 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
153 if (cmsg->cmsg_len < sizeof(struct cmsghdr) ||
154 (unsigned long)(((char*)cmsg - (char*)msg->msg_control)
155 + cmsg->cmsg_len) > msg->msg_controllen) {
156 return -EINVAL;
157 }
158 if (cmsg->cmsg_level != SOL_IP)
159 continue;
160 switch (cmsg->cmsg_type) {
161 case IP_RETOPTS:
162 err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
163 err = ip_options_get(&ipc->opt, CMSG_DATA(cmsg), err < 40 ? err : 40, 0);
164 if (err)
165 return err;
166 break;
167 case IP_PKTINFO:
168 {
169 struct in_pktinfo *info;
170 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
171 return -EINVAL;
172 info = (struct in_pktinfo *)CMSG_DATA(cmsg);
173 ipc->oif = info->ipi_ifindex;
174 ipc->addr = info->ipi_spec_dst.s_addr;
175 break;
176 }
177 default:
178 return -EINVAL;
179 }
180 }
181 return 0;
182 }
183
184
185 /* Special input handler for packets catched by router alert option.
186 They are selected only by protocol field, and then processed likely
187 local ones; but only if someone wants them! Otherwise, router
188 not running rsvpd will kill RSVP.
189
190 It is user level problem, what it will make with them.
191 I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
192 but receiver should be enough clever f.e. to forward mtrace requests,
193 sent to multicast group to reach destination designated router.
194 */
195 struct ip_ra_chain *ip_ra_chain;
196
197 int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *))
198 {
199 struct ip_ra_chain *ra, *new_ra, **rap;
200
201 if (sk->type != SOCK_RAW || sk->num == IPPROTO_RAW)
202 return -EINVAL;
203
204 new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
205
206 for (rap = &ip_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
207 if (ra->sk == sk) {
208 if (on) {
209 if (new_ra)
210 kfree(new_ra);
211 return -EADDRINUSE;
212 }
213 *rap = ra->next;
214 synchronize_bh();
215
216 if (ra->destructor)
217 ra->destructor(sk);
218 kfree(ra);
219 return 0;
220 }
221 }
222 if (new_ra == NULL)
223 return -ENOBUFS;
224 new_ra->sk = sk;
225 new_ra->destructor = destructor;
226
227 new_ra->next = ra;
228 wmb();
229 *rap = new_ra;
230
231 return 0;
232 }
233
234 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
235 u16 port, u32 info, u8 *payload)
236 {
237 struct sock_exterr_skb *serr;
238
239 if (!sk->ip_recverr)
240 return;
241
242 skb = skb_clone(skb, GFP_ATOMIC);
243 if (!skb)
244 return;
245
246 serr = SKB_EXT_ERR(skb);
247 serr->ee.ee_errno = err;
248 serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
249 serr->ee.ee_type = skb->h.icmph->type;
250 serr->ee.ee_code = skb->h.icmph->code;
251 serr->ee.ee_pad = 0;
252 serr->ee.ee_info = info;
253 serr->ee.ee_data = 0;
254 serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw;
255 serr->port = port;
256
257 skb->h.raw = payload;
258 skb_pull(skb, payload - skb->data);
259
260 if (sock_queue_err_skb(sk, skb))
261 kfree_skb(skb);
262 }
263
264 void ip_local_error(struct sock *sk, int err, u32 daddr, u16 port, u32 info)
265 {
266 struct sock_exterr_skb *serr;
267 struct iphdr *iph;
268 struct sk_buff *skb;
269
270 if (!sk->ip_recverr)
271 return;
272
273 skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
274 if (!skb)
275 return;
276
277 iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr));
278 skb->nh.iph = iph;
279 iph->daddr = daddr;
280
281 serr = SKB_EXT_ERR(skb);
282 serr->ee.ee_errno = err;
283 serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
284 serr->ee.ee_type = 0;
285 serr->ee.ee_code = 0;
286 serr->ee.ee_pad = 0;
287 serr->ee.ee_info = info;
288 serr->ee.ee_data = 0;
289 serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw;
290 serr->port = port;
291
292 skb->h.raw = skb->tail;
293 skb_pull(skb, skb->tail - skb->data);
294
295 if (sock_queue_err_skb(sk, skb))
296 kfree_skb(skb);
297 }
298
299 /*
300 * Handle MSG_ERRQUEUE
301 */
302 int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
303 {
304 struct sock_exterr_skb *serr;
305 struct sk_buff *skb, *skb2;
306 struct sockaddr_in *sin;
307 struct {
308 struct sock_extended_err ee;
309 struct sockaddr_in offender;
310 } errhdr;
311 int err;
312 int copied;
313
314 err = -EAGAIN;
315 skb = skb_dequeue(&sk->error_queue);
316 if (skb == NULL)
317 goto out;
318
319 copied = skb->len;
320 if (copied > len) {
321 msg->msg_flags |= MSG_TRUNC;
322 copied = len;
323 }
324 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
325 if (err)
326 goto out_free_skb;
327
328 serr = SKB_EXT_ERR(skb);
329
330 sin = (struct sockaddr_in *)msg->msg_name;
331 if (sin) {
332 sin->sin_family = AF_INET;
333 sin->sin_addr.s_addr = *(u32*)(skb->nh.raw + serr->addr_offset);
334 sin->sin_port = serr->port;
335 }
336
337 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
338 sin = &errhdr.offender;
339 sin->sin_family = AF_UNSPEC;
340 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
341 sin->sin_family = AF_INET;
342 sin->sin_addr.s_addr = skb->nh.iph->saddr;
343 if (sk->ip_cmsg_flags)
344 ip_cmsg_recv(msg, skb);
345 }
346
347 put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);
348
349 /* Now we could try to dump offended packet options */
350
351 msg->msg_flags |= MSG_ERRQUEUE;
352 err = copied;
353
354 /* Reset and regenerate socket error */
355 sk->err = 0;
356 if ((skb2 = skb_peek(&sk->error_queue)) != NULL) {
357 sk->err = SKB_EXT_ERR(skb2)->ee.ee_errno;
358 sk->error_report(sk);
359 }
360
361 out_free_skb:
362 kfree_skb(skb);
363 out:
364 return err;
365 }
366
367
368 /*
369 * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on
370 * an IP socket.
371 *
372 * We implement IP_TOS (type of service), IP_TTL (time to live).
373 */
374
375 int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
376 {
377 int val=0,err;
378 #if defined(CONFIG_IP_FIREWALL)
379 char tmp_fw[MAX(sizeof(struct ip_fwtest),sizeof(struct ip_fwnew))];
380 #endif
381 if(optlen>=sizeof(int)) {
382 if(get_user(val, (int *) optval))
383 return -EFAULT;
384 } else if(optlen>=sizeof(char)) {
385 unsigned char ucval;
386 if(get_user(ucval, (unsigned char *) optval))
387 return -EFAULT;
388 val = (int)ucval;
389 }
390 /* If optlen==0, it is equivalent to val == 0 */
391
392 if(level!=SOL_IP)
393 return -ENOPROTOOPT;
394 #ifdef CONFIG_IP_MROUTE
395 if(optname>=MRT_BASE && optname <=MRT_BASE+10)
396 {
397 return ip_mroute_setsockopt(sk,optname,optval,optlen);
398 }
399 #endif
400
401 switch(optname)
402 {
403 case IP_OPTIONS:
404 {
405 struct ip_options * opt = NULL;
406 if (optlen > 40 || optlen < 0)
407 return -EINVAL;
408 err = ip_options_get(&opt, optval, optlen, 1);
409 if (err)
410 return err;
411 lock_sock(sk);
412 if (sk->type == SOCK_STREAM) {
413 struct tcp_opt *tp = &sk->tp_pinfo.af_tcp;
414 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
415 if (sk->family == PF_INET ||
416 ((tcp_connected(sk->state) || sk->state == TCP_SYN_SENT)
417 && sk->daddr != LOOPBACK4_IPV6)) {
418 #endif
419 if (opt)
420 tp->ext_header_len = opt->optlen;
421 tcp_sync_mss(sk, tp->pmtu_cookie);
422 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
423 }
424 #endif
425 }
426 opt = xchg(&sk->opt, opt);
427 release_sock(sk);
428 if (opt)
429 kfree_s(opt, sizeof(struct ip_options) + opt->optlen);
430 return 0;
431 }
432 case IP_PKTINFO:
433 if (val)
434 sk->ip_cmsg_flags |= IP_CMSG_PKTINFO;
435 else
436 sk->ip_cmsg_flags &= ~IP_CMSG_PKTINFO;
437 return 0;
438 case IP_RECVTTL:
439 if (val)
440 sk->ip_cmsg_flags |= IP_CMSG_TTL;
441 else
442 sk->ip_cmsg_flags &= ~IP_CMSG_TTL;
443 return 0;
444 case IP_RECVTOS:
445 if (val)
446 sk->ip_cmsg_flags |= IP_CMSG_TOS;
447 else
448 sk->ip_cmsg_flags &= ~IP_CMSG_TOS;
449 return 0;
450 case IP_RECVOPTS:
451 if (val)
452 sk->ip_cmsg_flags |= IP_CMSG_RECVOPTS;
453 else
454 sk->ip_cmsg_flags &= ~IP_CMSG_RECVOPTS;
455 return 0;
456 case IP_RETOPTS:
457 if (val)
458 sk->ip_cmsg_flags |= IP_CMSG_RETOPTS;
459 else
460 sk->ip_cmsg_flags &= ~IP_CMSG_RETOPTS;
461 return 0;
462 case IP_TOS: /* This sets both TOS and Precedence */
463 /* Reject setting of unused bits */
464 if (val & ~(IPTOS_TOS_MASK|IPTOS_PREC_MASK))
465 return -EINVAL;
466 if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP &&
467 !capable(CAP_NET_ADMIN))
468 return -EPERM;
469 if (sk->ip_tos != val) {
470 lock_sock(sk);
471 sk->ip_tos=val;
472 sk->priority = rt_tos2priority(val);
473 dst_release(xchg(&sk->dst_cache, NULL));
474 release_sock(sk);
475 }
476 return 0;
477 case IP_TTL:
478 if (optlen<1)
479 return -EINVAL;
480 if(val==-1)
481 val = ip_statistics.IpDefaultTTL;
482 if(val<1||val>255)
483 return -EINVAL;
484 sk->ip_ttl=val;
485 return 0;
486 case IP_HDRINCL:
487 if(sk->type!=SOCK_RAW)
488 return -ENOPROTOOPT;
489 sk->ip_hdrincl=val?1:0;
490 return 0;
491 case IP_MTU_DISCOVER:
492 if (val<0 || val>2)
493 return -EINVAL;
494 sk->ip_pmtudisc = val;
495 return 0;
496 case IP_RECVERR:
497 sk->ip_recverr = !!val;
498 if (!val)
499 skb_queue_purge(&sk->error_queue);
500 return 0;
501 case IP_MULTICAST_TTL:
502 if (optlen<1)
503 return -EINVAL;
504 if (val==-1)
505 val = 1;
506 if (val < 0 || val > 255)
507 return -EINVAL;
508 sk->ip_mc_ttl=val;
509 return 0;
510 case IP_MULTICAST_LOOP:
511 if (optlen<1)
512 return -EINVAL;
513 sk->ip_mc_loop = val ? 1 : 0;
514 return 0;
515 case IP_MULTICAST_IF:
516 {
517 struct ip_mreqn mreq;
518 struct device *dev = NULL;
519
520 /*
521 * Check the arguments are allowable
522 */
523
524 if (optlen >= sizeof(struct ip_mreqn)) {
525 if (copy_from_user(&mreq,optval,sizeof(mreq)))
526 return -EFAULT;
527 } else {
528 memset(&mreq, 0, sizeof(mreq));
529 if (optlen >= sizeof(struct in_addr) &&
530 copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr)))
531 return -EFAULT;
532 }
533
534 if (!mreq.imr_ifindex) {
535 if (mreq.imr_address.s_addr == INADDR_ANY) {
536 sk->ip_mc_index = 0;
537 sk->ip_mc_addr = 0;
538 return 0;
539 }
540 dev = ip_dev_find(mreq.imr_address.s_addr);
541 } else
542 dev = dev_get_by_index(mreq.imr_ifindex);
543
544 if (!dev)
545 return -EADDRNOTAVAIL;
546
547 if (sk->bound_dev_if && dev->ifindex != sk->bound_dev_if)
548 return -EINVAL;
549
550 sk->ip_mc_index = mreq.imr_ifindex;
551 sk->ip_mc_addr = mreq.imr_address.s_addr;
552 return 0;
553 }
554
555 case IP_ADD_MEMBERSHIP:
556 case IP_DROP_MEMBERSHIP:
557 {
558 struct ip_mreqn mreq;
559
560 if (optlen < sizeof(struct ip_mreq))
561 return -EINVAL;
562 if (optlen >= sizeof(struct ip_mreqn)) {
563 if(copy_from_user(&mreq,optval,sizeof(mreq)))
564 return -EFAULT;
565 } else {
566 memset(&mreq, 0, sizeof(mreq));
567 if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq)))
568 return -EFAULT;
569 }
570
571 if (optname == IP_ADD_MEMBERSHIP)
572 return ip_mc_join_group(sk,&mreq);
573 else
574 return ip_mc_leave_group(sk,&mreq);
575 }
576 case IP_ROUTER_ALERT:
577 return ip_ra_control(sk, val ? 1 : 0, NULL);
578
579 #ifdef CONFIG_IP_FIREWALL
580 case IP_FW_MASQ_TIMEOUTS:
581 case IP_FW_APPEND:
582 case IP_FW_REPLACE:
583 case IP_FW_DELETE:
584 case IP_FW_DELETE_NUM:
585 case IP_FW_INSERT:
586 case IP_FW_FLUSH:
587 case IP_FW_ZERO:
588 case IP_FW_CHECK:
589 case IP_FW_CREATECHAIN:
590 case IP_FW_DELETECHAIN:
591 case IP_FW_POLICY:
592 if(!capable(CAP_NET_ADMIN))
593 return -EACCES;
594 if(optlen>sizeof(tmp_fw) || optlen<1)
595 return -EINVAL;
596 if(copy_from_user(&tmp_fw,optval,optlen))
597 return -EFAULT;
598 err=ip_fw_ctl(optname, &tmp_fw,optlen);
599 return -err; /* -0 is 0 after all */
600 #endif /* CONFIG_IP_FIREWALL */
601 #ifdef CONFIG_IP_MASQUERADE
602 case IP_FW_MASQ_CTL:
603 if(!capable(CAP_NET_ADMIN))
604 return -EPERM;
605 if(optlen<1)
606 return -EINVAL;
607 err=ip_masq_uctl(optname, optval ,optlen);
608 return err;
609
610 #endif
611 default:
612 return(-ENOPROTOOPT);
613 }
614 }
615
616 /*
617 * Get the options. Note for future reference. The GET of IP options gets the
618 * _received_ ones. The set sets the _sent_ ones.
619 */
620
621 int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
622 {
623 int val;
624 int len;
625
626 if(level!=SOL_IP)
627 return -EOPNOTSUPP;
628
629 #ifdef CONFIG_IP_MROUTE
630 if(optname>=MRT_BASE && optname <=MRT_BASE+10)
631 {
632 return ip_mroute_getsockopt(sk,optname,optval,optlen);
633 }
634 #endif
635
636 if(get_user(len,optlen))
637 return -EFAULT;
638
639 switch(optname)
640 {
641 case IP_OPTIONS:
642 {
643 unsigned char optbuf[sizeof(struct ip_options)+40];
644 struct ip_options * opt = (struct ip_options*)optbuf;
645 lock_sock(sk);
646 opt->optlen = 0;
647 if (sk->opt)
648 memcpy(optbuf, sk->opt, sizeof(struct ip_options)+sk->opt->optlen);
649 release_sock(sk);
650 if (opt->optlen == 0)
651 return put_user(0, optlen);
652
653 ip_options_undo(opt);
654
655 len=min(len, opt->optlen);
656 if(put_user(len, optlen))
657 return -EFAULT;
658 if(copy_to_user(optval, opt->__data, len))
659 return -EFAULT;
660 return 0;
661 }
662 case IP_PKTINFO:
663 val = (sk->ip_cmsg_flags & IP_CMSG_PKTINFO) != 0;
664 break;
665 case IP_RECVTTL:
666 val = (sk->ip_cmsg_flags & IP_CMSG_TTL) != 0;
667 break;
668 case IP_RECVTOS:
669 val = (sk->ip_cmsg_flags & IP_CMSG_TOS) != 0;
670 break;
671 case IP_RECVOPTS:
672 val = (sk->ip_cmsg_flags & IP_CMSG_RECVOPTS) != 0;
673 break;
674 case IP_RETOPTS:
675 val = (sk->ip_cmsg_flags & IP_CMSG_RETOPTS) != 0;
676 break;
677 case IP_TOS:
678 val=sk->ip_tos;
679 break;
680 case IP_TTL:
681 val=sk->ip_ttl;
682 break;
683 case IP_HDRINCL:
684 val=sk->ip_hdrincl;
685 break;
686 case IP_MTU_DISCOVER:
687 val=sk->ip_pmtudisc;
688 break;
689 case IP_MTU:
690 val = 0;
691 lock_sock(sk);
692 if (sk->dst_cache)
693 val = sk->dst_cache->pmtu;
694 release_sock(sk);
695 if (!val)
696 return -ENOTCONN;
697 break;
698 case IP_RECVERR:
699 val=sk->ip_recverr;
700 break;
701 case IP_MULTICAST_TTL:
702 val=sk->ip_mc_ttl;
703 break;
704 case IP_MULTICAST_LOOP:
705 val=sk->ip_mc_loop;
706 break;
707 case IP_MULTICAST_IF:
708 {
709 struct ip_mreqn mreq;
710 len = min(len,sizeof(struct ip_mreqn));
711 if(put_user(len, optlen))
712 return -EFAULT;
713 mreq.imr_ifindex = sk->ip_mc_index;
714 mreq.imr_address.s_addr = sk->ip_mc_addr;
715 mreq.imr_multiaddr.s_addr = 0;
716 if(copy_to_user((void *)optval, &mreq, len))
717 return -EFAULT;
718 return 0;
719 }
720 default:
721 return(-ENOPROTOOPT);
722 }
723
724 if (len < sizeof(int) && len > 0 && val>=0 && val<255) {
725 unsigned char ucval = (unsigned char)val;
726 len = 1;
727 if(put_user(len, optlen))
728 return -EFAULT;
729 if(copy_to_user(optval,&ucval,1))
730 return -EFAULT;
731 } else {
732 len=min(sizeof(int),len);
733 if(put_user(len, optlen))
734 return -EFAULT;
735 if(copy_to_user(optval,&val,len))
736 return -EFAULT;
737 }
738 return 0;
739 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux