自学教程：C++ GROUP_FILTER_SIZE函数代码示例

intgetsourcefilter (int s, uint32_t interface, const struct sockaddr *group,		 socklen_t grouplen, uint32_t *fmode, uint32_t *numsrc,		 struct sockaddr_storage *slist){  /* We have to create an struct ip_msfilter object which we can pass     to the kernel.  */  socklen_t needed = GROUP_FILTER_SIZE (*numsrc);  int use_alloca = __libc_use_alloca (needed);  struct group_filter *gf;  if (use_alloca)    gf = (struct group_filter *) alloca (needed);  else    {      gf = (struct group_filter *) malloc (needed);      if (gf == NULL)	return -1;    }  gf->gf_interface = interface;  memcpy (&gf->gf_group, group, grouplen);  gf->gf_numsrc = *numsrc;  /* We need to provide the appropriate socket level value.  */  int result;  int sol = __get_sol (group->sa_family, grouplen);  if (sol == -1)    {      __set_errno (EINVAL);      result = -1;    }  else    {      result = __getsockopt (s, sol, MCAST_MSFILTER, gf, &needed);      /* If successful, copy the results to the places the caller wants	 them in.  */      if (result == 0)	{	  *fmode = gf->gf_fmode;	  memcpy (slist, gf->gf_slist,		  MIN (*numsrc, gf->gf_numsrc)		  * sizeof (struct sockaddr_storage));	  *numsrc = gf->gf_numsrc;	}    }  if (! use_alloca)    {      int save_errno = errno;      free (gf);      __set_errno (save_errno);    }  return result;}

/* * Function: create_mcast_socket() * * Description: *  This function creates a socket to receive multicast datagrams * * Argument: *  info_p: pointer to data of multicast receiver information * * Return value: *  file descriptor referencing the socket */int create_mcast_socket(struct mcast_rcv_info *info_p){	int sd;			/* socket file descriptor */	int level;		/* protocol levels */	int on;			/* flag for setsockopt */	switch (info_p->mainfo->ai_family) {	case PF_INET:		level = IPPROTO_IP;		break;	case PF_INET6:		level = IPPROTO_IPV6;		break;	default:		level = 0;		fprintf(stderr, "Unknown protocol level %d/n", level);		exit(EXIT_FAILURE);		break;	}	/* Create a socket */	sd = socket(info_p->mainfo->ai_family, info_p->mainfo->ai_socktype,		    info_p->mainfo->ai_protocol);	if (sd < 0)		fatal_error("socket()");	/* Bind to the multicast address */	if (bind(sd, info_p->mainfo->ai_addr, info_p->mainfo->ai_addrlen) < 0)		fatal_error("bind()");	/* Enable to reuse the socket */	on = 1;	if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int)))		fatal_error("setsockopt(): failed to set reuse the socket");	/* Join the multicast group */	if (setsockopt	    (sd, level, MCAST_JOIN_GROUP, info_p->greq,	     sizeof(struct group_req)))		fatal_error("setsockopt(): failed to join the multicast group");	/* Apply the source filter */	if (info_p->gsf) {		if (setsockopt		    (sd, level, MCAST_MSFILTER, info_p->gsf,		     GROUP_FILTER_SIZE(info_p->gsf->gf_numsrc)))			fatal_error			    ("setsockopt(): failed to apply the source filter");	}	return sd;}

