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

int ipv6_sock_mc_join(struct sock *sk, int ifindex, struct in6_addr *addr){	struct net_device *dev = NULL;	struct ipv6_mc_socklist *mc_lst;	struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;	int err;	if (!(ipv6_addr_type(addr) & IPV6_ADDR_MULTICAST))		return -EINVAL;	mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL);	if (mc_lst == NULL)		return -ENOMEM;	mc_lst->next = NULL;	memcpy(&mc_lst->addr, addr, sizeof(struct in6_addr));	mc_lst->ifindex = ifindex;	if (ifindex == 0) {		struct rt6_info *rt;		rt = rt6_lookup(addr, NULL, 0, 0);		if (rt) {			dev = rt->rt6i_dev;			dev_hold(dev);			dst_release(&rt->u.dst);		}	} else		dev = dev_get_by_index(ifindex);	if (dev == NULL) {		sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));		return -ENODEV;	}	/*	 *	now add/increase the group membership on the device	 */	err = ipv6_dev_mc_inc(dev, addr);	if (err) {		sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));		dev_put(dev);		return err;	}	write_lock_bh(&ipv6_sk_mc_lock);	mc_lst->next = np->ipv6_mc_list;	np->ipv6_mc_list = mc_lst;	write_unlock_bh(&ipv6_sk_mc_lock);	dev_put(dev);	return 0;}

/* *	socket leave an anycast group */int ipv6_sock_ac_drop(struct sock *sk, int ifindex, struct in6_addr *addr){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net_device *dev;	struct ipv6_ac_socklist *pac, *prev_pac;	write_lock_bh(&ipv6_sk_ac_lock);	prev_pac = NULL;	for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {		if ((ifindex == 0 || pac->acl_ifindex == ifindex) &&		     ipv6_addr_equal(&pac->acl_addr, addr))			break;		prev_pac = pac;	}	if (!pac) {		write_unlock_bh(&ipv6_sk_ac_lock);		return -ENOENT;	}	if (prev_pac)		prev_pac->acl_next = pac->acl_next;	else		np->ipv6_ac_list = pac->acl_next;	write_unlock_bh(&ipv6_sk_ac_lock);	dev = dev_get_by_index(&init_net, pac->acl_ifindex);	if (dev) {		ipv6_dev_ac_dec(dev, &pac->acl_addr);		dev_put(dev);	}	sock_kfree_s(sk, pac, sizeof(*pac));	return 0;}

static int dccp_v6_send_response(struct sock *sk, struct request_sock *req){	struct inet6_request_sock *ireq6 = inet6_rsk(req);	struct ipv6_pinfo *np = inet6_sk(sk);	struct sk_buff *skb;	struct ipv6_txoptions *opt = NULL;	struct in6_addr *final_p = NULL, final;	struct flowi fl;	int err = -1;	struct dst_entry *dst;	memset(&fl, 0, sizeof(fl));	fl.proto = IPPROTO_DCCP;	ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);	ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr);	fl.fl6_flowlabel = 0;	fl.oif = ireq6->iif;	fl.fl_ip_dport = inet_rsk(req)->rmt_port;	fl.fl_ip_sport = inet_rsk(req)->loc_port;	security_req_classify_flow(req, &fl);	opt = np->opt;	if (opt != NULL && opt->srcrt != NULL) {		const struct rt0_hdr *rt0 = (struct rt0_hdr *)opt->srcrt;		ipv6_addr_copy(&final, &fl.fl6_dst);		ipv6_addr_copy(&fl.fl6_dst, rt0->addr);		final_p = &final;	}	err = ip6_dst_lookup(sk, &dst, &fl);	if (err)		goto done;	if (final_p)		ipv6_addr_copy(&fl.fl6_dst, final_p);	err = xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0);	if (err < 0)		goto done;	skb = dccp_make_response(sk, dst, req);	if (skb != NULL) {		struct dccp_hdr *dh = dccp_hdr(skb);		dh->dccph_checksum = dccp_v6_csum_finish(skb,							 &ireq6->loc_addr,							 &ireq6->rmt_addr);		ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);		err = ip6_xmit(sk, skb, &fl, opt, 0);		err = net_xmit_eval(err);	}done:	if (opt != NULL && opt != np->opt)		sock_kfree_s(sk, opt, opt->tot_len);	dst_release(dst);	return err;}

