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