int ipv6_getsockopt(struct sock *sk, int level, int optname,		    char __user *optval, int __user *optlen){	struct ipv6_pinfo *np = inet6_sk(sk);	int len;	int val;	if (level == SOL_IP && sk->sk_type != SOCK_RAW)		return udp_prot.getsockopt(sk, level, optname, optval, optlen);	if(level!=SOL_IPV6)		return -ENOPROTOOPT;	if (get_user(len, optlen))		return -EFAULT;	switch (optname) {	case IPV6_ADDRFORM:		if (sk->sk_protocol != IPPROTO_UDP &&		    sk->sk_protocol != IPPROTO_TCP)			return -EINVAL;		if (sk->sk_state != TCP_ESTABLISHED)			return -ENOTCONN;		val = sk->sk_family;		break;	case MCAST_MSFILTER:	{		struct group_filter gsf;		int err;		if (len < GROUP_FILTER_SIZE(0))			return -EINVAL;		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))			return -EFAULT;		lock_sock(sk);		err = ip6_mc_msfget(sk, &gsf,			(struct group_filter __user *)optval, optlen);		release_sock(sk);		return err;	}	case IPV6_PKTOPTIONS:	{		struct msghdr msg;		struct sk_buff *skb;		if (sk->sk_type != SOCK_STREAM)			return -ENOPROTOOPT;		msg.msg_control = optval;		msg.msg_controllen = len;		msg.msg_flags = 0;		lock_sock(sk);		skb = np->pktoptions;		if (skb)			atomic_inc(&skb->users);		release_sock(sk);		if (skb) {			int err = datagram_recv_ctl(sk, &msg, skb);			kfree_skb(skb);			if (err)				return err;		} else {			if (np->rxopt.bits.rxinfo) {				struct in6_pktinfo src_info;				src_info.ipi6_ifindex = np->mcast_oif;				ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);				put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);			}			if (np->rxopt.bits.rxhlim) {				int hlim = np->mcast_hops;				put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);			}		}		len -= msg.msg_controllen;		return put_user(len, optlen);	}	case IPV6_MTU:	{		struct dst_entry *dst;		val = 0;			lock_sock(sk);		dst = sk_dst_get(sk);		if (dst) {			val = dst_mtu(dst);			dst_release(dst);		}		release_sock(sk);		if (!val)			return -ENOTCONN;		break;	}	case IPV6_V6ONLY:		val = np->ipv6only;		break;	case IPV6_PKTINFO:		val = np->rxopt.bits.rxinfo;		break;//.........这里部分代码省略.........

//.........这里部分代码省略.........		    greqs.gsr_source.ss_family != AF_INET6) {			retv = -EADDRNOTAVAIL;			break;		}		if (optname == MCAST_BLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 1;		} else if (optname == MCAST_UNBLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 0;		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {			struct sockaddr_in6 *psin6;			psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;			retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,				&psin6->sin6_addr);			if (retv)				break;			omode = MCAST_INCLUDE;			add = 1;		} else /*IP_DROP_SOURCE_MEMBERSHIP */ {			omode = MCAST_INCLUDE;			add = 0;		}		retv = ip6_mc_source(add, omode, sk, &greqs);		break;	}	case MCAST_MSFILTER:	{		extern int sysctl_optmem_max;		extern int sysctl_mld_max_msf;		struct group_filter *gsf;		if (optlen < GROUP_FILTER_SIZE(0))			goto e_inval;		if (optlen > sysctl_optmem_max) {			retv = -ENOBUFS;			break;		}		gsf = (struct group_filter *)kmalloc(optlen,GFP_KERNEL);		if (gsf == 0) {			retv = -ENOBUFS;			break;		}		retv = -EFAULT;		if (copy_from_user(gsf, optval, optlen)) {			kfree(gsf);			break;		}		/* numsrc >= (4G-140)/128 overflow in 32 bits */		if (gsf->gf_numsrc >= 0x1ffffffU ||		    gsf->gf_numsrc > sysctl_mld_max_msf) {			kfree(gsf);			retv = -ENOBUFS;			break;		}		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {			kfree(gsf);			retv = -EINVAL;			break;		}		retv = ip6_mc_msfilter(sk, gsf);		kfree(gsf);		break;	}