/* *	socket leave on multicast group */int ipv6_sock_mc_drop(struct sock *sk, int ifindex, struct in6_addr *addr){	struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;	struct ipv6_mc_socklist *mc_lst, **lnk;	write_lock_bh(&ipv6_sk_mc_lock);	for (lnk = &np->ipv6_mc_list; (mc_lst = *lnk) !=NULL ; lnk = &mc_lst->next) {		if (mc_lst->ifindex == ifindex &&		    ipv6_addr_cmp(&mc_lst->addr, addr) == 0) {			struct net_device *dev;			*lnk = mc_lst->next;			write_unlock_bh(&ipv6_sk_mc_lock);			if ((dev = dev_get_by_index(ifindex)) != NULL) {				ipv6_dev_mc_dec(dev, &mc_lst->addr);				dev_put(dev);			}			sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));			return 0;		}	}	write_unlock_bh(&ipv6_sk_mc_lock);	return -ENOENT;}

int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk){	struct sk_filter *fp; 	unsigned int fsize = sizeof(struct sock_filter) * fprog->len;	int err;	/* Make sure new filter is there and in the right amounts. */        if (fprog->filter == NULL || fprog->len > BPF_MAXINSNS)                return (-EINVAL);	fp = (struct sk_filter *)sock_kmalloc(sk, fsize+sizeof(*fp), GFP_KERNEL);	if(fp == NULL)		return (-ENOMEM);	if (copy_from_user(fp->insns, fprog->filter, fsize)) {		sock_kfree_s(sk, fp, fsize+sizeof(*fp)); 		return -EFAULT;	}	atomic_set(&fp->refcnt, 1);	fp->len = fprog->len;	if ((err = sk_chk_filter(fp->insns, fp->len))==0) {		struct sk_filter *old_fp = sk->filter;		sk->filter = fp;		synchronize_bh();		fp = old_fp;	}	if (fp)		sk_filter_release(sk, fp);	return (err);}

/** *	sk_attach_filter - attach a socket filter *	@fprog: the filter program *	@sk: the socket to use * * Attach the user's filter code. We first run some sanity checks on * it to make sure it does not explode on us later. If an error * occurs or there is insufficient memory for the filter a negative * errno code is returned. On success the return is zero. */int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk){	struct sk_filter *fp, *old_fp;	unsigned int fsize = sizeof(struct sock_filter) * fprog->len;	int err;	/* Make sure new filter is there and in the right amounts. */	if (fprog->filter == NULL)		return -EINVAL;	fp = sock_kmalloc(sk, fsize+sizeof(*fp), GFP_KERNEL);	if (!fp)		return -ENOMEM;	if (copy_from_user(fp->insns, fprog->filter, fsize)) {		sock_kfree_s(sk, fp, fsize+sizeof(*fp));		return -EFAULT;	}	atomic_set(&fp->refcnt, 1);	fp->len = fprog->len;	err = sk_chk_filter(fp->insns, fp->len);	if (err) {		sk_filter_uncharge(sk, fp);		return err;	}	old_fp = rcu_dereference_protected(sk->sk_filter,					   sock_owned_by_user(sk));	rcu_assign_pointer(sk->sk_filter, fp);	if (old_fp)		sk_filter_uncharge(sk, old_fp);	return 0;}

static voidMksckPageDescSkDestruct(struct sock *sk){	struct sock *mkSk = NULL;	struct MksckPageDescInfo *mpdi;	lock_sock(sk);	mpdi = sk->sk_protinfo;	while (mpdi) {		struct MksckPageDescInfo *next = mpdi->next;		MksckPageDescManage(mpdi->descs, mpdi->pages,				    MANAGE_DECREMENT);		kfree(mpdi);		mpdi = next;	}	if (sk->sk_user_data) {		mkSk = (struct sock *)sk->sk_user_data;		sk->sk_user_data = NULL;	}	sk->sk_protinfo  = NULL;	release_sock(sk);	if (mkSk) {		lock_sock(mkSk);		sock_kfree_s(mkSk, mkSk->sk_user_data, sizeof(int));		mkSk->sk_user_data = NULL;		release_sock(mkSk);		sock_put(mkSk); 	}}

int inet6_destroy_sock(struct sock *sk){	struct sk_buff *skb;	struct ipv6_txoptions *opt;	/*	 *	Release destination entry	 */	sk_dst_reset(sk);	/* Release rx options */	if ((skb = xchg(&sk->net_pinfo.af_inet6.pktoptions, NULL)) != NULL)		kfree_skb(skb);	/* Free flowlabels */	fl6_free_socklist(sk);	/* Free tx options */	if ((opt = xchg(&sk->net_pinfo.af_inet6.opt, NULL)) != NULL)		sock_kfree_s(sk, opt, opt->tot_len);	return 0;}

