/* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * The IP to API glue. * * Version: $Id: ip_sockglue.c,v 1.54 2000/11/28 13:34:56 davem Exp $ * * Authors: see ip.c * * Fixes: * Many : Split from ip.c , see ip.c for history. * Martin Mares : TOS setting fixed. * Alan Cox : Fixed a couple of oopses in Martin's * TOS tweaks. * Mike McLagan : Routing by source */ #include <linux/config.h> #include <linux/types.h> #include <linux/mm.h> #include <linux/sched.h> #include <linux/skbuff.h> #include <linux/ip.h> #include <linux/icmp.h> #include <linux/netdevice.h> #include <net/sock.h> #include <net/ip.h> #include <net/icmp.h> #include <net/tcp.h> #include <linux/tcp.h> #include <linux/udp.h> #include <linux/igmp.h> #include <linux/netfilter.h> #include <linux/route.h> #include <linux/mroute.h> #include <net/route.h> #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) #include <net/transp_v6.h> #endif #include <linux/errqueue.h> #include <asm/uaccess.h> #define MAX(a,b) ((a)>(b)?(a):(b)) #define IP_CMSG_PKTINFO 1 #define IP_CMSG_TTL 2 #define IP_CMSG_TOS 4 #define IP_CMSG_RECVOPTS 8 #define IP_CMSG_RETOPTS 16 /* * SOL_IP control messages. */ 58 static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb) { struct in_pktinfo info; struct rtable *rt = (struct rtable *)skb->dst; info.ipi_addr.s_addr = skb->nh.iph->daddr; 64 if (rt) { info.ipi_ifindex = rt->rt_iif; info.ipi_spec_dst.s_addr = rt->rt_spec_dst; 67 } else { info.ipi_ifindex = 0; info.ipi_spec_dst.s_addr = 0; } put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info); } 75 static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb) { int ttl = skb->nh.iph->ttl; put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl); } 81 static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb) { put_cmsg(msg, SOL_IP, IP_TOS, 1, &skb->nh.iph->tos); } 86 static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb) { 88 if (IPCB(skb)->opt.optlen == 0) 89 return; put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen, skb->nh.iph+1); } 95 void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb) { unsigned char optbuf[sizeof(struct ip_options) + 40]; struct ip_options * opt = (struct ip_options*)optbuf; 100 if (IPCB(skb)->opt.optlen == 0) 101 return; 103 if (ip_options_echo(opt, skb)) { msg->msg_flags |= MSG_CTRUNC; 105 return; } ip_options_undo(opt); put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data); } 113 void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb) { unsigned flags = skb->sk->protinfo.af_inet.cmsg_flags; /* Ordered by supposed usage frequency */ 118 if (flags & 1) ip_cmsg_recv_pktinfo(msg, skb); 120 if ((flags>>=1) == 0) 121 return; 123 if (flags & 1) ip_cmsg_recv_ttl(msg, skb); 125 if ((flags>>=1) == 0) 126 return; 128 if (flags & 1) ip_cmsg_recv_tos(msg, skb); 130 if ((flags>>=1) == 0) 131 return; 133 if (flags & 1) ip_cmsg_recv_opts(msg, skb); 135 if ((flags>>=1) == 0) 136 return; 138 if (flags & 1) ip_cmsg_recv_retopts(msg, skb); } 142 int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc) { int err; struct cmsghdr *cmsg; 147 for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) { if (cmsg->cmsg_len < sizeof(struct cmsghdr) || (unsigned long)(((char*)cmsg - (char*)msg->msg_control) 150 + cmsg->cmsg_len) > msg->msg_controllen) { 151 return -EINVAL; } 153 if (cmsg->cmsg_level != SOL_IP) 154 continue; 155 switch (cmsg->cmsg_type) { 156 case IP_RETOPTS: err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr)); 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: { struct in_pktinfo *info; 165 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo))) 166 return -EINVAL; info = (struct in_pktinfo *)CMSG_DATA(cmsg); ipc->oif = info->ipi_ifindex; ipc->addr = info->ipi_spec_dst.s_addr; 170 break; } 172 default: 173 return -EINVAL; } } 176 return 0; } /* Special input handler for packets catched by router alert option. They are selected only by protocol field, and then processed likely local ones; but only if someone wants them! Otherwise, router not running rsvpd will kill RSVP. It is user level problem, what it will make with them. I have no idea, how it will masquearde or NAT them (it is joke, joke :-)), but receiver should be enough clever f.e. to forward mtrace requests, sent to multicast group to reach destination designated router. */ struct ip_ra_chain *ip_ra_chain; rwlock_t ip_ra_lock = RW_LOCK_UNLOCKED; 193 int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *)) { struct ip_ra_chain *ra, *new_ra, **rap; 197 if (sk->type != SOCK_RAW || sk->num == IPPROTO_RAW) 198 return -EINVAL; new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL; 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) kfree(new_ra); 209 return -EADDRINUSE; } *rap = ra->next; 212 write_unlock_bh(&ip_ra_lock); 214 if (ra->destructor) ra->destructor(sk); sock_put(sk); kfree(ra); 218 return 0; } } 221 if (new_ra == NULL) { 222 write_unlock_bh(&ip_ra_lock); 223 return -ENOBUFS; } new_ra->sk = sk; new_ra->destructor = destructor; new_ra->next = ra; *rap = new_ra; sock_hold(sk); 231 write_unlock_bh(&ip_ra_lock); 233 return 0; } 236 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, u16 port, u32 info, u8 *payload) { struct sock_exterr_skb *serr; 241 if (!sk->protinfo.af_inet.recverr) 242 return; skb = skb_clone(skb, GFP_ATOMIC); 245 if (!skb) 246 return; serr = SKB_EXT_ERR(skb); serr->ee.ee_errno = err; serr->ee.ee_origin = SO_EE_ORIGIN_ICMP; serr->ee.ee_type = skb->h.icmph->type; serr->ee.ee_code = skb->h.icmph->code; serr->ee.ee_pad = 0; serr->ee.ee_info = info; serr->ee.ee_data = 0; serr->addr_offset = (u8*)&(((struct iphdr*)(skb->h.icmph+1))->daddr) - skb->nh.raw; serr->port = port; skb->h.raw = payload; skb_pull(skb, payload - skb->data); 262 if (sock_queue_err_skb(sk, skb)) kfree_skb(skb); } 266 void ip_local_error(struct sock *sk, int err, u32 daddr, u16 port, u32 info) { struct sock_exterr_skb *serr; struct iphdr *iph; struct sk_buff *skb; 272 if (!sk->protinfo.af_inet.recverr) 273 return; skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC); 276 if (!skb) 277 return; iph = (struct iphdr*)skb_put(skb, sizeof(struct iphdr)); skb->nh.iph = iph; iph->daddr = daddr; serr = SKB_EXT_ERR(skb); serr->ee.ee_errno = err; serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL; serr->ee.ee_type = 0; serr->ee.ee_code = 0; serr->ee.ee_pad = 0; serr->ee.ee_info = info; serr->ee.ee_data = 0; serr->addr_offset = (u8*)&iph->daddr - skb->nh.raw; serr->port = port; skb->h.raw = skb->tail; skb_pull(skb, skb->tail - skb->data); 297 if (sock_queue_err_skb(sk, skb)) kfree_skb(skb); } /* * Handle MSG_ERRQUEUE */ 304 int ip_recv_error(struct sock *sk, struct msghdr *msg, int len) { struct sock_exterr_skb *serr; struct sk_buff *skb, *skb2; struct sockaddr_in *sin; struct { struct sock_extended_err ee; struct sockaddr_in offender; } errhdr; int err; int copied; err = -EAGAIN; skb = skb_dequeue(&sk->error_queue); 318 if (skb == NULL) 319 goto out; copied = skb->len; 322 if (copied > len) { msg->msg_flags |= MSG_TRUNC; copied = len; } err = memcpy_toiovec(msg->msg_iov, skb->data, copied); 327 if (err) 328 goto out_free_skb; sock_recv_timestamp(msg, sk, skb); serr = SKB_EXT_ERR(skb); sin = (struct sockaddr_in *)msg->msg_name; 335 if (sin) { sin->sin_family = AF_INET; sin->sin_addr.s_addr = *(u32*)(skb->nh.raw + serr->addr_offset); sin->sin_port = serr->port; } memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err)); sin = &errhdr.offender; sin->sin_family = AF_UNSPEC; 344 if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) { sin->sin_family = AF_INET; sin->sin_addr.s_addr = skb->nh.iph->saddr; 347 if (sk->protinfo.af_inet.cmsg_flags) ip_cmsg_recv(msg, skb); } put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr); /* Now we could try to dump offended packet options */ msg->msg_flags |= MSG_ERRQUEUE; err = copied; /* Reset and regenerate socket error */ 359 spin_lock_irq(&sk->error_queue.lock); sk->err = 0; 361 if ((skb2 = skb_peek(&sk->error_queue)) != NULL) { sk->err = SKB_EXT_ERR(skb2)->ee.ee_errno; 363 spin_unlock_irq(&sk->error_queue.lock); sk->error_report(sk); 365 } else { 366 spin_unlock_irq(&sk->error_queue.lock); } out_free_skb: kfree_skb(skb); out: 372 return err; } /* * Socket option code for IP. This is the end of the line after any TCP,UDP etc options on * an IP socket. */ 381 int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen) { int val=0,err; 385 if (level != SOL_IP) 386 return -ENOPROTOOPT; if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) | (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) | (1<<IP_RETOPTS) | (1<<IP_TOS) | (1<<IP_TTL) | (1<<IP_HDRINCL) | (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) | (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND))) || optname == IP_MULTICAST_TTL || 395 optname == IP_MULTICAST_LOOP) { 396 if (optlen >= sizeof(int)) { 397 if (get_user(val, (int *) optval)) 398 return -EFAULT; 399 } else if (optlen >= sizeof(char)) { unsigned char ucval; 402 if (get_user(ucval, (unsigned char *) optval)) 403 return -EFAULT; val = (int) ucval; } } /* If optlen==0, it is equivalent to val == 0 */ #ifdef CONFIG_IP_MROUTE if (optname >= MRT_BASE && optname <= (MRT_BASE + 10)) return ip_mroute_setsockopt(sk,optname,optval,optlen); #endif err = 0; 416 lock_sock(sk); 418 switch (optname) { 419 case IP_OPTIONS: { struct ip_options * opt = NULL; 422 if (optlen > 40 || optlen < 0) 423 goto e_inval; err = ip_options_get(&opt, optval, optlen, 1); 425 if (err) 426 break; 427 if (sk->type == SOCK_STREAM) { struct tcp_opt *tp = &sk->tp_pinfo.af_tcp; #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) if (sk->family == PF_INET || (!((1<<sk->state)&(TCPF_LISTEN|TCPF_CLOSE)) && sk->daddr != LOOPBACK4_IPV6)) { #endif 434 if (opt) tp->ext_header_len = opt->optlen; tcp_sync_mss(sk, tp->pmtu_cookie); #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) } #endif } opt = xchg(&sk->protinfo.af_inet.opt, opt); 442 if (opt) kfree(opt); 444 break; } 446 case IP_PKTINFO: 447 if (val) sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_PKTINFO; 449 else sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_PKTINFO; 451 break; 452 case IP_RECVTTL: 453 if (val) sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_TTL; 455 else sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_TTL; 457 break; 458 case IP_RECVTOS: 459 if (val) sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_TOS; 461 else sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_TOS; 463 break; 464 case IP_RECVOPTS: 465 if (val) sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_RECVOPTS; 467 else sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_RECVOPTS; 469 break; 470 case IP_RETOPTS: 471 if (val) sk->protinfo.af_inet.cmsg_flags |= IP_CMSG_RETOPTS; 473 else sk->protinfo.af_inet.cmsg_flags &= ~IP_CMSG_RETOPTS; 475 break; 476 case IP_TOS: /* This sets both TOS and Precedence */ /* Reject setting of unused bits */ #ifndef CONFIG_INET_ECN 479 if (val & ~(IPTOS_TOS_MASK|IPTOS_PREC_MASK)) 480 goto e_inval; #else if (sk->type == SOCK_STREAM) { val &= ~3; val |= sk->protinfo.af_inet.tos & 3; } #endif if (IPTOS_PREC(val) >= IPTOS_PREC_CRITIC_ECP && 488 !capable(CAP_NET_ADMIN)) { err = -EPERM; 490 break; } 492 if (sk->protinfo.af_inet.tos != val) { sk->protinfo.af_inet.tos=val; sk->priority = rt_tos2priority(val); sk_dst_reset(sk); } 497 break; 498 case IP_TTL: 499 if (optlen<1) 500 goto e_inval; 501 if(val==-1) val = sysctl_ip_default_ttl; 503 if(val<1||val>255) 504 goto e_inval; sk->protinfo.af_inet.ttl=val; 506 break; 507 case IP_HDRINCL: 508 if(sk->type!=SOCK_RAW) { err = -ENOPROTOOPT; 510 break; } sk->protinfo.af_inet.hdrincl=val?1:0; 513 break; 514 case IP_MTU_DISCOVER: 515 if (val<0 || val>2) 516 goto e_inval; sk->protinfo.af_inet.pmtudisc = val; 518 break; 519 case IP_RECVERR: sk->protinfo.af_inet.recverr = !!val; 521 if (!val) skb_queue_purge(&sk->error_queue); 523 break; 524 case IP_MULTICAST_TTL: 525 if (sk->type == SOCK_STREAM) 526 goto e_inval; 527 if (optlen<1) 528 goto e_inval; 529 if (val==-1) val = 1; 531 if (val < 0 || val > 255) 532 goto e_inval; sk->protinfo.af_inet.mc_ttl=val; 534 break; 535 case IP_MULTICAST_LOOP: 536 if (optlen<1) 537 goto e_inval; sk->protinfo.af_inet.mc_loop = val ? 1 : 0; 539 break; 540 case IP_MULTICAST_IF: { struct ip_mreqn mreq; struct net_device *dev = NULL; 545 if (sk->type == SOCK_STREAM) 546 goto e_inval; /* * Check the arguments are allowable */ err = -EFAULT; 552 if (optlen >= sizeof(struct ip_mreqn)) { 553 if (copy_from_user(&mreq,optval,sizeof(mreq))) 554 break; 555 } else { memset(&mreq, 0, sizeof(mreq)); if (optlen >= sizeof(struct in_addr) && 558 copy_from_user(&mreq.imr_address,optval,sizeof(struct in_addr))) 559 break; } 562 if (!mreq.imr_ifindex) { 563 if (mreq.imr_address.s_addr == INADDR_ANY) { sk->protinfo.af_inet.mc_index = 0; sk->protinfo.af_inet.mc_addr = 0; err = 0; 567 break; } dev = ip_dev_find(mreq.imr_address.s_addr); 570 if (dev) { mreq.imr_ifindex = dev->ifindex; dev_put(dev); } 574 } else dev = __dev_get_by_index(mreq.imr_ifindex); err = -EADDRNOTAVAIL; 579 if (!dev) 580 break; err = -EINVAL; 583 if (sk->bound_dev_if && mreq.imr_ifindex != sk->bound_dev_if) 584 break; sk->protinfo.af_inet.mc_index = mreq.imr_ifindex; sk->protinfo.af_inet.mc_addr = mreq.imr_address.s_addr; err = 0; 589 break; } 592 case IP_ADD_MEMBERSHIP: 593 case IP_DROP_MEMBERSHIP: { struct ip_mreqn mreq; 597 if (optlen < sizeof(struct ip_mreq)) 598 goto e_inval; err = -EFAULT; 600 if (optlen >= sizeof(struct ip_mreqn)) { 601 if(copy_from_user(&mreq,optval,sizeof(mreq))) 602 break; 603 } else { memset(&mreq, 0, sizeof(mreq)); 605 if (copy_from_user(&mreq,optval,sizeof(struct ip_mreq))) 606 break; } 609 if (optname == IP_ADD_MEMBERSHIP) err = ip_mc_join_group(sk,&mreq); 611 else err = ip_mc_leave_group(sk,&mreq); 613 break; } 615 case IP_ROUTER_ALERT: err = ip_ra_control(sk, val ? 1 : 0, NULL); 617 break; 619 case IP_FREEBIND: 620 if (optlen<1) 621 goto e_inval; sk->protinfo.af_inet.freebind = !!val; 623 break; 625 default: #ifdef CONFIG_NETFILTER err = nf_setsockopt(sk, PF_INET, optname, optval, optlen); #else err = -ENOPROTOOPT; #endif 632 break; } 634 release_sock(sk); 635 return err; e_inval: 638 release_sock(sk); 639 return -EINVAL; } /* * Get the options. Note for future reference. The GET of IP options gets the * _received_ ones. The set sets the _sent_ ones. */ 647 int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen) { int val; int len; 652 if(level!=SOL_IP) 653 return -EOPNOTSUPP; #ifdef CONFIG_IP_MROUTE if(optname>=MRT_BASE && optname <=MRT_BASE+10) { return ip_mroute_getsockopt(sk,optname,optval,optlen); } #endif 662 if(get_user(len,optlen)) 663 return -EFAULT; 665 lock_sock(sk); 667 switch(optname) { 668 case IP_OPTIONS: { unsigned char optbuf[sizeof(struct ip_options)+40]; struct ip_options * opt = (struct ip_options*)optbuf; opt->optlen = 0; 673 if (sk->protinfo.af_inet.opt) memcpy(optbuf, sk->protinfo.af_inet.opt, sizeof(struct ip_options)+ sk->protinfo.af_inet.opt->optlen); 677 release_sock(sk); 679 if (opt->optlen == 0) 680 return put_user(0, optlen); ip_options_undo(opt); len=min(len, opt->optlen); 685 if(put_user(len, optlen)) 686 return -EFAULT; 687 if(copy_to_user(optval, opt->__data, len)) 688 return -EFAULT; 689 return 0; } 691 case IP_PKTINFO: val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_PKTINFO) != 0; 693 break; 694 case IP_RECVTTL: val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_TTL) != 0; 696 break; 697 case IP_RECVTOS: val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_TOS) != 0; 699 break; 700 case IP_RECVOPTS: val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_RECVOPTS) != 0; 702 break; 703 case IP_RETOPTS: val = (sk->protinfo.af_inet.cmsg_flags & IP_CMSG_RETOPTS) != 0; 705 break; 706 case IP_TOS: val=sk->protinfo.af_inet.tos; 708 break; 709 case IP_TTL: val=sk->protinfo.af_inet.ttl; 711 break; 712 case IP_HDRINCL: val=sk->protinfo.af_inet.hdrincl; 714 break; 715 case IP_MTU_DISCOVER: val=sk->protinfo.af_inet.pmtudisc; 717 break; 718 case IP_MTU: { struct dst_entry *dst; val = 0; dst = sk_dst_get(sk); 723 if (dst) { val = dst->pmtu; dst_release(dst); } 727 if (!val) { 728 release_sock(sk); 729 return -ENOTCONN; } 731 break; } 733 case IP_RECVERR: val=sk->protinfo.af_inet.recverr; 735 break; 736 case IP_MULTICAST_TTL: val=sk->protinfo.af_inet.mc_ttl; 738 break; 739 case IP_MULTICAST_LOOP: val=sk->protinfo.af_inet.mc_loop; 741 break; 742 case IP_MULTICAST_IF: { struct in_addr addr; len = min(len,sizeof(struct in_addr)); addr.s_addr = sk->protinfo.af_inet.mc_addr; 747 release_sock(sk); 749 if(put_user(len, optlen)) 750 return -EFAULT; 751 if(copy_to_user((void *)optval, &addr, len)) 752 return -EFAULT; 753 return 0; } 755 case IP_PKTOPTIONS: { struct msghdr msg; 759 release_sock(sk); 761 if (sk->type != SOCK_STREAM) 762 return -ENOPROTOOPT; msg.msg_control = optval; msg.msg_controllen = len; msg.msg_flags = 0; 768 if (sk->protinfo.af_inet.cmsg_flags&IP_CMSG_PKTINFO) { struct in_pktinfo info; info.ipi_addr.s_addr = sk->rcv_saddr; info.ipi_spec_dst.s_addr = sk->rcv_saddr; info.ipi_ifindex = sk->protinfo.af_inet.mc_index; put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info); } 776 if (sk->protinfo.af_inet.cmsg_flags&IP_CMSG_TTL) { int hlim = sk->protinfo.af_inet.mc_ttl; put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim); } len -= msg.msg_controllen; 781 return put_user(len, optlen); } 783 case IP_FREEBIND: val = sk->protinfo.af_inet.freebind; 785 break; 786 default: #ifdef CONFIG_NETFILTER val = nf_getsockopt(sk, PF_INET, optname, optval, &len); release_sock(sk); if (val >= 0) val = put_user(len, optlen); return val; #else 795 release_sock(sk); 796 return -ENOPROTOOPT; #endif } 799 release_sock(sk); 801 if (len < sizeof(int) && len > 0 && val>=0 && val<255) { unsigned char ucval = (unsigned char)val; len = 1; 804 if(put_user(len, optlen)) 805 return -EFAULT; 806 if(copy_to_user(optval,&ucval,1)) 807 return -EFAULT; 808 } else { len=min(sizeof(int),len); 810 if(put_user(len, optlen)) 811 return -EFAULT; 812 if(copy_to_user(optval,&val,len)) 813 return -EFAULT; } 815 return 0; }