static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,		    char __user *optval, int __user *optlen, unsigned int flags){	struct ipv6_pinfo *np = inet6_sk(sk);	int len;	int val;	if (ip6_mroute_opt(optname))		return ip6_mroute_getsockopt(sk, optname, optval, optlen);	if (get_user(len, optlen))		return -EFAULT;	switch (optname) {	case IPV6_ADDRFORM:		if (sk->sk_protocol != IPPROTO_UDP &&		    sk->sk_protocol != IPPROTO_UDPLITE &&		    sk->sk_protocol != IPPROTO_TCP)			return -ENOPROTOOPT;		if (sk->sk_state != TCP_ESTABLISHED)			return -ENOTCONN;		val = sk->sk_family;		break;	case MCAST_MSFILTER:	{		struct group_filter gsf;		int err;		if (len < GROUP_FILTER_SIZE(0))			return -EINVAL;		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))			return -EFAULT;		if (gsf.gf_group.ss_family != AF_INET6)			return -EADDRNOTAVAIL;		lock_sock(sk);		err = ip6_mc_msfget(sk, &gsf,			(struct group_filter __user *)optval, optlen);		release_sock(sk);		return err;	}	case IPV6_2292PKTOPTIONS:	{		struct msghdr msg;		struct sk_buff *skb;		if (sk->sk_type != SOCK_STREAM)			return -ENOPROTOOPT;		msg.msg_control = (void __force_kernel *)optval;		msg.msg_controllen = len;		msg.msg_flags = flags;		lock_sock(sk);		skb = np->pktoptions;		if (skb)			atomic_inc(&skb->users);		release_sock(sk);		if (skb) {			int err = ip6_datagram_recv_ctl(sk, &msg, skb);			kfree_skb(skb);			if (err)				return err;		} else {			if (np->rxopt.bits.rxinfo) {				struct in6_pktinfo src_info;				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :					np->sticky_pktinfo.ipi6_ifindex;				src_info.ipi6_addr = np->mcast_oif ? np->daddr : np->sticky_pktinfo.ipi6_addr;				put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);			}			if (np->rxopt.bits.rxhlim) {				int hlim = np->mcast_hops;				put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);			}			if (np->rxopt.bits.rxtclass) {				int tclass = np->rcv_tclass;				put_cmsg(&msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);			}			if (np->rxopt.bits.rxoinfo) {				struct in6_pktinfo src_info;				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :					np->sticky_pktinfo.ipi6_ifindex;				src_info.ipi6_addr = np->mcast_oif ? np->daddr : np->sticky_pktinfo.ipi6_addr;				put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);			}			if (np->rxopt.bits.rxohlim) {				int hlim = np->mcast_hops;				put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);			}		}		len -= msg.msg_controllen;		return put_user(len, optlen);	}	case IPV6_MTU:	{		struct dst_entry *dst;		val = 0;		rcu_read_lock();//.........这里部分代码省略.........

//.........这里部分代码省略.........		if (greqs.gsr_group.ss_family != AF_INET6 ||		    greqs.gsr_source.ss_family != AF_INET6) {			retv = -EADDRNOTAVAIL;			break;		}		if (optname == MCAST_BLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 1;		} else if (optname == MCAST_UNBLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 0;		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {			struct sockaddr_in6 *psin6;			psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;			retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,				&psin6->sin6_addr);			/* prior join w/ different source is ok */			if (retv && retv != -EADDRINUSE)				break;			omode = MCAST_INCLUDE;			add = 1;		} else /* MCAST_LEAVE_SOURCE_GROUP */ {			omode = MCAST_INCLUDE;			add = 0;		}		retv = ip6_mc_source(add, omode, sk, &greqs);		break;	}	case MCAST_MSFILTER:	{		struct group_filter *gsf;		if (optlen < GROUP_FILTER_SIZE(0))			goto e_inval;		if (optlen > sysctl_optmem_max) {			retv = -ENOBUFS;			break;		}		gsf = kmalloc(optlen,GFP_KERNEL);		if (!gsf) {			retv = -ENOBUFS;			break;		}		retv = -EFAULT;		if (copy_from_user(gsf, optval, optlen)) {			kfree(gsf);			break;		}		/* numsrc >= (4G-140)/128 overflow in 32 bits */		if (gsf->gf_numsrc >= 0x1ffffffU ||		    gsf->gf_numsrc > sysctl_mld_max_msf) {			kfree(gsf);			retv = -ENOBUFS;			break;		}		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {			kfree(gsf);			retv = -EINVAL;			break;		}		retv = ip6_mc_msfilter(sk, gsf);		kfree(gsf);		break;	}

int compat_mc_getsockopt(struct sock *sock, int level, int optname,	char __user *optval, int __user *optlen,	int (*getsockopt)(struct sock *, int, int, char __user *, int __user *)){	struct compat_group_filter __user *gf32 = (void *)optval;	struct group_filter __user *kgf;	int __user	*koptlen;	u32 interface, fmode, numsrc;	int klen, ulen, err;	if (optname != MCAST_MSFILTER)		return getsockopt(sock, level, optname, optval, optlen);	koptlen = compat_alloc_user_space(sizeof(*koptlen));	if (!access_ok(VERIFY_READ, optlen, sizeof(*optlen)) ||	    __get_user(ulen, optlen))		return -EFAULT;	/* adjust len for pad */	klen = ulen + sizeof(*kgf) - sizeof(*gf32);	if (klen < GROUP_FILTER_SIZE(0))		return -EINVAL;	if (!access_ok(VERIFY_WRITE, koptlen, sizeof(*koptlen)) ||	    __put_user(klen, koptlen))		return -EFAULT;	/* have to allow space for previous compat_alloc_user_space, too */	kgf = compat_alloc_user_space(klen+sizeof(*optlen));	if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||	    __get_user(interface, &gf32->gf_interface) ||	    __get_user(fmode, &gf32->gf_fmode) ||	    __get_user(numsrc, &gf32->gf_numsrc) ||	    __put_user(interface, &kgf->gf_interface) ||	    __put_user(fmode, &kgf->gf_fmode) ||	    __put_user(numsrc, &kgf->gf_numsrc) ||	    copy_in_user(&kgf->gf_group, &gf32->gf_group, sizeof(kgf->gf_group)))		return -EFAULT;	err = getsockopt(sock, level, optname, (char __user *)kgf, koptlen);	if (err)		return err;	if (!access_ok(VERIFY_READ, koptlen, sizeof(*koptlen)) ||	    __get_user(klen, koptlen))		return -EFAULT;	ulen = klen - (sizeof(*kgf)-sizeof(*gf32));	if (!access_ok(VERIFY_WRITE, optlen, sizeof(*optlen)) ||	    __put_user(ulen, optlen))		return -EFAULT;	if (!access_ok(VERIFY_READ, kgf, klen) ||	    !access_ok(VERIFY_WRITE, gf32, ulen) ||	    __get_user(interface, &kgf->gf_interface) ||	    __get_user(fmode, &kgf->gf_fmode) ||	    __get_user(numsrc, &kgf->gf_numsrc) ||	    __put_user(interface, &gf32->gf_interface) ||	    __put_user(fmode, &gf32->gf_fmode) ||	    __put_user(numsrc, &gf32->gf_numsrc))		return -EFAULT;	if (numsrc) {		int copylen;		klen -= GROUP_FILTER_SIZE(0);		copylen = numsrc * sizeof(gf32->gf_slist[0]);		if (copylen > klen)			copylen = klen;		if (copy_in_user(gf32->gf_slist, kgf->gf_slist, copylen))			return -EFAULT;	}	return err;}