void ipv6_sock_ac_close(struct sock *sk){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net_device *dev = NULL;	struct ipv6_ac_socklist *pac;	int	prev_index;	write_lock_bh(&ipv6_sk_ac_lock);	pac = np->ipv6_ac_list;	np->ipv6_ac_list = NULL;	write_unlock_bh(&ipv6_sk_ac_lock);	prev_index = 0;	while (pac) {		struct ipv6_ac_socklist *next = pac->acl_next;		if (pac->acl_ifindex != prev_index) {			if (dev)				dev_put(dev);			dev = dev_get_by_index(&init_net, pac->acl_ifindex);			prev_index = pac->acl_ifindex;		}		if (dev)			ipv6_dev_ac_dec(dev, &pac->acl_addr);		sock_kfree_s(sk, pac, sizeof(*pac));		pac = next;	}	if (dev)		dev_put(dev);}

void ipv6_sock_ac_close(struct sock *sk){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net_device *dev = NULL;	struct ipv6_ac_socklist *pac;	struct net *net = sock_net(sk);	int	prev_index;	if (!np->ipv6_ac_list)		return;	rtnl_lock();	pac = np->ipv6_ac_list;	np->ipv6_ac_list = NULL;	prev_index = 0;	while (pac) {		struct ipv6_ac_socklist *next = pac->acl_next;		if (pac->acl_ifindex != prev_index) {			dev = __dev_get_by_index(net, pac->acl_ifindex);			prev_index = pac->acl_ifindex;		}		if (dev)			ipv6_dev_ac_dec(dev, &pac->acl_addr);		sock_kfree_s(sk, pac, sizeof(*pac));		pac = next;	}	rtnl_unlock();}

/* *	socket leave an anycast group */int ipv6_sock_ac_drop(struct sock *sk, int ifindex, const struct in6_addr *addr){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net_device *dev;	struct ipv6_ac_socklist *pac, *prev_pac;	struct net *net = sock_net(sk);	ASSERT_RTNL();	prev_pac = NULL;	for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {		if ((ifindex == 0 || pac->acl_ifindex == ifindex) &&		     ipv6_addr_equal(&pac->acl_addr, addr))			break;		prev_pac = pac;	}	if (!pac)		return -ENOENT;	if (prev_pac)		prev_pac->acl_next = pac->acl_next;	else		np->ipv6_ac_list = pac->acl_next;	dev = __dev_get_by_index(net, pac->acl_ifindex);	if (dev)		ipv6_dev_ac_dec(dev, &pac->acl_addr);	sock_kfree_s(sk, pac, sizeof(*pac));	return 0;}

int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr){    struct ip_mc_socklist *iml, **imlp;    rtnl_lock();    for (imlp=&sk->protinfo.af_inet.mc_list; (iml=*imlp)!=NULL; imlp=&iml->next) {        if (iml->multi.imr_multiaddr.s_addr==imr->imr_multiaddr.s_addr &&                iml->multi.imr_address.s_addr==imr->imr_address.s_addr &&                (!imr->imr_ifindex || iml->multi.imr_ifindex==imr->imr_ifindex)) {            struct in_device *in_dev;            if (--iml->count) {                rtnl_unlock();                return 0;            }            *imlp = iml->next;            in_dev = inetdev_by_index(iml->multi.imr_ifindex);            if (in_dev) {                ip_mc_dec_group(in_dev, imr->imr_multiaddr.s_addr);                in_dev_put(in_dev);            }            rtnl_unlock();            sock_kfree_s(sk, iml, sizeof(*iml));            return 0;        }    }    rtnl_unlock();    return -EADDRNOTAVAIL;}

int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr){    int err;    u32 addr = imr->imr_multiaddr.s_addr;    struct ip_mc_socklist *iml, *i;    struct in_device *in_dev;    int count = 0;    if (!MULTICAST(addr))        return -EINVAL;    rtnl_shlock();    if (!imr->imr_ifindex)        in_dev = ip_mc_find_dev(imr);    else {        in_dev = inetdev_by_index(imr->imr_ifindex);        if (in_dev)            __in_dev_put(in_dev);    }    if (!in_dev) {        iml = NULL;        err = -ENODEV;        goto done;    }    iml = (struct ip_mc_socklist *)sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);    err = -EADDRINUSE;    for (i=sk->protinfo.af_inet.mc_list; i; i=i->next) {        if (memcmp(&i->multi, imr, sizeof(*imr)) == 0) {            /* New style additions are reference counted */            if (imr->imr_address.s_addr == 0) {                i->count++;                err = 0;            }            goto done;        }        count++;    }    err = -ENOBUFS;    if (iml == NULL || count >= sysctl_igmp_max_memberships)        goto done;    memcpy(&iml->multi, imr, sizeof(*imr));    iml->next = sk->protinfo.af_inet.mc_list;    iml->count = 1;    sk->protinfo.af_inet.mc_list = iml;    ip_mc_inc_group(in_dev, addr);    iml = NULL;    err = 0;done:    rtnl_shunlock();    if (iml)        sock_kfree_s(sk, iml, sizeof(*iml));    return err;}

