/*
* 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;
}