int compat_mc_setsockopt(struct sock *sock, int level, int optname,	char __user *optval, unsigned int optlen,	int (*setsockopt)(struct sock *, int, int, char __user *, unsigned int)){	char __user	*koptval = optval;	int		koptlen = optlen;	switch (optname) {	case MCAST_JOIN_GROUP:	case MCAST_LEAVE_GROUP:	{		struct compat_group_req __user *gr32 = (void *)optval;		struct group_req __user *kgr =			compat_alloc_user_space(sizeof(struct group_req));		u32 interface;		if (!access_ok(VERIFY_READ, gr32, sizeof(*gr32)) ||		    !access_ok(VERIFY_WRITE, kgr, sizeof(struct group_req)) ||		    __get_user(interface, &gr32->gr_interface) ||		    __put_user(interface, &kgr->gr_interface) ||		    copy_in_user(&kgr->gr_group, &gr32->gr_group,				sizeof(kgr->gr_group)))			return -EFAULT;		koptval = (char __user *)kgr;		koptlen = sizeof(struct group_req);		break;	}	case MCAST_JOIN_SOURCE_GROUP:	case MCAST_LEAVE_SOURCE_GROUP:	case MCAST_BLOCK_SOURCE:	case MCAST_UNBLOCK_SOURCE:	{		struct compat_group_source_req __user *gsr32 = (void *)optval;		struct group_source_req __user *kgsr = compat_alloc_user_space(			sizeof(struct group_source_req));		u32 interface;		if (!access_ok(VERIFY_READ, gsr32, sizeof(*gsr32)) ||		    !access_ok(VERIFY_WRITE, kgsr,			sizeof(struct group_source_req)) ||		    __get_user(interface, &gsr32->gsr_interface) ||		    __put_user(interface, &kgsr->gsr_interface) ||		    copy_in_user(&kgsr->gsr_group, &gsr32->gsr_group,				sizeof(kgsr->gsr_group)) ||		    copy_in_user(&kgsr->gsr_source, &gsr32->gsr_source,				sizeof(kgsr->gsr_source)))			return -EFAULT;		koptval = (char __user *)kgsr;		koptlen = sizeof(struct group_source_req);		break;	}	case MCAST_MSFILTER:	{		struct compat_group_filter __user *gf32 = (void *)optval;		struct group_filter __user *kgf;		u32 interface, fmode, numsrc;		if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||		    __get_user(interface, &gf32->gf_interface) ||		    __get_user(fmode, &gf32->gf_fmode) ||		    __get_user(numsrc, &gf32->gf_numsrc))			return -EFAULT;		koptlen = optlen + sizeof(struct group_filter) -				sizeof(struct compat_group_filter);		if (koptlen < GROUP_FILTER_SIZE(numsrc))			return -EINVAL;		kgf = compat_alloc_user_space(koptlen);		if (!access_ok(VERIFY_WRITE, kgf, koptlen) ||		    __put_user(interface, &kgf->gf_interface) ||		    __put_user(fmode, &kgf->gf_fmode) ||		    __put_user(numsrc, &kgf->gf_numsrc) ||		    copy_in_user(&kgf->gf_group, &gf32->gf_group,				sizeof(kgf->gf_group)) ||		    (numsrc && copy_in_user(kgf->gf_slist, gf32->gf_slist,				numsrc * sizeof(kgf->gf_slist[0]))))			return -EFAULT;		koptval = (char __user *)kgf;		break;	}	default:		break;	}	return setsockopt(sock, level, optname, koptval, koptlen);}