void ip_mc_drop_socket(struct sock *sk){	struct ip_mc_socklist *iml;	while ((iml=sk->ip_mc_list) != NULL) {		struct in_device *in_dev;		sk->ip_mc_list = iml->next;		if ((in_dev = inetdev_by_index(iml->multi.imr_ifindex)) != NULL)			ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);		sock_kfree_s(sk, iml, sizeof(*iml));	}}

static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,			      struct request_values *rvp){	struct inet6_request_sock *treq = inet6_rsk(req);	struct ipv6_pinfo *np = inet6_sk(sk);	struct sk_buff * skb;	struct ipv6_txoptions *opt = NULL;	struct in6_addr * final_p, final;	struct flowi6 fl6;	struct dst_entry *dst;	int err;	memset(&fl6, 0, sizeof(fl6));	fl6.flowi6_proto = IPPROTO_TCP;	fl6.daddr = treq->rmt_addr;	fl6.saddr = treq->loc_addr;	fl6.flowlabel = 0;	fl6.flowi6_oif = treq->iif;	fl6.flowi6_mark = inet_rsk(req)->ir_mark;	fl6.fl6_dport = inet_rsk(req)->rmt_port;	fl6.fl6_sport = inet_rsk(req)->loc_port;	fl6.flowi6_uid = sock_i_uid(sk);	security_req_classify_flow(req, flowi6_to_flowi(&fl6));	opt = np->opt;	final_p = fl6_update_dst(&fl6, opt, &final);	dst = ip6_dst_lookup_flow(sk, &fl6, final_p, false);	if (IS_ERR(dst)) {		err = PTR_ERR(dst);		dst = NULL;		goto done;	}	skb = tcp_make_synack(sk, dst, req, rvp);	err = -ENOMEM;	if (skb) {		__tcp_v6_send_check(skb, &treq->loc_addr, &treq->rmt_addr);		fl6.daddr = treq->rmt_addr;		err = ip6_xmit(sk, skb, &fl6, opt, np->tclass);		err = net_xmit_eval(err);	}done:	if (opt && opt != np->opt)		sock_kfree_s(sk, opt, opt->tot_len);	dst_release(dst);	return err;}

static voidMksckSkDestruct(struct sock *sk){	Mksck *mksck;	lock_sock(sk);	mksck = sk->sk_protinfo;	if (mksck != NULL) {		sk->sk_protinfo = NULL;		Mksck_CloseCommon(mksck);	}	if (sk->sk_user_data != NULL) {		sock_kfree_s(sk, sk->sk_user_data, sizeof(int));		sk->sk_user_data = NULL;	}	release_sock(sk);}

void ip_mc_drop_socket(struct sock *sk){    struct ip_mc_socklist *iml;    if (sk->protinfo.af_inet.mc_list == NULL)        return;    rtnl_lock();    while ((iml=sk->protinfo.af_inet.mc_list) != NULL) {        struct in_device *in_dev;        sk->protinfo.af_inet.mc_list = iml->next;        if ((in_dev = inetdev_by_index(iml->multi.imr_ifindex)) != NULL) {            ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);            in_dev_put(in_dev);        }        sock_kfree_s(sk, iml, sizeof(*iml));    }    rtnl_unlock();}

int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr){	struct ip_mc_socklist *iml, **imlp;	for (imlp=&sk->ip_mc_list; (iml=*imlp)!=NULL; imlp=&iml->next) {		if (iml->multi.imr_multiaddr.s_addr==imr->imr_multiaddr.s_addr &&		    iml->multi.imr_address.s_addr==imr->imr_address.s_addr &&		    (!imr->imr_ifindex || iml->multi.imr_ifindex==imr->imr_ifindex)) {			struct in_device *in_dev;			if (--iml->count)				return 0;			*imlp = iml->next;			synchronize_bh();			in_dev = inetdev_by_index(iml->multi.imr_ifindex);			if (in_dev)				ip_mc_dec_group(in_dev, imr->imr_multiaddr.s_addr);			sock_kfree_s(sk, iml, sizeof(*iml));			return 0;		}	}	return -EADDRNOTAVAIL;}