//.........这里部分代码省略.........	case IP_RETOPTS:	case IP_TOS:	case IP_TTL:	case IP_HDRINCL:	case IP_MTU_DISCOVER:	case IP_RECVERR:	case IP_ROUTER_ALERT:	case IP_FREEBIND:	case IP_PASSSEC:	case IP_TRANSPARENT:	case IP_MINTTL:	case IP_NODEFRAG:	case IP_UNICAST_IF:	case IP_MULTICAST_TTL:	case IP_MULTICAST_ALL:	case IP_MULTICAST_LOOP:	case IP_RECVORIGDSTADDR:		if (rand_bool())			so->optlen = sizeof(int);		else			so->optlen = sizeof(char);		break;	case IP_OPTIONS:		so->optlen = rand() % 40;		break;	case IP_MULTICAST_IF:	case IP_ADD_MEMBERSHIP:	case IP_DROP_MEMBERSHIP:		mcaddr = 0xe0000000 | rand() % 0xff;		mr = zmalloc(sizeof(struct ip_mreqn));		mr->imr_multiaddr.s_addr = mcaddr;		mr->imr_address.s_addr = random_ipv4_address();		mr->imr_ifindex = rand32();		so->optval = (unsigned long) mr;		so->optlen = sizeof(struct ip_mreqn);		break;	case MRT_ADD_VIF:	case MRT_DEL_VIF:		so->optlen = sizeof(struct vifctl);		break;	case MRT_ADD_MFC:	case MRT_ADD_MFC_PROXY:	case MRT_DEL_MFC:	case MRT_DEL_MFC_PROXY:		so->optlen = sizeof(struct mfcctl);		break;	case MRT_TABLE:		so->optlen = sizeof(__u32);		break;	case IP_MSFILTER:		//FIXME: Read size from sysctl /proc/sys/net/core/optmem_max		so->optlen = rand() % sizeof(unsigned long)*(2*UIO_MAXIOV+512);		so->optlen |= IP_MSFILTER_SIZE(0);		break;	case IP_BLOCK_SOURCE:	case IP_UNBLOCK_SOURCE:	case IP_ADD_SOURCE_MEMBERSHIP:	case IP_DROP_SOURCE_MEMBERSHIP:		mcaddr = 0xe0000000 | rand() % 0xff;		ms = zmalloc(sizeof(struct ip_mreq_source));		ms->imr_multiaddr.s_addr = mcaddr;		ms->imr_interface.s_addr = random_ipv4_address();		ms->imr_sourceaddr.s_addr = random_ipv4_address();		so->optval = (unsigned long) ms;		so->optlen = sizeof(struct ip_mreq_source);		break;	case MCAST_JOIN_GROUP:	case MCAST_LEAVE_GROUP:		so->optlen = sizeof(struct group_req);		break;	case MCAST_JOIN_SOURCE_GROUP:	case MCAST_LEAVE_SOURCE_GROUP:	case MCAST_BLOCK_SOURCE:	case MCAST_UNBLOCK_SOURCE:		so->optlen = sizeof(struct group_source_req);		break;	case MCAST_MSFILTER:		//FIXME: Read size from sysctl /proc/sys/net/core/optmem_max		so->optlen = rand() % sizeof(unsigned long)*(2*UIO_MAXIOV+512);		so->optlen |= GROUP_FILTER_SIZE(0);		break;	default:		break;	}}

//.........这里部分代码省略.........			omode = MCAST_EXCLUDE;			add = 1;		} else if (optname == MCAST_UNBLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 0;		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {			struct ip_mreqn mreq;			psin = (struct sockaddr_in *)&greqs.gsr_group;			mreq.imr_multiaddr = psin->sin_addr;			mreq.imr_address.s_addr = 0;			mreq.imr_ifindex = greqs.gsr_interface;			err = ip_mc_join_group(sk, &mreq);			if (err && err != -EADDRINUSE)				break;			greqs.gsr_interface = mreq.imr_ifindex;			omode = MCAST_INCLUDE;			add = 1;		} else /* MCAST_LEAVE_SOURCE_GROUP */ {			omode = MCAST_INCLUDE;			add = 0;		}		err = ip_mc_source(add, omode, sk, &mreqs,				   greqs.gsr_interface);		break;	}	case MCAST_MSFILTER:	{		struct sockaddr_in *psin;		struct ip_msfilter *msf = NULL;		struct group_filter *gsf = NULL;		int msize, i, ifindex;		if (optlen < GROUP_FILTER_SIZE(0))			goto e_inval;		if (optlen > sysctl_optmem_max) {			err = -ENOBUFS;			break;		}		gsf = kmalloc(optlen, GFP_KERNEL);		if (!gsf) {			err = -ENOBUFS;			break;		}		err = -EFAULT;		if (copy_from_user(gsf, optval, optlen))			goto mc_msf_out;		/* numsrc >= (4G-140)/128 overflow in 32 bits */		if (gsf->gf_numsrc >= 0x1ffffff ||		    gsf->gf_numsrc > net->ipv4.sysctl_igmp_max_msf) {			err = -ENOBUFS;			goto mc_msf_out;		}		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {			err = -EINVAL;			goto mc_msf_out;		}		msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);		msf = kmalloc(msize, GFP_KERNEL);		if (!msf) {			err = -ENOBUFS;			goto mc_msf_out;		}		ifindex = gsf->gf_interface;		psin = (struct sockaddr_in *)&gsf->gf_group;

//.........这里部分代码省略.........	case IP_MULTICAST_IF:	{		struct in_addr addr;		len = min_t(unsigned int, len, sizeof(struct in_addr));		addr.s_addr = inet->mc_addr;		release_sock(sk);		if (put_user(len, optlen))			return -EFAULT;		if (copy_to_user(optval, &addr, len))			return -EFAULT;		return 0;	}	case IP_MSFILTER:	{		struct ip_msfilter msf;		if (len < IP_MSFILTER_SIZE(0)) {			err = -EINVAL;			goto out;		}		if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {			err = -EFAULT;			goto out;		}		err = ip_mc_msfget(sk, &msf,				   (struct ip_msfilter __user *)optval, optlen);		goto out;	}	case MCAST_MSFILTER:	{		struct group_filter gsf;		if (len < GROUP_FILTER_SIZE(0)) {			err = -EINVAL;			goto out;		}		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {			err = -EFAULT;			goto out;		}		err = ip_mc_gsfget(sk, &gsf,				   (struct group_filter __user *)optval,				   optlen);		goto out;	}	case IP_MULTICAST_ALL:		val = inet->mc_all;		break;	case IP_PKTOPTIONS:	{		struct msghdr msg;		release_sock(sk);		if (sk->sk_type != SOCK_STREAM)			return -ENOPROTOOPT;		msg.msg_control = (__force void *) optval;		msg.msg_controllen = len;		msg.msg_flags = flags;		if (inet->cmsg_flags & IP_CMSG_PKTINFO) {			struct in_pktinfo info;			info.ipi_addr.s_addr = inet->inet_rcv_saddr;