//.........这里部分代码省略.........		}		ipv6_addr_copy(&fl.fl6_src, &ireq6->loc_addr);		fl.oif = sk->sk_bound_dev_if;		fl.fl_ip_dport = inet_rsk(req)->rmt_port;		fl.fl_ip_sport = inet_rsk(req)->loc_port;		security_sk_classify_flow(sk, &fl);		if (ip6_dst_lookup(sk, &dst, &fl))			goto out;		if (final_p)			ipv6_addr_copy(&fl.fl6_dst, final_p);		if ((xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0)			goto out;	}	newsk = dccp_create_openreq_child(sk, req, skb);	if (newsk == NULL)		goto out;	/*	 * No need to charge this sock to the relevant IPv6 refcnt debug socks	 * count here, dccp_create_openreq_child now does this for us, see the	 * comment in that function for the gory details. -acme	 */	__ip6_dst_store(newsk, dst, NULL, NULL);	newsk->sk_route_caps = dst->dev->features & ~(NETIF_F_IP_CSUM |						      NETIF_F_TSO);	newdp6 = (struct dccp6_sock *)newsk;	newinet = inet_sk(newsk);	newinet->pinet6 = &newdp6->inet6;	newdp = dccp_sk(newsk);	newnp = inet6_sk(newsk);	memcpy(newnp, np, sizeof(struct ipv6_pinfo));	ipv6_addr_copy(&newnp->daddr, &ireq6->rmt_addr);	ipv6_addr_copy(&newnp->saddr, &ireq6->loc_addr);	ipv6_addr_copy(&newnp->rcv_saddr, &ireq6->loc_addr);	newsk->sk_bound_dev_if = ireq6->iif;	/* Now IPv6 options...	   First: no IPv4 options.	 */	newinet->opt = NULL;	/* Clone RX bits */	newnp->rxopt.all = np->rxopt.all;	/* Clone pktoptions received with SYN */	newnp->pktoptions = NULL;	if (ireq6->pktopts != NULL) {		newnp->pktoptions = skb_clone(ireq6->pktopts, GFP_ATOMIC);		kfree_skb(ireq6->pktopts);		ireq6->pktopts = NULL;		if (newnp->pktoptions)			skb_set_owner_r(newnp->pktoptions, newsk);	}	newnp->opt	  = NULL;	newnp->mcast_oif  = inet6_iif(skb);	newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;	/*	 * Clone native IPv6 options from listening socket (if any)	 *	 * Yes, keeping reference count would be much more clever, but we make	 * one more one thing there: reattach optmem to newsk.	 */	if (opt != NULL) {		newnp->opt = ipv6_dup_options(newsk, opt);		if (opt != np->opt)			sock_kfree_s(sk, opt, opt->tot_len);	}	inet_csk(newsk)->icsk_ext_hdr_len = 0;	if (newnp->opt != NULL)		inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +						     newnp->opt->opt_flen);	dccp_sync_mss(newsk, dst_mtu(dst));	newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;	__inet6_hash(newsk);	__inet_inherit_port(sk, newsk);	return newsk;out_overflow:	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);out:	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);	if (opt != NULL && opt != np->opt)		sock_kfree_s(sk, opt, opt->tot_len);	dst_release(dst);	return NULL;}

int ipv6_setsockopt(struct sock *sk, int level, int optname,		    char __user *optval, int optlen){	struct ipv6_pinfo *np = inet6_sk(sk);	int val, valbool;	int retv = -ENOPROTOOPT;	if (level == SOL_IP && sk->sk_type != SOCK_RAW)		return udp_prot.setsockopt(sk, level, optname, optval, optlen);	if(level!=SOL_IPV6)		goto out;	if (optval == NULL)		val=0;	else if (get_user(val, (int __user *) optval))		return -EFAULT;	valbool = (val!=0);	lock_sock(sk);	switch (optname) {	case IPV6_ADDRFORM:		if (val == PF_INET) {			struct ipv6_txoptions *opt;			struct sk_buff *pktopt;			if (sk->sk_protocol != IPPROTO_UDP &&			    sk->sk_protocol != IPPROTO_TCP)				break;			if (sk->sk_state != TCP_ESTABLISHED) {				retv = -ENOTCONN;				break;			}			if (ipv6_only_sock(sk) ||			    !(ipv6_addr_type(&np->daddr) & IPV6_ADDR_MAPPED)) {				retv = -EADDRNOTAVAIL;				break;			}			fl6_free_socklist(sk);			ipv6_sock_mc_close(sk);			if (sk->sk_protocol == IPPROTO_TCP) {				struct tcp_sock *tp = tcp_sk(sk);				local_bh_disable();				sock_prot_dec_use(sk->sk_prot);				sock_prot_inc_use(&tcp_prot);				local_bh_enable();				sk->sk_prot = &tcp_prot;				tp->af_specific = &ipv4_specific;				sk->sk_socket->ops = &inet_stream_ops;				sk->sk_family = PF_INET;				tcp_sync_mss(sk, tp->pmtu_cookie);			} else {				local_bh_disable();				sock_prot_dec_use(sk->sk_prot);				sock_prot_inc_use(&udp_prot);				local_bh_enable();				sk->sk_prot = &udp_prot;				sk->sk_socket->ops = &inet_dgram_ops;				sk->sk_family = PF_INET;			}			opt = xchg(&np->opt, NULL);			if (opt)				sock_kfree_s(sk, opt, opt->tot_len);			pktopt = xchg(&np->pktoptions, NULL);			if (pktopt)				kfree_skb(pktopt);			sk->sk_destruct = inet_sock_destruct;#ifdef INET_REFCNT_DEBUG			atomic_dec(&inet6_sock_nr);#endif			module_put(THIS_MODULE);			retv = 0;			break;		}		goto e_inval;	case IPV6_V6ONLY:		if (inet_sk(sk)->num)			goto e_inval;		np->ipv6only = valbool;		retv = 0;		break;	case IPV6_PKTINFO:		np->rxopt.bits.rxinfo = valbool;		retv = 0;		break;	case IPV6_HOPLIMIT:		np->rxopt.bits.rxhlim = valbool;		retv = 0;//.........这里部分代码省略.........

static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,		    char __user *optval, unsigned int optlen){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net *net = sock_net(sk);	int val, valbool;	int retv = -ENOPROTOOPT;	if (optval == NULL)		val=0;	else {		if (optlen >= sizeof(int)) {			if (get_user(val, (int __user *) optval))				return -EFAULT;		} else			val = 0;	}	valbool = (val!=0);	if (ip6_mroute_opt(optname))		return ip6_mroute_setsockopt(sk, optname, optval, optlen);	lock_sock(sk);	switch (optname) {	case IPV6_ADDRFORM:		if (optlen < sizeof(int))			goto e_inval;		if (val == PF_INET) {			struct ipv6_txoptions *opt;			struct sk_buff *pktopt;			if (sk->sk_type == SOCK_RAW)				break;			if (sk->sk_protocol == IPPROTO_UDP ||			    sk->sk_protocol == IPPROTO_UDPLITE) {				struct udp_sock *up = udp_sk(sk);				if (up->pending == AF_INET6) {					retv = -EBUSY;					break;				}			} else if (sk->sk_protocol != IPPROTO_TCP)				break;			if (sk->sk_state != TCP_ESTABLISHED) {				retv = -ENOTCONN;				break;			}			if (ipv6_only_sock(sk) ||			    !ipv6_addr_v4mapped(&np->daddr)) {				retv = -EADDRNOTAVAIL;				break;			}			fl6_free_socklist(sk);			ipv6_sock_mc_close(sk);			/*			 * Sock is moving from IPv6 to IPv4 (sk_prot), so			 * remove it from the refcnt debug socks count in the			 * original family...			 */			sk_refcnt_debug_dec(sk);			if (sk->sk_protocol == IPPROTO_TCP) {				struct inet_connection_sock *icsk = inet_csk(sk);				local_bh_disable();				sock_prot_inuse_add(net, sk->sk_prot, -1);				sock_prot_inuse_add(net, &tcp_prot, 1);				local_bh_enable();				sk->sk_prot = &tcp_prot;				icsk->icsk_af_ops = &ipv4_specific;				sk->sk_socket->ops = &inet_stream_ops;				sk->sk_family = PF_INET;				tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);			} else {				struct proto *prot = &udp_prot;				if (sk->sk_protocol == IPPROTO_UDPLITE)					prot = &udplite_prot;				local_bh_disable();				sock_prot_inuse_add(net, sk->sk_prot, -1);				sock_prot_inuse_add(net, prot, 1);				local_bh_enable();				sk->sk_prot = prot;				sk->sk_socket->ops = &inet_dgram_ops;				sk->sk_family = PF_INET;			}			opt = xchg(&np->opt, NULL);			if (opt)				sock_kfree_s(sk, opt, opt->tot_len);			pktopt = xchg(&np->pktoptions, NULL);			kfree_skb(pktopt);			sk->sk_destruct = inet_sock_destruct;			/*//.........这里部分代码省略.........

/* There is a lot of hair here because the alignment rules (and * thus placement) of cmsg headers and length are different for * 32-bit apps.  -DaveM */int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg, struct sock *sk,			       unsigned char *stackbuf, int stackbuf_size){	struct compat_cmsghdr __user *ucmsg;	struct cmsghdr *kcmsg, *kcmsg_base;	compat_size_t ucmlen;	__kernel_size_t kcmlen, tmp;	int err = -EFAULT;	kcmlen = 0;	kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;	ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);	while (ucmsg != NULL) {		if (get_user(ucmlen, &ucmsg->cmsg_len))			return -EFAULT;		/* Catch bogons. */		if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))			return -EINVAL;		tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +		       CMSG_ALIGN(sizeof(struct cmsghdr)));		tmp = CMSG_ALIGN(tmp);		kcmlen += tmp;		ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);	}	if (kcmlen == 0)		return -EINVAL;	/* The kcmlen holds the 64-bit version of the control length.	 * It may not be modified as we do not stick it into the kmsg	 * until we have successfully copied over all of the data	 * from the user.	 */	if (kcmlen > stackbuf_size)		kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);	if (kcmsg == NULL)		return -ENOBUFS;	/* Now copy them over neatly. */	memset(kcmsg, 0, kcmlen);	ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);	while (ucmsg != NULL) {		if (__get_user(ucmlen, &ucmsg->cmsg_len))			goto Efault;		if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))			goto Einval;		tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +		       CMSG_ALIGN(sizeof(struct cmsghdr)));		if ((char *)kcmsg_base + kcmlen - (char *)kcmsg < CMSG_ALIGN(tmp))			goto Einval;		kcmsg->cmsg_len = tmp;		tmp = CMSG_ALIGN(tmp);		if (__get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level) ||		    __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type) ||		    copy_from_user(CMSG_DATA(kcmsg),				   CMSG_COMPAT_DATA(ucmsg),				   (ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg)))))			goto Efault;		/* Advance. */		kcmsg = (struct cmsghdr *)((char *)kcmsg + tmp);		ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);	}	/* Ok, looks like we made it.  Hook it up and return success. */	kmsg->msg_control = kcmsg_base;	kmsg->msg_controllen = kcmlen;	return 0;Einval:	err = -EINVAL;Efault:	if (kcmsg_base != (struct cmsghdr *)stackbuf)		sock_kfree_s(sk, kcmsg_base, kcmlen);	return err;}