//.........这里部分代码省略.........			add = 1;		} else if (optname == MCAST_UNBLOCK_SOURCE) {			omode = MCAST_EXCLUDE;			add = 0;		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {			struct ip_mreqn mreq;			psin = (struct sockaddr_in *)&greqs.gsr_group;			mreq.imr_multiaddr = psin->sin_addr;			mreq.imr_address.s_addr = 0;			mreq.imr_ifindex = greqs.gsr_interface;			err = ip_mc_join_group(sk, &mreq);			if (err && err != -EADDRINUSE)				break;			greqs.gsr_interface = mreq.imr_ifindex;			omode = MCAST_INCLUDE;			add = 1;		} else /* MCAST_LEAVE_SOURCE_GROUP */ {			omode = MCAST_INCLUDE;			add = 0;		}		err = ax8netfilter_ip_mc_source(add, omode, sk, &mreqs,				   greqs.gsr_interface);		break;	}	case MCAST_MSFILTER:	{		extern int * ax8netfilter_sysctl_igmp_max_msf;		struct sockaddr_in *psin;		struct ip_msfilter *msf = NULL;		struct group_filter *gsf = NULL;		int msize, i, ifindex;		if (optlen < GROUP_FILTER_SIZE(0))			goto e_inval;		if (optlen > sysctl_optmem_max) {			err = -ENOBUFS;			break;		}		gsf = kmalloc(optlen, GFP_KERNEL);		if (!gsf) {			err = -ENOBUFS;			break;		}		err = -EFAULT;		if (copy_from_user(gsf, optval, optlen)) {			goto mc_msf_out;		}		/* numsrc >= (4G-140)/128 overflow in 32 bits */		if (gsf->gf_numsrc >= 0x1ffffff ||		    gsf->gf_numsrc > (*ax8netfilter_sysctl_igmp_max_msf)) {			err = -ENOBUFS;			goto mc_msf_out;		}		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {			err = -EINVAL;			goto mc_msf_out;		}		msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);		msf = kmalloc(msize, GFP_KERNEL);		if (!msf) {			err = -ENOBUFS;			goto mc_msf_out;		}		ifindex = gsf->gf_interface;		psin = (struct sockaddr_in *)&gsf->gf_group;

//.........这里部分代码省略.........		len = min_t(unsigned int, len, sizeof(struct in_addr));		addr.s_addr = inet->mc_addr;		release_sock(sk);		if (put_user(len, optlen))			return -EFAULT;		if (copy_to_user(optval, &addr, len))			return -EFAULT;		return 0;	}	case IP_MSFILTER:	{		struct ip_msfilter msf;		int err;		if (len < IP_MSFILTER_SIZE(0)) {			release_sock(sk);			return -EINVAL;		}		if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {			release_sock(sk);			return -EFAULT;		}		err = ax8netfilter_ip_mc_msfget(sk, &msf,				   (struct ip_msfilter __user *)optval, optlen);		release_sock(sk);		return err;	}	case MCAST_MSFILTER:	{		struct group_filter gsf;		int err;		if (len < GROUP_FILTER_SIZE(0)) {			release_sock(sk);			return -EINVAL;		}		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {			release_sock(sk);			return -EFAULT;		}		err = ax8netfilter_ip_mc_gsfget(sk, &gsf,				   (struct group_filter __user *)optval, optlen);		release_sock(sk);		return err;	}	case IP_PKTOPTIONS:	{		struct msghdr msg;		release_sock(sk);		if (sk->sk_type != SOCK_STREAM)			return -ENOPROTOOPT;		msg.msg_control = optval;		msg.msg_controllen = len;		msg.msg_flags = 0;		if (inet->cmsg_flags & IP_CMSG_PKTINFO) {			struct in_pktinfo info;			info.ipi_addr.s_addr = inet->rcv_saddr;			info.ipi_spec_dst.s_addr = inet->rcv_saddr;			info.ipi_ifindex = inet->mc_index;			put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);