static intMksckPageDescIoctl(struct socket *sock,		   unsigned int cmd,		   unsigned long arg){	struct sock *mksck = NULL;	struct sock *sk = sock->sk;	struct MksckPageDescInfo *mpdi;	unsigned long ul[2];	int retval = 0;	switch (cmd) {	case MKSCK_DETACH:		lock_sock(sk);		mpdi = sk->sk_protinfo;		if (copy_from_user(ul, (void *)arg, sizeof(ul))) {			retval = -EFAULT;		} else if (!mpdi || !sk->sk_user_data) {			retval = -EINVAL;		} else {			uint32 flags = calc_vm_prot_bits(ul[0]);			ul[0] = 0;			while (mpdi) {				struct MksckPageDescInfo *next = mpdi->next;				ul[0] += MksckPageDescManage(mpdi->descs,							     mpdi->pages,							     MANAGE_COUNT);				mpdi->mapCounts = ul[1];				mpdi = next;			}			if (copy_to_user((void *)arg, ul, sizeof(ul[0]))) {				retval = -EFAULT;			} else {				mpdi = sk->sk_protinfo;				mpdi->flags = flags;				mksck = (struct sock *)sk->sk_user_data;				sk->sk_user_data = NULL;			}		}		release_sock(sk);		sk = mksck;		if (sk) {			lock_sock(sk);			sock_kfree_s(sk, sk->sk_user_data, sizeof(int));			sk->sk_user_data = NULL;			release_sock(sk);			sock_put(sk);		}		break;	default:		retval = -EINVAL;		break;	}	return retval;}

static intMksckPageDescToFd(struct socket *sock,		  struct msghdr *msg,		  Mksck_PageDesc *pd,		  uint32 pages){	int retval;	int newfd;	struct socket *newsock;	struct sock *newsk;	struct sock *sk = sock->sk;	struct MksckPageDescInfo **pmpdi, *mpdi;	lock_sock(sk);	if (sk->sk_user_data) {		struct MksckPageDescInfo *mpdi2;				newfd = *((int *)sk->sk_user_data);				newsock = sockfd_lookup(newfd, &retval);		if (!newsock) {			retval = -EINVAL;			goto endProcessingReleaseSock;		}		newsk = newsock->sk;		lock_sock(newsk);		sockfd_put(newsock);		if (((struct sock *)newsk->sk_user_data) != sk) {			retval = -EINVAL;			release_sock(newsk);			goto endProcessingReleaseSock;		}		mpdi = kmalloc(sizeof(struct MksckPageDescInfo) +			       pages*sizeof(Mksck_PageDesc), GFP_KERNEL);		if (!mpdi) {			retval = -ENOMEM;			release_sock(newsk);			goto endProcessingReleaseSock;		}		retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);		if (retval < 0)			goto endProcessingKFreeReleaseSock;		release_sock(sk);		mpdi2 = (struct MksckPageDescInfo *)newsk->sk_protinfo;		while (mpdi2->next)			mpdi2 = mpdi2->next;		pmpdi = &(mpdi2->next);	} else {		retval = sock_create(sk->sk_family, sock->type, 0, &newsock);		if (retval < 0)			goto endProcessingReleaseSock;		newsk = newsock->sk;		lock_sock(newsk);		newsk->sk_destruct = &MksckPageDescSkDestruct;		newsk->sk_user_data = sk;		sock_hold(sk); 		newsock->ops = &mksckPageDescOps;		mpdi = kmalloc(sizeof(struct MksckPageDescInfo) +			       pages*sizeof(Mksck_PageDesc), GFP_KERNEL);		if (!mpdi) {			retval = -ENOMEM;			goto endProcessingFreeNewSock;		}		sk->sk_user_data = sock_kmalloc(sk, sizeof(int), GFP_KERNEL);		if (sk->sk_user_data == NULL) {			retval = -ENOMEM;			goto endProcessingKFreeAndNewSock;		}		newfd = sock_map_fd(newsock, O_CLOEXEC);		if (newfd < 0) {			retval = newfd;			sock_kfree_s(sk, sk->sk_user_data, sizeof(int));			sk->sk_user_data = NULL;			goto endProcessingKFreeAndNewSock;		}		retval = put_cmsg(msg, SOL_DECNET, 0, sizeof(int), &newfd);		if (retval < 0) {			sock_kfree_s(sk, sk->sk_user_data, sizeof(int));			sk->sk_user_data = NULL;			kfree(mpdi);			release_sock(newsk);			sockfd_put(newsock);			sock_release(newsock);			put_unused_fd(newfd);//.........这里部分代码省略.........

int ipv6_sock_ac_join(struct sock *sk, int ifindex, struct in6_addr *addr){	struct ipv6_pinfo *np = inet6_sk(sk);	struct net_device *dev = NULL;	struct inet6_dev *idev;	struct ipv6_ac_socklist *pac;	int	ishost = !ipv6_devconf.forwarding;	int	err = 0;	if (!capable(CAP_NET_ADMIN))		return -EPERM;	if (ipv6_addr_is_multicast(addr))		return -EINVAL;	if (ipv6_chk_addr(addr, NULL, 0))		return -EINVAL;	pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);	if (pac == NULL)		return -ENOMEM;	pac->acl_next = NULL;	ipv6_addr_copy(&pac->acl_addr, addr);	if (ifindex == 0) {		struct rt6_info *rt;		rt = rt6_lookup(addr, NULL, 0, 0);		if (rt) {			dev = rt->rt6i_dev;			dev_hold(dev);			dst_release(&rt->u.dst);		} else if (ishost) {			err = -EADDRNOTAVAIL;			goto out_free_pac;		} else {			/* router, no matching interface: just pick one */			dev = dev_get_by_flags(&init_net, IFF_UP, IFF_UP|IFF_LOOPBACK);		}	} else		dev = dev_get_by_index(&init_net, ifindex);	if (dev == NULL) {		err = -ENODEV;		goto out_free_pac;	}	idev = in6_dev_get(dev);	if (!idev) {		if (ifindex)			err = -ENODEV;		else			err = -EADDRNOTAVAIL;		goto out_dev_put;	}	/* reset ishost, now that we have a specific device */	ishost = !idev->cnf.forwarding;	in6_dev_put(idev);	pac->acl_ifindex = dev->ifindex;	/* XXX	 * For hosts, allow link-local or matching prefix anycasts.	 * This obviates the need for propagating anycast routes while	 * still allowing some non-router anycast participation.	 */	if (!ip6_onlink(addr, dev)) {		if (ishost)			err = -EADDRNOTAVAIL;		if (err)			goto out_dev_put;	}	err = ipv6_dev_ac_inc(dev, addr);	if (err)		goto out_dev_put;	write_lock_bh(&ipv6_sk_ac_lock);	pac->acl_next = np->ipv6_ac_list;	np->ipv6_ac_list = pac;	write_unlock_bh(&ipv6_sk_ac_lock);	dev_put(dev);	return 0;out_dev_put:	dev_put(dev);out_free_pac:	sock_kfree_s(sk, pac, sizeof(*pac));	return err;}