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

/* tipc_send_msg - enqueue a send request */static int tipc_udp_send_msg(struct net *net, struct sk_buff *skb,			     struct tipc_bearer *b,			     struct tipc_media_addr *dest){	int ttl, err = 0;	struct udp_bearer *ub;	struct udp_media_addr *dst = (struct udp_media_addr *)&dest->value;	struct udp_media_addr *src = (struct udp_media_addr *)&b->addr.value;	struct rtable *rt;	if (skb_headroom(skb) < UDP_MIN_HEADROOM) {		err = pskb_expand_head(skb, UDP_MIN_HEADROOM, 0, GFP_ATOMIC);		if (err)			goto tx_error;	}	skb_set_inner_protocol(skb, htons(ETH_P_TIPC));	ub = rcu_dereference_rtnl(b->media_ptr);	if (!ub) {		err = -ENODEV;		goto tx_error;	}	if (dst->proto == htons(ETH_P_IP)) {		struct flowi4 fl = {			.daddr = dst->ipv4.s_addr,			.saddr = src->ipv4.s_addr,			.flowi4_mark = skb->mark,			.flowi4_proto = IPPROTO_UDP		};		rt = ip_route_output_key(net, &fl);		if (IS_ERR(rt)) {			err = PTR_ERR(rt);			goto tx_error;		}		ttl = ip4_dst_hoplimit(&rt->dst);		err = udp_tunnel_xmit_skb(rt, ub->ubsock->sk, skb,					  src->ipv4.s_addr,					  dst->ipv4.s_addr, 0, ttl, 0,					  src->udp_port, dst->udp_port,					  false, true);		if (err < 0) {			ip_rt_put(rt);			goto tx_error;		}#if IS_ENABLED(CONFIG_IPV6)	} else {		struct dst_entry *ndst;		struct flowi6 fl6 = {			.flowi6_oif = ub->ifindex,			.daddr = dst->ipv6,			.saddr = src->ipv6,			.flowi6_proto = IPPROTO_UDP		};		err = ipv6_stub->ipv6_dst_lookup(net, ub->ubsock->sk, &ndst,						 &fl6);		if (err)			goto tx_error;		ttl = ip6_dst_hoplimit(ndst);		err = udp_tunnel6_xmit_skb(ndst, ub->ubsock->sk, skb,					   ndst->dev, &src->ipv6,					   &dst->ipv6, 0, ttl, src->udp_port,					   dst->udp_port, false);#endif	}	return err;tx_error:	kfree_skb(skb);	return err;}/* tipc_udp_recv - read data from bearer socket */static int tipc_udp_recv(struct sock *sk, struct sk_buff *skb){	struct udp_bearer *ub;	struct tipc_bearer *b;	int usr = msg_user(buf_msg(skb));	if ((usr == LINK_PROTOCOL) || (usr == NAME_DISTRIBUTOR))		skb_linearize(skb);	ub = rcu_dereference_sk_user_data(sk);	if (!ub) {		pr_err_ratelimited("Failed to get UDP bearer reference");		kfree_skb(skb);		return 0;	}	skb_pull(skb, sizeof(struct udphdr));	rcu_read_lock();	b = rcu_dereference_rtnl(ub->bearer);	if (b) {		tipc_rcv(sock_net(sk), skb, b);		rcu_read_unlock();		return 0;	}	rcu_read_unlock();	kfree_skb(skb);//.........这里部分代码省略.........

int ip6_push_pending_frames(struct sock *sk){	struct sk_buff *skb, *tmp_skb;	struct sk_buff **tail_skb;	struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;	struct inet_sock *inet = inet_sk(sk);	struct ipv6_pinfo *np = inet6_sk(sk);	struct net *net = sock_net(sk);	struct ipv6hdr *hdr;	struct ipv6_txoptions *opt = np->cork.opt;	struct rt6_info *rt = (struct rt6_info *)inet->cork.base.dst;	struct flowi6 *fl6 = &inet->cork.fl.u.ip6;	unsigned char proto = fl6->flowi6_proto;	int err = 0;	if ((skb = __skb_dequeue(&sk->sk_write_queue)) == NULL)		goto out;	tail_skb = &(skb_shinfo(skb)->frag_list);	/* move skb->data to ip header from ext header */	if (skb->data < skb_network_header(skb))		__skb_pull(skb, skb_network_offset(skb));	while ((tmp_skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {		__skb_pull(tmp_skb, skb_network_header_len(skb));		*tail_skb = tmp_skb;		tail_skb = &(tmp_skb->next);		skb->len += tmp_skb->len;		skb->data_len += tmp_skb->len;		skb->truesize += tmp_skb->truesize;		tmp_skb->destructor = NULL;		tmp_skb->sk = NULL;	}	/* Allow local fragmentation. */	if (np->pmtudisc < IPV6_PMTUDISC_DO)		skb->local_df = 1;	*final_dst = fl6->daddr;	__skb_pull(skb, skb_network_header_len(skb));	if (opt && opt->opt_flen)		ipv6_push_frag_opts(skb, opt, &proto);	if (opt && opt->opt_nflen)		ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst);	skb_push(skb, sizeof(struct ipv6hdr));	skb_reset_network_header(skb);	hdr = ipv6_hdr(skb);	ip6_flow_hdr(hdr, np->cork.tclass, fl6->flowlabel);	hdr->hop_limit = np->cork.hop_limit;	hdr->nexthdr = proto;	hdr->saddr = fl6->saddr;	hdr->daddr = *final_dst;	skb->priority = sk->sk_priority;	skb->mark = sk->sk_mark;	skb_dst_set(skb, dst_clone(&rt->dst));	IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);	if (proto == IPPROTO_ICMPV6) {		struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));		ICMP6MSGOUT_INC_STATS(net, idev, icmp6_hdr(skb)->icmp6_type);		ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);	}	err = ip6_local_out(skb);	if (err) {		if (err > 0)			err = net_xmit_errno(err);		if (err)			goto error;	}out:	ip6_cork_release(inet, np);	return err;error:	IP6_INC_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);	goto out;}

static int ip6_dst_lookup_tail(struct sock *sk,			       struct dst_entry **dst, struct flowi6 *fl6){	struct net *net = sock_net(sk);#ifdef CONFIG_IPV6_OPTIMISTIC_DAD	struct neighbour *n;	struct rt6_info *rt;#endif	int err;	if (*dst == NULL)		*dst = ip6_route_output(net, sk, fl6);	if ((err = (*dst)->error))		goto out_err_release;	if (ipv6_addr_any(&fl6->saddr)) {		struct rt6_info *rt = (struct rt6_info *) *dst;		err = ip6_route_get_saddr(net, rt, &fl6->daddr,					  sk ? inet6_sk(sk)->srcprefs : 0,					  &fl6->saddr);		if (err)			goto out_err_release;	}#ifdef CONFIG_IPV6_OPTIMISTIC_DAD	/*	 * Here if the dst entry we've looked up	 * has a neighbour entry that is in the INCOMPLETE	 * state and the src address from the flow is	 * marked as OPTIMISTIC, we release the found	 * dst entry and replace it instead with the	 * dst entry of the nexthop router	 */	rt = (struct rt6_info *) *dst;	rcu_read_lock_bh();	n = __ipv6_neigh_lookup_noref(rt->dst.dev, rt6_nexthop(rt));	err = n && !(n->nud_state & NUD_VALID) ? -EINVAL : 0;	rcu_read_unlock_bh();	if (err) {		struct inet6_ifaddr *ifp;		struct flowi6 fl_gw6;		int redirect;		ifp = ipv6_get_ifaddr(net, &fl6->saddr,				      (*dst)->dev, 1);		redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);		if (ifp)			in6_ifa_put(ifp);		if (redirect) {			/*			 * We need to get the dst entry for the			 * default router instead			 */			dst_release(*dst);			memcpy(&fl_gw6, fl6, sizeof(struct flowi6));			memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr));			*dst = ip6_route_output(net, sk, &fl_gw6);			if ((err = (*dst)->error))				goto out_err_release;		}	}#endif	return 0;out_err_release:	if (err == -ENETUNREACH)		IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES);	dst_release(*dst);	*dst = NULL;	return err;}

/* Returns true if we should perform Fast Open on the SYN. The cookie (foc) * may be updated and return the client in the SYN-ACK later. E.g., Fast Open * cookie request (foc->len == 0). */struct sock *tcp_try_fastopen(struct sock *sk, struct sk_buff *skb,			      struct request_sock *req,			      struct tcp_fastopen_cookie *foc,			      struct dst_entry *dst){	struct tcp_fastopen_cookie valid_foc = { .len = -1 };	bool syn_data = TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq + 1;	struct sock *child;	if (foc->len == 0) /* Client requests a cookie */		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENCOOKIEREQD);	if (!((sysctl_tcp_fastopen & TFO_SERVER_ENABLE) &&	      (syn_data || foc->len >= 0) &&	      tcp_fastopen_queue_check(sk))) {		foc->len = -1;		return NULL;	}	if (syn_data && (sysctl_tcp_fastopen & TFO_SERVER_COOKIE_NOT_REQD))		goto fastopen;	if (foc->len >= 0 &&  /* Client presents or requests a cookie */	    tcp_fastopen_cookie_gen(req, skb, &valid_foc) &&	    foc->len == TCP_FASTOPEN_COOKIE_SIZE &&	    foc->len == valid_foc.len &&	    !memcmp(foc->val, valid_foc.val, foc->len)) {		/* Cookie is valid. Create a (full) child socket to accept		 * the data in SYN before returning a SYN-ACK to ack the		 * data. If we fail to create the socket, fall back and		 * ack the ISN only but includes the same cookie.		 *		 * Note: Data-less SYN with valid cookie is allowed to send		 * data in SYN_RECV state.		 */fastopen:		child = tcp_fastopen_create_child(sk, skb, dst, req);		if (child) {			foc->len = -1;			NET_INC_STATS(sock_net(sk),				      LINUX_MIB_TCPFASTOPENPASSIVE);			return child;		}		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);	} else if (foc->len > 0) /* Client presents an invalid cookie */		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENPASSIVEFAIL);	valid_foc.exp = foc->exp;	*foc = valid_foc;	return NULL;}bool tcp_fastopen_cookie_check(struct sock *sk, u16 *mss,			       struct tcp_fastopen_cookie *cookie){	unsigned long last_syn_loss = 0;	int syn_loss = 0;	tcp_fastopen_cache_get(sk, mss, cookie, &syn_loss, &last_syn_loss);	/* Recurring FO SYN losses: no cookie or data in SYN */	if (syn_loss > 1 &&	    time_before(jiffies, last_syn_loss + (60*HZ << syn_loss))) {		cookie->len = -1;		return false;	}	/* Firewall blackhole issue check */	if (tcp_fastopen_active_should_disable(sk)) {		cookie->len = -1;		return false;	}	if (sysctl_tcp_fastopen & TFO_CLIENT_NO_COOKIE) {		cookie->len = -1;		return true;	}	return cookie->len > 0;}

static int tc_ctl_tfilter(struct sk_buff *skb, struct nlmsghdr *n, void *arg){    struct net *net = sock_net(skb->sk);    struct nlattr *tca[TCA_MAX + 1];    spinlock_t *root_lock;    struct tcmsg *t;    u32 protocol;    u32 prio;    u32 nprio;    u32 parent;    struct net_device *dev;    struct Qdisc  *q;    struct tcf_proto **back, **chain;    struct tcf_proto *tp;    struct tcf_proto_ops *tp_ops;    const struct Qdisc_class_ops *cops;    unsigned long cl;    unsigned long fh;    int err;    if (net != &init_net)        return -EINVAL;replay:    t = NLMSG_DATA(n);    protocol = TC_H_MIN(t->tcm_info);    prio = TC_H_MAJ(t->tcm_info);    nprio = prio;    parent = t->tcm_parent;    cl = 0;    if (prio == 0) {        /* If no priority is given, user wants we allocated it. */        if (n->nlmsg_type != RTM_NEWTFILTER || !(n->nlmsg_flags&NLM_F_CREATE))            return -ENOENT;        prio = TC_H_MAKE(0x80000000U, 0U);    }    /* Find head of filter chain. */    /* Find link */    dev = __dev_get_by_index(&init_net, t->tcm_ifindex);    if (dev == NULL)        return -ENODEV;    err = nlmsg_parse(n, sizeof(*t), tca, TCA_MAX, NULL);    if (err < 0)        return err;    /* Find qdisc */    if (!parent) {        struct netdev_queue *dev_queue = netdev_get_tx_queue(dev, 0);        q = dev_queue->qdisc_sleeping;        parent = q->handle;    } else {        q = qdisc_lookup(dev, TC_H_MAJ(t->tcm_parent));        if (q == NULL)            return -EINVAL;    }    /* Is it classful? */    if ((cops = q->ops->cl_ops) == NULL)        return -EINVAL;    /* Do we search for filter, attached to class? */    if (TC_H_MIN(parent)) {        cl = cops->get(q, parent);        if (cl == 0)            return -ENOENT;    }    /* And the last stroke */    chain = cops->tcf_chain(q, cl);    err = -EINVAL;    if (chain == NULL)        goto errout;    /* Check the chain for existence of proto-tcf with this priority */    for (back = chain; (tp=*back) != NULL; back = &tp->next) {        if (tp->prio >= prio) {            if (tp->prio == prio) {                if (!nprio || (tp->protocol != protocol && protocol))                    goto errout;            } else                tp = NULL;            break;        }    }    root_lock = qdisc_root_sleeping_lock(q);    if (tp == NULL) {        /* Proto-tcf does not exist, create new one */        if (tca[TCA_KIND] == NULL || !protocol)            goto errout;        err = -ENOENT;        if (n->nlmsg_type != RTM_NEWTFILTER || !(n->nlmsg_flags&NLM_F_CREATE))            goto errout;//.........这里部分代码省略.........

/* Process one complete nfnetlink message. */static int nfnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh){	struct net *net = sock_net(skb->sk);	const struct nfnl_callback *nc;	const struct nfnetlink_subsystem *ss;	int type, err;	if (security_netlink_recv(skb, CAP_NET_ADMIN))		return -EPERM;	/* All the messages must at least contain nfgenmsg */	if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct nfgenmsg)))		return 0;	type = nlh->nlmsg_type;replay:	rcu_read_lock();	ss = nfnetlink_get_subsys(type);	if (!ss) {#ifdef CONFIG_MODULES		rcu_read_unlock();		request_module("nfnetlink-subsys-%d", NFNL_SUBSYS_ID(type));		rcu_read_lock();		ss = nfnetlink_get_subsys(type);		if (!ss)#endif		{			rcu_read_unlock();			return -EINVAL;		}	}	nc = nfnetlink_find_client(type, ss);	if (!nc) {		rcu_read_unlock();		return -EINVAL;	}	{		int min_len = NLMSG_SPACE(sizeof(struct nfgenmsg));		u_int8_t cb_id = NFNL_MSG_TYPE(nlh->nlmsg_type);		struct nlattr *cda[ss->cb[cb_id].attr_count + 1];		struct nlattr *attr = (void *)nlh + min_len;		int attrlen = nlh->nlmsg_len - min_len;		err = nla_parse(cda, ss->cb[cb_id].attr_count,				attr, attrlen, ss->cb[cb_id].policy);		if (err < 0)			return err;		if (nc->call_rcu) {			err = nc->call_rcu(net->nfnl, skb, nlh,					   (const struct nlattr **)cda);			rcu_read_unlock();		} else {			rcu_read_unlock();			nfnl_lock();			if (rcu_dereference_protected(					subsys_table[NFNL_SUBSYS_ID(type)],					lockdep_is_held(&nfnl_mutex)) != ss ||			    nfnetlink_find_client(type, ss) != nc)				err = -EAGAIN;			else				err = nc->call(net->nfnl, skb, nlh,						   (const struct nlattr **)cda);			nfnl_unlock();		}		if (err == -EAGAIN)			goto replay;		return err;	}}

static int accept(struct socket *sock, struct socket *new_sock, int flags){	struct sock *sk = sock->sk;	struct sk_buff *buf;	int res;	lock_sock(sk);	if (sock->state != SS_LISTENING) {		res = -EINVAL;		goto exit;	}	while (skb_queue_empty(&sk->sk_receive_queue)) {		if (flags & O_NONBLOCK) {			res = -EWOULDBLOCK;			goto exit;		}		release_sock(sk);		res = wait_event_interruptible(*sk_sleep(sk),				(!skb_queue_empty(&sk->sk_receive_queue)));		lock_sock(sk);		if (res)			goto exit;	}	buf = skb_peek(&sk->sk_receive_queue);	res = tipc_create(sock_net(sock->sk), new_sock, 0, 0);	if (!res) {		struct sock *new_sk = new_sock->sk;		struct tipc_sock *new_tsock = tipc_sk(new_sk);		struct tipc_port *new_tport = new_tsock->p;		u32 new_ref = new_tport->ref;		struct tipc_msg *msg = buf_msg(buf);		lock_sock(new_sk);		/*		 * Reject any stray messages received by new socket		 * before the socket lock was taken (very, very unlikely)		 */		reject_rx_queue(new_sk);		/* Connect new socket to it's peer */		new_tsock->peer_name.ref = msg_origport(msg);		new_tsock->peer_name.node = msg_orignode(msg);		tipc_connect2port(new_ref, &new_tsock->peer_name);		new_sock->state = SS_CONNECTED;		tipc_set_portimportance(new_ref, msg_importance(msg));		if (msg_named(msg)) {			new_tport->conn_type = msg_nametype(msg);			new_tport->conn_instance = msg_nameinst(msg);		}		/*		 * Respond to 'SYN-' by discarding it & returning 'ACK'-.		 * Respond to 'SYN+' by queuing it on new socket.		 */		if (!msg_data_sz(msg)) {			struct msghdr m = {NULL,};			advance_rx_queue(sk);			send_packet(NULL, new_sock, &m, 0);		} else {			__skb_dequeue(&sk->sk_receive_queue);			__skb_queue_head(&new_sk->sk_receive_queue, buf);		}		release_sock(new_sk);	}exit:	release_sock(sk);	return res;}

int pfq_setsockopt(struct socket *sock,                int level, int optname,                char __user * optval,#if(LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31))                unsigned#endif                int optlen){        struct pfq_sock *so = pfq_sk(sock->sk);        bool found = true;        if (so == NULL)                return -EINVAL;        switch(optname)        {        case Q_SO_ENABLE:	{		unsigned long addr;		int err = 0;                if (optlen != sizeof(addr))                        return -EINVAL;                if (copy_from_user(&addr, optval, optlen))                        return -EFAULT;                err = pfq_shared_queue_enable(so, addr);                if (err < 0) {                        printk(KERN_INFO "[PFQ|%d] enable error!/n", so->id);                        return err;                }		return 0;	} break;	case Q_SO_DISABLE:	{		int err = 0;		pfq_sock_tx_unbind(so);		msleep(Q_GRACE_PERIOD);                err = pfq_shared_queue_disable(so);                if (err < 0) {                        printk(KERN_INFO "[PFQ|%d] disable error!/n", so->id);                        return err;                }	} break;        case Q_SO_GROUP_BIND:        {                struct pfq_binding bind;		pfq_gid_t gid;                if (optlen != sizeof(struct pfq_binding))                        return -EINVAL;                if (copy_from_user(&bind, optval, optlen))                        return -EFAULT;		gid = (__force pfq_gid_t)bind.gid;                if (!pfq_has_joined_group(gid, so->id)) {                        printk(KERN_INFO "[PFQ|%d] add bind: gid=%d not joined!/n", so->id, bind.gid);			return -EACCES;		}                if (!dev_get_by_index(sock_net(&so->sk), bind.ifindex)) {                        printk(KERN_INFO "[PFQ|%d] bind: invalid ifindex=%d!/n", so->id, bind.ifindex);                        return -EACCES;                }                pfq_devmap_update(map_set, bind.ifindex, bind.qindex, gid);                pr_devel("[PFQ|%d] group id=%d bind: device ifindex=%d qindex=%d/n",					so->id, bind.gid, bind.ifindex, bind.qindex);        } break;        case Q_SO_GROUP_UNBIND:        {                struct pfq_binding bind;		pfq_gid_t gid;                if (optlen != sizeof(struct pfq_binding))                        return -EINVAL;                if (copy_from_user(&bind, optval, optlen))                        return -EFAULT;		gid = (__force pfq_gid_t)bind.gid;		if (!pfq_has_joined_group(gid, so->id)) {                        printk(KERN_INFO "[PFQ|%d] group id=%d unbind: gid=%d not joined!/n", so->id, gid, bind.gid);			return -EACCES;//.........这里部分代码省略.........

/* Create a new IPv4 subflow. * * We are in user-context and meta-sock-lock is hold. */int mptcp_init4_subsockets(struct sock *meta_sk, const struct mptcp_loc4 *loc,			   struct mptcp_rem4 *rem){	struct tcp_sock *tp;	struct sock *sk;	struct sockaddr_in loc_in, rem_in;	struct socket_alloc sock_full;	struct socket *sock = (struct socket *)&sock_full;	int ret;	/** First, create and prepare the new socket */	memcpy(&sock_full, meta_sk->sk_socket, sizeof(sock_full));	sock->state = SS_UNCONNECTED;	sock->ops = NULL;	ret = inet_create(sock_net(meta_sk), sock, IPPROTO_TCP, 1);	if (unlikely(ret < 0)) {		net_err_ratelimited("%s inet_create failed ret: %d/n",				    __func__, ret);		return ret;	}	sk = sock->sk;	tp = tcp_sk(sk);	/* All subsockets need the MPTCP-lock-class */	lockdep_set_class_and_name(&(sk)->sk_lock.slock, &meta_slock_key, meta_slock_key_name);	lockdep_init_map(&(sk)->sk_lock.dep_map, meta_key_name, &meta_key, 0);	ret = mptcp_add_sock(meta_sk, sk, loc->loc4_id, rem->rem4_id, GFP_KERNEL);	if (ret) {		net_err_ratelimited("%s mptcp_add_sock failed ret: %d/n",				    __func__, ret);		goto error;	}	tp->mptcp->slave_sk = 1;	/* Initializing the timer for an MPTCP subflow */	timer_setup(&tp->mptcp->mptcp_ack_timer, mptcp_ack_handler, 0);	/** Then, connect the socket to the peer */	loc_in.sin_family = AF_INET;	rem_in.sin_family = AF_INET;	loc_in.sin_port = 0;	if (rem->port)		rem_in.sin_port = rem->port;	else		rem_in.sin_port = inet_sk(meta_sk)->inet_dport;	loc_in.sin_addr = loc->addr;	rem_in.sin_addr = rem->addr;	if (loc->if_idx)		sk->sk_bound_dev_if = loc->if_idx;	ret = kernel_bind(sock, (struct sockaddr *)&loc_in,			  sizeof(struct sockaddr_in));	if (ret < 0) {		net_err_ratelimited("%s: token %#x bind() to %pI4 index %d failed, error %d/n",				    __func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,				    &loc_in.sin_addr, loc->if_idx, ret);		goto error;	}	mptcp_debug("%s: token %#x pi %d src_addr:%pI4:%d dst_addr:%pI4:%d ifidx: %d/n",		    __func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,		    tp->mptcp->path_index, &loc_in.sin_addr,		    ntohs(loc_in.sin_port), &rem_in.sin_addr,		    ntohs(rem_in.sin_port), loc->if_idx);	ret = kernel_connect(sock, (struct sockaddr *)&rem_in,			     sizeof(struct sockaddr_in), O_NONBLOCK);	if (ret < 0 && ret != -EINPROGRESS) {		net_err_ratelimited("%s: MPTCP subsocket connect() failed, error %d/n",				    __func__, ret);		goto error;	}	MPTCP_INC_STATS(sock_net(meta_sk), MPTCP_MIB_JOINSYNTX);	sk_set_socket(sk, meta_sk->sk_socket);	sk->sk_wq = meta_sk->sk_wq;	return 0;error:	/* May happen if mptcp_add_sock fails first */	if (!mptcp(tp)) {		tcp_close(sk, 0);	} else {		local_bh_disable();		mptcp_sub_force_close(sk);		local_bh_enable();	}	return ret;}

static int do_ip_setsockopt(struct sock *sk, int level,			    int optname, char __user *optval, unsigned int optlen){	struct inet_sock *inet = inet_sk(sk);	int val = 0, err;	switch (optname) {	case IP_PKTINFO:	case IP_RECVTTL:	case IP_RECVOPTS:	case IP_RECVTOS:	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_MULTICAST_TTL:	case IP_MULTICAST_ALL:	case IP_MULTICAST_LOOP:	case IP_RECVORIGDSTADDR:		if (optlen >= sizeof(int)) {			if (get_user(val, (int __user *) optval))				return -EFAULT;		} else if (optlen >= sizeof(char)) {			unsigned char ucval;			if (get_user(ucval, (unsigned char __user *) optval))				return -EFAULT;			val = (int) ucval;		}	}	/* If optlen==0, it is equivalent to val == 0 */	if (ip_mroute_opt(optname))		return ip_mroute_setsockopt(sk, optname, optval, optlen);	err = 0;	lock_sock(sk);	switch (optname) {	case IP_OPTIONS:	{		struct ip_options_rcu *old, *opt = NULL;		if (optlen > 40)			goto e_inval;		err = ip_options_get_from_user(sock_net(sk), &opt,					       optval, optlen);		if (err)			break;		old = rcu_dereference_protected(inet->inet_opt,						sock_owned_by_user(sk));		if (inet->is_icsk) {			struct inet_connection_sock *icsk = inet_csk(sk);#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)			if (sk->sk_family == PF_INET ||			    (!((1 << sk->sk_state) &			       (TCPF_LISTEN | TCPF_CLOSE)) &&			     inet->inet_daddr != LOOPBACK4_IPV6)) {#endif				if (old)					icsk->icsk_ext_hdr_len -= old->opt.optlen;				if (opt)					icsk->icsk_ext_hdr_len += opt->opt.optlen;				icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)			}#endif		}		rcu_assign_pointer(inet->inet_opt, opt);		if (old)			call_rcu(&old->rcu, opt_kfree_rcu);		break;	}	case IP_PKTINFO:		if (val)			inet->cmsg_flags |= IP_CMSG_PKTINFO;		else			inet->cmsg_flags &= ~IP_CMSG_PKTINFO;		break;	case IP_RECVTTL:		if (val)			inet->cmsg_flags |=  IP_CMSG_TTL;		else			inet->cmsg_flags &= ~IP_CMSG_TTL;		break;	case IP_RECVTOS:		if (val)			inet->cmsg_flags |=  IP_CMSG_TOS;		else			inet->cmsg_flags &= ~IP_CMSG_TOS;		break;//.........这里部分代码省略.........

/* Similar to: tcp_v4_do_rcv * We only process join requests here. (either the SYN or the final ACK) */int mptcp_v4_do_rcv(struct sock *meta_sk, struct sk_buff *skb){	const struct tcphdr *th = tcp_hdr(skb);	const struct iphdr *iph = ip_hdr(skb);	struct sock *child, *rsk = NULL, *sk;	int ret;	sk = inet_lookup_established(sock_net(meta_sk), &tcp_hashinfo,				     iph->saddr, th->source, iph->daddr,				     th->dest, inet_iif(skb));	if (!sk)		goto new_subflow;	if (is_meta_sk(sk)) {		WARN("%s Did not find a sub-sk - did found the meta!/n", __func__);		sock_put(sk);		goto discard;	}	if (sk->sk_state == TCP_TIME_WAIT) {		inet_twsk_put(inet_twsk(sk));		goto discard;	}	if (sk->sk_state == TCP_NEW_SYN_RECV) {		struct request_sock *req = inet_reqsk(sk);		bool req_stolen;		if (!mptcp_can_new_subflow(meta_sk))			goto reset_and_discard;		local_bh_disable();		child = tcp_check_req(meta_sk, skb, req, false, &req_stolen);		if (!child) {			reqsk_put(req);			local_bh_enable();			goto discard;		}		if (child != meta_sk) {			ret = mptcp_finish_handshake(child, skb);			if (ret) {				rsk = child;				local_bh_enable();				goto reset_and_discard;			}			local_bh_enable();			return 0;		}		/* tcp_check_req failed */		reqsk_put(req);		local_bh_enable();		goto discard;	}	ret = tcp_v4_do_rcv(sk, skb);	sock_put(sk);	return ret;new_subflow:	if (!mptcp_can_new_subflow(meta_sk))		goto reset_and_discard;	child = tcp_v4_cookie_check(meta_sk, skb);	if (!child)		goto discard;	if (child != meta_sk) {		ret = mptcp_finish_handshake(child, skb);		if (ret) {			rsk = child;			goto reset_and_discard;		}	}	if (tcp_hdr(skb)->syn) {		local_bh_disable();		mptcp_v4_join_request(meta_sk, skb);		local_bh_enable();	}discard:	kfree_skb(skb);	return 0;reset_and_discard:	tcp_v4_send_reset(rsk, skb);	goto discard;}

static struct sock *pep_sock_accept(struct sock *sk, int flags, int *errp){	struct pep_sock *pn = pep_sk(sk), *newpn;	struct sock *newsk = NULL;	struct sk_buff *skb;	struct pnpipehdr *hdr;	struct sockaddr_pn dst, src;	int err;	u16 peer_type;	u8 pipe_handle, enabled, n_sb;	u8 aligned = 0;	skb = skb_recv_datagram(sk, 0, flags & O_NONBLOCK, errp);	if (!skb)		return NULL;	lock_sock(sk);	if (sk->sk_state != TCP_LISTEN) {		err = -EINVAL;		goto drop;	}	sk_acceptq_removed(sk);	err = -EPROTO;	if (!pskb_may_pull(skb, sizeof(*hdr) + 4))		goto drop;	hdr = pnp_hdr(skb);	pipe_handle = hdr->pipe_handle;	switch (hdr->state_after_connect) {	case PN_PIPE_DISABLE:		enabled = 0;		break;	case PN_PIPE_ENABLE:		enabled = 1;		break;	default:		pep_reject_conn(sk, skb, PN_PIPE_ERR_INVALID_PARAM,				GFP_KERNEL);		goto drop;	}	peer_type = hdr->other_pep_type << 8;	/* Parse sub-blocks (options) */	n_sb = hdr->data[4];	while (n_sb > 0) {		u8 type, buf[1], len = sizeof(buf);		const u8 *data = pep_get_sb(skb, &type, &len, buf);		if (data == NULL)			goto drop;		switch (type) {		case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE:			if (len < 1)				goto drop;			peer_type = (peer_type & 0xff00) | data[0];			break;		case PN_PIPE_SB_ALIGNED_DATA:			aligned = data[0] != 0;			break;		}		n_sb--;	}	/* Check for duplicate pipe handle */	newsk = pep_find_pipe(&pn->hlist, &dst, pipe_handle);	if (unlikely(newsk)) {		__sock_put(newsk);		newsk = NULL;		pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE, GFP_KERNEL);		goto drop;	}	/* Create a new to-be-accepted sock */	newsk = sk_alloc(sock_net(sk), PF_PHONET, GFP_KERNEL, sk->sk_prot, 0);	if (!newsk) {		pep_reject_conn(sk, skb, PN_PIPE_ERR_OVERLOAD, GFP_KERNEL);		err = -ENOBUFS;		goto drop;	}	sock_init_data(NULL, newsk);	newsk->sk_state = TCP_SYN_RECV;	newsk->sk_backlog_rcv = pipe_do_rcv;	newsk->sk_protocol = sk->sk_protocol;	newsk->sk_destruct = pipe_destruct;	newpn = pep_sk(newsk);	pn_skb_get_dst_sockaddr(skb, &dst);	pn_skb_get_src_sockaddr(skb, &src);	newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);	newpn->pn_sk.dobject = pn_sockaddr_get_object(&src);	newpn->pn_sk.resource = pn_sockaddr_get_resource(&dst);	sock_hold(sk);	newpn->listener = sk;	skb_queue_head_init(&newpn->ctrlreq_queue);	newpn->pipe_handle = pipe_handle;	atomic_set(&newpn->tx_credits, 0);	newpn->ifindex = 0;	newpn->peer_type = peer_type;//.........这里部分代码省略.........

static int ip6_dst_lookup_tail(struct sock *sk,			       struct dst_entry **dst, struct flowi *fl){	int err;	struct net *net = sock_net(sk);	if (*dst == NULL)		*dst = ip6_route_output(net, sk, fl);	if ((err = (*dst)->error))		goto out_err_release;	if (ipv6_addr_any(&fl->fl6_src)) {		err = ipv6_dev_get_saddr(net, ip6_dst_idev(*dst)->dev,					 &fl->fl6_dst,					 sk ? inet6_sk(sk)->srcprefs : 0,					 &fl->fl6_src);		if (err)			goto out_err_release;	}#ifdef CONFIG_IPV6_OPTIMISTIC_DAD	/*	 * Here if the dst entry we've looked up	 * has a neighbour entry that is in the INCOMPLETE	 * state and the src address from the flow is	 * marked as OPTIMISTIC, we release the found	 * dst entry and replace it instead with the	 * dst entry of the nexthop router	 */	if ((*dst)->neighbour && !((*dst)->neighbour->nud_state & NUD_VALID)) {		struct inet6_ifaddr *ifp;		struct flowi fl_gw;		int redirect;		ifp = ipv6_get_ifaddr(net, &fl->fl6_src,				      (*dst)->dev, 1);		redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);		if (ifp)			in6_ifa_put(ifp);		if (redirect) {			/*			 * We need to get the dst entry for the			 * default router instead			 */			dst_release(*dst);			memcpy(&fl_gw, fl, sizeof(struct flowi));			memset(&fl_gw.fl6_dst, 0, sizeof(struct in6_addr));			*dst = ip6_route_output(net, sk, &fl_gw);			if ((err = (*dst)->error))				goto out_err_release;		}	}#endif	return 0;out_err_release:	if (err == -ENETUNREACH)		IP6_INC_STATS_BH(NULL, IPSTATS_MIB_OUTNOROUTES);	dst_release(*dst);	*dst = NULL;	return err;}

int ipv6_flowlabel_opt(struct sock *sk, char __user *optval, int optlen){	int uninitialized_var(err);	struct net *net = sock_net(sk);	struct ipv6_pinfo *np = inet6_sk(sk);	struct in6_flowlabel_req freq;	struct ipv6_fl_socklist *sfl1=NULL;	struct ipv6_fl_socklist *sfl, **sflp;	struct ip6_flowlabel *fl, *fl1 = NULL;	if (optlen < sizeof(freq))		return -EINVAL;	if (copy_from_user(&freq, optval, sizeof(freq)))		return -EFAULT;	switch (freq.flr_action) {	case IPV6_FL_A_PUT:		write_lock_bh(&ip6_sk_fl_lock);		for (sflp = &np->ipv6_fl_list; (sfl=*sflp)!=NULL; sflp = &sfl->next) {			if (sfl->fl->label == freq.flr_label) {				if (freq.flr_label == (np->flow_label&IPV6_FLOWLABEL_MASK))					np->flow_label &= ~IPV6_FLOWLABEL_MASK;				*sflp = sfl->next;				write_unlock_bh(&ip6_sk_fl_lock);				fl_release(sfl->fl);				kfree(sfl);				return 0;			}		}		write_unlock_bh(&ip6_sk_fl_lock);		return -ESRCH;	case IPV6_FL_A_RENEW:		read_lock_bh(&ip6_sk_fl_lock);		for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {			if (sfl->fl->label == freq.flr_label) {				err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires);				read_unlock_bh(&ip6_sk_fl_lock);				return err;			}		}		read_unlock_bh(&ip6_sk_fl_lock);		if (freq.flr_share == IPV6_FL_S_NONE && capable(CAP_NET_ADMIN)) {			fl = fl_lookup(net, freq.flr_label);			if (fl) {				err = fl6_renew(fl, freq.flr_linger, freq.flr_expires);				fl_release(fl);				return err;			}		}		return -ESRCH;	case IPV6_FL_A_GET:		if (freq.flr_label & ~IPV6_FLOWLABEL_MASK)			return -EINVAL;		fl = fl_create(net, sk, &freq, optval, optlen, &err);		if (fl == NULL)			return err;		sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL);		if (freq.flr_label) {			err = -EEXIST;			read_lock_bh(&ip6_sk_fl_lock);			for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) {				if (sfl->fl->label == freq.flr_label) {					if (freq.flr_flags&IPV6_FL_F_EXCL) {						read_unlock_bh(&ip6_sk_fl_lock);						goto done;					}					fl1 = sfl->fl;					atomic_inc(&fl1->users);					break;				}			}			read_unlock_bh(&ip6_sk_fl_lock);			if (fl1 == NULL)				fl1 = fl_lookup(net, freq.flr_label);			if (fl1) {recheck:				err = -EEXIST;				if (freq.flr_flags&IPV6_FL_F_EXCL)					goto release;				err = -EPERM;				if (fl1->share == IPV6_FL_S_EXCL ||				    fl1->share != fl->share ||				    fl1->owner != fl->owner)					goto release;				err = -EINVAL;				if (!ipv6_addr_equal(&fl1->dst, &fl->dst) ||				    ipv6_opt_cmp(fl1->opt, fl->opt))					goto release;				err = -ENOMEM;				if (sfl1 == NULL)//.........这里部分代码省略.........

//.........这里部分代码省略.........		if (copy_to_user(optval, &mtuinfo, len))			return -EFAULT;		return 0;	}	case IPV6_TRANSPARENT:		val = inet_sk(sk)->transparent;		break;	case IPV6_RECVORIGDSTADDR:		val = np->rxopt.bits.rxorigdstaddr;		break;	case IPV6_UNICAST_HOPS:	case IPV6_MULTICAST_HOPS:	{		struct dst_entry *dst;		if (optname == IPV6_UNICAST_HOPS)			val = np->hop_limit;		else			val = np->mcast_hops;		if (val < 0) {			rcu_read_lock();			dst = __sk_dst_get(sk);			if (dst)				val = ip6_dst_hoplimit(dst);			rcu_read_unlock();		}		if (val < 0)			val = sock_net(sk)->ipv6.devconf_all->hop_limit;		break;	}	case IPV6_MULTICAST_LOOP:		val = np->mc_loop;		break;	case IPV6_MULTICAST_IF:		val = np->mcast_oif;		break;	case IPV6_UNICAST_IF:		val = (__force int)htonl((__u32) np->ucast_oif);		break;	case IPV6_MTU_DISCOVER:		val = np->pmtudisc;		break;	case IPV6_RECVERR:		val = np->recverr;		break;	case IPV6_FLOWINFO_SEND:		val = np->sndflow;		break;	case IPV6_FLOWLABEL_MGR:	{		struct in6_flowlabel_req freq;		int flags;

static struct sock *dccp_v6_request_recv_sock(struct sock *sk,					      struct sk_buff *skb,					      struct request_sock *req,					      struct dst_entry *dst){	struct inet6_request_sock *ireq6 = inet6_rsk(req);	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);	struct inet_sock *newinet;	struct dccp_sock *newdp;	struct dccp6_sock *newdp6;	struct sock *newsk;	struct ipv6_txoptions *opt;	if (skb->protocol == htons(ETH_P_IP)) {		/*		 *	v6 mapped		 */		newsk = dccp_v4_request_recv_sock(sk, skb, req, dst);		if (newsk == NULL)			return NULL;		newdp6 = (struct dccp6_sock *)newsk;		newdp = dccp_sk(newsk);		newinet = inet_sk(newsk);		newinet->pinet6 = &newdp6->inet6;		newnp = inet6_sk(newsk);		memcpy(newnp, np, sizeof(struct ipv6_pinfo));		ipv6_addr_set_v4mapped(newinet->inet_daddr, &newnp->daddr);		ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);		ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);		inet_csk(newsk)->icsk_af_ops = &dccp_ipv6_mapped;		newsk->sk_backlog_rcv = dccp_v4_do_rcv;		newnp->pktoptions  = NULL;		newnp->opt	   = NULL;		newnp->mcast_oif   = inet6_iif(skb);		newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;		/*		 * 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		 */		/* It is tricky place. Until this moment IPv4 tcp		   worked with IPv6 icsk.icsk_af_ops.		   Sync it now.		 */		dccp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);		return newsk;	}	opt = np->opt;	if (sk_acceptq_is_full(sk))		goto out_overflow;	if (dst == NULL) {		struct in6_addr *final_p, final;		struct flowi fl;		memset(&fl, 0, sizeof(fl));		fl.proto = IPPROTO_DCCP;		ipv6_addr_copy(&fl.fl6_dst, &ireq6->rmt_addr);		final_p = fl6_update_dst(&fl, opt, &final);		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;//.........这里部分代码省略.........

//.........这里部分代码省略.........				  sizeof(user_icmph));	if (err)		return err;	if (msg->msg_name) {		struct sockaddr_in6 *u = (struct sockaddr_in6 *) msg->msg_name;		if (msg->msg_namelen < sizeof(struct sockaddr_in6) ||		    u->sin6_family != AF_INET6) {			return -EINVAL;		}		if (sk->sk_bound_dev_if &&		    sk->sk_bound_dev_if != u->sin6_scope_id) {			return -EINVAL;		}		daddr = &(u->sin6_addr);		iif = u->sin6_scope_id;	} else {		if (sk->sk_state != TCP_ESTABLISHED)			return -EDESTADDRREQ;		daddr = &np->daddr;	}	if (!iif)		iif = sk->sk_bound_dev_if;	addr_type = ipv6_addr_type(daddr);	if (__ipv6_addr_needs_scope_id(addr_type) && !iif)		return -EINVAL;	if (addr_type & IPV6_ADDR_MAPPED)		return -EINVAL;	/* TODO: use ip6_datagram_send_ctl to get options from cmsg */	memset(&fl6, 0, sizeof(fl6));	fl6.flowi6_proto = IPPROTO_ICMPV6;	fl6.saddr = np->saddr;	fl6.daddr = *daddr;	fl6.fl6_icmp_type = user_icmph.icmp6_type;	fl6.fl6_icmp_code = user_icmph.icmp6_code;	fl6.flowi6_uid = sock_i_uid(sk);	security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))		fl6.flowi6_oif = np->mcast_oif;	else if (!fl6.flowi6_oif)		fl6.flowi6_oif = np->ucast_oif;	dst = ip6_sk_dst_lookup_flow(sk, &fl6,  daddr, 1);	if (IS_ERR(dst))		return PTR_ERR(dst);	rt = (struct rt6_info *) dst;	np = inet6_sk(sk);	if (!np)		return -EBADF;	if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))		fl6.flowi6_oif = np->mcast_oif;	else if (!fl6.flowi6_oif)		fl6.flowi6_oif = np->ucast_oif;	pfh.icmph.type = user_icmph.icmp6_type;	pfh.icmph.code = user_icmph.icmp6_code;	pfh.icmph.checksum = 0;	pfh.icmph.un.echo.id = inet->inet_sport;	pfh.icmph.un.echo.sequence = user_icmph.icmp6_sequence;	pfh.iov = msg->msg_iov;	pfh.wcheck = 0;	pfh.family = AF_INET6;	if (ipv6_addr_is_multicast(&fl6.daddr))		hlimit = np->mcast_hops;	else		hlimit = np->hop_limit;	if (hlimit < 0)		hlimit = ip6_dst_hoplimit(dst);	lock_sock(sk);	err = ip6_append_data(sk, ping_getfrag, &pfh, len,			      0, hlimit,			      np->tclass, NULL, &fl6, rt,			      MSG_DONTWAIT, np->dontfrag);	if (err) {		ICMP6_INC_STATS_BH(sock_net(sk), rt->rt6i_idev,				   ICMP6_MIB_OUTERRORS);		ip6_flush_pending_frames(sk);	} else {		err = icmpv6_push_pending_frames(sk, &fl6,						 (struct icmp6hdr *) &pfh.icmph,						 len);	}	release_sock(sk);	if (err)		return err;	return len;}

//.........这里部分代码省略.........	 * DCCP over IPv4	 */	if (addr_type == IPV6_ADDR_MAPPED) {		u32 exthdrlen = icsk->icsk_ext_hdr_len;		struct sockaddr_in sin;		SOCK_DEBUG(sk, "connect: ipv4 mapped/n");		if (__ipv6_only_sock(sk))			return -ENETUNREACH;		sin.sin_family = AF_INET;		sin.sin_port = usin->sin6_port;		sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];		icsk->icsk_af_ops = &dccp_ipv6_mapped;		sk->sk_backlog_rcv = dccp_v4_do_rcv;		err = dccp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));		if (err) {			icsk->icsk_ext_hdr_len = exthdrlen;			icsk->icsk_af_ops = &dccp_ipv6_af_ops;			sk->sk_backlog_rcv = dccp_v6_do_rcv;			goto failure;		}		ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);		ipv6_addr_set_v4mapped(inet->inet_rcv_saddr, &np->rcv_saddr);		return err;	}	if (!ipv6_addr_any(&np->rcv_saddr))		saddr = &np->rcv_saddr;	fl.proto = IPPROTO_DCCP;	ipv6_addr_copy(&fl.fl6_dst, &np->daddr);	ipv6_addr_copy(&fl.fl6_src, saddr ? saddr : &np->saddr);	fl.oif = sk->sk_bound_dev_if;	fl.fl_ip_dport = usin->sin6_port;	fl.fl_ip_sport = inet->inet_sport;	security_sk_classify_flow(sk, &fl);	final_p = fl6_update_dst(&fl, np->opt, &final);	err = ip6_dst_lookup(sk, &dst, &fl);	if (err)		goto failure;	if (final_p)		ipv6_addr_copy(&fl.fl6_dst, final_p);	err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);	if (err < 0) {		if (err == -EREMOTE)			err = ip6_dst_blackhole(sk, &dst, &fl);		if (err < 0)			goto failure;	}	if (saddr == NULL) {		saddr = &fl.fl6_src;		ipv6_addr_copy(&np->rcv_saddr, saddr);	}	/* set the source address */	ipv6_addr_copy(&np->saddr, saddr);	inet->inet_rcv_saddr = LOOPBACK4_IPV6;	__ip6_dst_store(sk, dst, NULL, NULL);	icsk->icsk_ext_hdr_len = 0;	if (np->opt != NULL)		icsk->icsk_ext_hdr_len = (np->opt->opt_flen +					  np->opt->opt_nflen);	inet->inet_dport = usin->sin6_port;	dccp_set_state(sk, DCCP_REQUESTING);	err = inet6_hash_connect(&dccp_death_row, sk);	if (err)		goto late_failure;	dp->dccps_iss = secure_dccpv6_sequence_number(np->saddr.s6_addr32,						      np->daddr.s6_addr32,						      inet->inet_sport,						      inet->inet_dport);	err = dccp_connect(sk);	if (err)		goto late_failure;	return 0;late_failure:	dccp_set_state(sk, DCCP_CLOSED);	__sk_dst_reset(sk);failure:	inet->inet_dport = 0;	sk->sk_route_caps = 0;	return err;}

static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,		       size_t len){	struct inet_sock *inet = inet_sk(sk);	struct ipcm_cookie ipc;	struct rtable *rt = NULL;	int free = 0;	__be32 daddr;	__be32 saddr;	u8  tos;	int err;	err = -EMSGSIZE;	if (len > 0xFFFF)		goto out;	/*	 *	Check the flags.	 */	err = -EOPNOTSUPP;	if (msg->msg_flags & MSG_OOB)	/* Mirror BSD error message */		goto out;               /* compatibility */	/*	 *	Get and verify the address.	 */	if (msg->msg_namelen) {		struct sockaddr_in *usin = (struct sockaddr_in *)msg->msg_name;		err = -EINVAL;		if (msg->msg_namelen < sizeof(*usin))			goto out;		if (usin->sin_family != AF_INET) {			static int complained;			if (!complained++)				printk(KERN_INFO "%s forgot to set AF_INET in "						 "raw sendmsg. Fix it!/n",						 current->comm);			err = -EAFNOSUPPORT;			if (usin->sin_family)				goto out;		}		daddr = usin->sin_addr.s_addr;		/* ANK: I did not forget to get protocol from port field.		 * I just do not know, who uses this weirdness.		 * IP_HDRINCL is much more convenient.		 */	} else {		err = -EDESTADDRREQ;		if (sk->sk_state != TCP_ESTABLISHED)			goto out;		daddr = inet->inet_daddr;	}	ipc.addr = inet->inet_saddr;	ipc.opt = NULL;	ipc.shtx.flags = 0;	ipc.oif = sk->sk_bound_dev_if;	if (msg->msg_controllen) {		err = ip_cmsg_send(sock_net(sk), msg, &ipc);		if (err)			goto out;		if (ipc.opt)			free = 1;	}	saddr = ipc.addr;	ipc.addr = daddr;	if (!ipc.opt)		ipc.opt = inet->opt;	if (ipc.opt) {		err = -EINVAL;		/* Linux does not mangle headers on raw sockets,		 * so that IP options + IP_HDRINCL is non-sense.		 */		if (inet->hdrincl)			goto done;		if (ipc.opt->srr) {			if (!daddr)				goto done;			daddr = ipc.opt->faddr;		}	}	tos = RT_CONN_FLAGS(sk);	if (msg->msg_flags & MSG_DONTROUTE)		tos |= RTO_ONLINK;	if (ipv4_is_multicast(daddr)) {		if (!ipc.oif)			ipc.oif = inet->mc_index;		if (!saddr)			saddr = inet->mc_addr;	}	{		struct flowi fl = { .oif = ipc.oif,//.........这里部分代码省略.........

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;	struct net *net = sock_net(sk);	int	ishost = !net->ipv6.devconf_all->forwarding;	int	err = 0;	if (!capable(CAP_NET_ADMIN))		return -EPERM;	if (ipv6_addr_is_multicast(addr))		return -EINVAL;	if (ipv6_chk_addr(net, 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(net, 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(net, IFF_UP, IFF_UP|IFF_LOOPBACK);		}	} else		dev = dev_get_by_index(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 (!ipv6_chk_prefix(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;}

//.........这里部分代码省略.........		return newsk;	}	if (sk_acceptq_is_full(sk))		goto out_overflow;	if (!dst) {		struct flowi6 fl6;		dst = inet6_csk_route_req(sk, &fl6, req, IPPROTO_DCCP);		if (!dst)			goto out;	}	newsk = dccp_create_openreq_child(sk, req, skb);	if (newsk == NULL)		goto out_nonewsk;	/*	 * 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;	newnp = inet6_sk(newsk);	memcpy(newnp, np, sizeof(struct ipv6_pinfo));	newsk->sk_v6_daddr	= ireq->ir_v6_rmt_addr;	newnp->saddr		= ireq->ir_v6_loc_addr;	newsk->sk_v6_rcv_saddr	= ireq->ir_v6_loc_addr;	newsk->sk_bound_dev_if	= ireq->ir_iif;	/* Now IPv6 options...	   First: no IPv4 options.	 */	newinet->inet_opt = NULL;	/* Clone RX bits */	newnp->rxopt.all = np->rxopt.all;	newnp->pktoptions = NULL;	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.	 */	opt = rcu_dereference(np->opt);	if (opt) {		opt = ipv6_dup_options(newsk, opt);		RCU_INIT_POINTER(newnp->opt, opt);	}	inet_csk(newsk)->icsk_ext_hdr_len = 0;	if (opt)		inet_csk(newsk)->icsk_ext_hdr_len = opt->opt_nflen +						    opt->opt_flen;	dccp_sync_mss(newsk, dst_mtu(dst));	newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;	newinet->inet_rcv_saddr = LOOPBACK4_IPV6;	if (__inet_inherit_port(sk, newsk) < 0) {		inet_csk_prepare_forced_close(newsk);		dccp_done(newsk);		goto out;	}	*own_req = inet_ehash_nolisten(newsk, req_to_sk(req_unhash));	/* Clone pktoptions received with SYN, if we own the req */	if (*own_req && ireq->pktopts) {		newnp->pktoptions = skb_clone(ireq->pktopts, GFP_ATOMIC);		consume_skb(ireq->pktopts);		ireq->pktopts = NULL;		if (newnp->pktoptions)			skb_set_owner_r(newnp->pktoptions, newsk);	}	return newsk;out_overflow:	__NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);out_nonewsk:	dst_release(dst);out:	__NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENDROPS);	return NULL;}

//.........这里部分代码省略.........			/*			 *	Find where to start putting bytes			 */			data = skb_put(skb, fraglen);			skb_set_network_header(skb, exthdrlen);			data += fragheaderlen;			skb->transport_header = (skb->network_header +						 fragheaderlen);			if (fraggap) {				skb->csum = skb_copy_and_csum_bits(					skb_prev, maxfraglen,					data + transhdrlen, fraggap, 0);				skb_prev->csum = csum_sub(skb_prev->csum,							  skb->csum);				data += fraggap;				pskb_trim_unique(skb_prev, maxfraglen);			}			copy = datalen - transhdrlen - fraggap;			if (copy < 0) {				err = -EINVAL;				kfree_skb(skb);				goto error;			} else if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {				err = -EFAULT;				kfree_skb(skb);				goto error;			}			offset += copy;			length -= datalen - fraggap;			transhdrlen = 0;			exthdrlen = 0;			dst_exthdrlen = 0;			/*			 * Put the packet on the pending queue			 */			__skb_queue_tail(&sk->sk_write_queue, skb);			continue;		}		if (copy > length)			copy = length;		if (!(rt->dst.dev->features&NETIF_F_SG)) {			unsigned int off;			off = skb->len;			if (getfrag(from, skb_put(skb, copy),						offset, copy, off, skb) < 0) {				__skb_trim(skb, off);				err = -EFAULT;				goto error;			}		} else {			int i = skb_shinfo(skb)->nr_frags;			struct page_frag *pfrag = sk_page_frag(sk);			err = -ENOMEM;			if (!sk_page_frag_refill(sk, pfrag))				goto error;			if (!skb_can_coalesce(skb, i, pfrag->page,					      pfrag->offset)) {				err = -EMSGSIZE;				if (i == MAX_SKB_FRAGS)					goto error;				__skb_fill_page_desc(skb, i, pfrag->page,						     pfrag->offset, 0);				skb_shinfo(skb)->nr_frags = ++i;				get_page(pfrag->page);			}			copy = min_t(int, copy, pfrag->size - pfrag->offset);			if (getfrag(from,				    page_address(pfrag->page) + pfrag->offset,				    offset, copy, skb->len, skb) < 0)				goto error_efault;			pfrag->offset += copy;			skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);			skb->len += copy;			skb->data_len += copy;			skb->truesize += copy;			atomic_add(copy, &sk->sk_wmem_alloc);		}		offset += copy;		length -= copy;	}	return 0;error_efault:	err = -EFAULT;error:	cork->length -= length;	IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);	return err;}

static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,		    char __user *optval, 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;			/*//.........这里部分代码省略.........

int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,	     struct ipv6_txoptions *opt, int tclass){	struct net *net = sock_net(sk);	struct ipv6_pinfo *np = inet6_sk(sk);	struct in6_addr *first_hop = &fl6->daddr;	struct dst_entry *dst = skb_dst(skb);	struct ipv6hdr *hdr;	u8  proto = fl6->flowi6_proto;	int seg_len = skb->len;	int hlimit = -1;	u32 mtu;	if (opt) {		unsigned int head_room;		/* First: exthdrs may take lots of space (~8K for now)		   MAX_HEADER is not enough.		 */		head_room = opt->opt_nflen + opt->opt_flen;		seg_len += head_room;		head_room += sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);		if (skb_headroom(skb) < head_room) {			struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);			if (skb2 == NULL) {				IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),					      IPSTATS_MIB_OUTDISCARDS);				kfree_skb(skb);				return -ENOBUFS;			}			consume_skb(skb);			skb = skb2;			skb_set_owner_w(skb, sk);		}		if (opt->opt_flen)			ipv6_push_frag_opts(skb, opt, &proto);		if (opt->opt_nflen)			ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop);	}	skb_push(skb, sizeof(struct ipv6hdr));	skb_reset_network_header(skb);	hdr = ipv6_hdr(skb);	/*	 *	Fill in the IPv6 header	 */	if (np)		hlimit = np->hop_limit;	if (hlimit < 0)		hlimit = ip6_dst_hoplimit(dst);	ip6_flow_hdr(hdr, tclass, fl6->flowlabel);	hdr->payload_len = htons(seg_len);	hdr->nexthdr = proto;	hdr->hop_limit = hlimit;	hdr->saddr = fl6->saddr;	hdr->daddr = *first_hop;	skb->priority = sk->sk_priority;	skb->mark = sk->sk_mark;	mtu = dst_mtu(dst);	if ((skb->len <= mtu) || skb->local_df || skb_is_gso(skb)) {		IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),			      IPSTATS_MIB_OUT, skb->len);		return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL,			       dst->dev, dst_output);	}	skb->dev = dst->dev;	ipv6_local_error(sk, EMSGSIZE, fl6, mtu);	IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);	kfree_skb(skb);	return -EMSGSIZE;}

//.........这里部分代码省略.........	case IPV6_RECVHOPOPTS:		val = np->rxopt.bits.hopopts;		break;	case IPV6_2292HOPOPTS:		val = np->rxopt.bits.ohopopts;		break;	case IPV6_RECVDSTOPTS:		val = np->rxopt.bits.dstopts;		break;	case IPV6_2292DSTOPTS:		val = np->rxopt.bits.odstopts;		break;	case IPV6_TCLASS:		val = np->tclass;		if (val < 0)			val = 0;		break;	case IPV6_RECVTCLASS:		val = np->rxopt.bits.rxtclass;		break;	case IPV6_FLOWINFO:		val = np->rxopt.bits.rxflow;		break;	case IPV6_UNICAST_HOPS:	case IPV6_MULTICAST_HOPS:	{		struct dst_entry *dst;		if (optname == IPV6_UNICAST_HOPS)			val = np->hop_limit;		else			val = np->mcast_hops;		dst = sk_dst_get(sk);		if (dst) {			if (val < 0)				val = ip6_dst_hoplimit(dst);			dst_release(dst);		}		if (val < 0)			val = sock_net(sk)->ipv6.devconf_all->hop_limit;		break;	}	case IPV6_MULTICAST_LOOP:		val = np->mc_loop;		break;	case IPV6_MULTICAST_IF:		val = np->mcast_oif;		break;	case IPV6_MTU_DISCOVER:		val = np->pmtudisc;		break;	case IPV6_RECVERR:		val = np->recverr;		break;	case IPV6_FLOWINFO_SEND:		val = np->sndflow;		break;	case IPV6_ADDR_PREFERENCES:		val = 0;		if (np->srcprefs & IPV6_PREFER_SRC_TMP)			val |= IPV6_PREFER_SRC_TMP;		else if (np->srcprefs & IPV6_PREFER_SRC_PUBLIC)			val |= IPV6_PREFER_SRC_PUBLIC;		else {			/* XXX: should we return system default? */			val |= IPV6_PREFER_SRC_PUBTMP_DEFAULT;		}		if (np->srcprefs & IPV6_PREFER_SRC_COA)			val |= IPV6_PREFER_SRC_COA;		else			val |= IPV6_PREFER_SRC_HOME;		break;	default:		return -ENOPROTOOPT;	}	len = min_t(unsigned int, sizeof(int), len);	if(put_user(len, optlen))		return -EFAULT;	if(copy_to_user(optval,&val,len))		return -EFAULT;	return 0;}

static int svc_accept(struct socket *sock,struct socket *newsock,int flags){	struct sock *sk = sock->sk;	struct sk_buff *skb;	struct atmsvc_msg *msg;	struct atm_vcc *old_vcc = ATM_SD(sock);	struct atm_vcc *new_vcc;	int error;	lock_sock(sk);	error = svc_create(sock_net(sk), newsock,0);	if (error)		goto out;	new_vcc = ATM_SD(newsock);	pr_debug("svc_accept %p -> %p/n",old_vcc,new_vcc);	while (1) {		DEFINE_WAIT(wait);		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);		while (!(skb = skb_dequeue(&sk->sk_receive_queue)) &&		       sigd) {			if (test_bit(ATM_VF_RELEASED,&old_vcc->flags)) break;			if (test_bit(ATM_VF_CLOSE,&old_vcc->flags)) {				error = -sk->sk_err;				break;			}			if (flags & O_NONBLOCK) {				error = -EAGAIN;				break;			}			release_sock(sk);			schedule();			lock_sock(sk);			if (signal_pending(current)) {				error = -ERESTARTSYS;				break;			}			prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);		}		finish_wait(sk->sk_sleep, &wait);		if (error)			goto out;		if (!skb) {			error = -EUNATCH;			goto out;		}		msg = (struct atmsvc_msg *) skb->data;		new_vcc->qos = msg->qos;		set_bit(ATM_VF_HASQOS,&new_vcc->flags);		new_vcc->remote = msg->svc;		new_vcc->local = msg->local;		new_vcc->sap = msg->sap;		error = vcc_connect(newsock, msg->pvc.sap_addr.itf,				    msg->pvc.sap_addr.vpi, msg->pvc.sap_addr.vci);		dev_kfree_skb(skb);		sk->sk_ack_backlog--;		if (error) {			sigd_enq2(NULL,as_reject,old_vcc,NULL,NULL,			    &old_vcc->qos,error);			error = error == -EAGAIN ? -EBUSY : error;			goto out;		}		/* wait should be short, so we ignore the non-blocking flag */		set_bit(ATM_VF_WAITING, &new_vcc->flags);		prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);		sigd_enq(new_vcc,as_accept,old_vcc,NULL,NULL);		while (test_bit(ATM_VF_WAITING, &new_vcc->flags) && sigd) {			release_sock(sk);			schedule();			lock_sock(sk);			prepare_to_wait(sk_atm(new_vcc)->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);		}		finish_wait(sk_atm(new_vcc)->sk_sleep, &wait);		if (!sigd) {			error = -EUNATCH;			goto out;		}		if (!sk_atm(new_vcc)->sk_err)			break;		if (sk_atm(new_vcc)->sk_err != ERESTARTSYS) {			error = -sk_atm(new_vcc)->sk_err;			goto out;		}	}	newsock->state = SS_CONNECTED;out:	release_sock(sk);	return error;}

//.........这里部分代码省略.........virtio_transport_send_response(struct vsock_sock *vsk,			       struct virtio_vsock_pkt *pkt){	struct virtio_vsock_pkt_info info = {		.op = VIRTIO_VSOCK_OP_RESPONSE,		.type = VIRTIO_VSOCK_TYPE_STREAM,		.remote_cid = le64_to_cpu(pkt->hdr.src_cid),		.remote_port = le32_to_cpu(pkt->hdr.src_port),		.reply = true,		.vsk = vsk,	};	return virtio_transport_send_pkt_info(vsk, &info);}/* Handle server socket */static intvirtio_transport_recv_listen(struct sock *sk, struct virtio_vsock_pkt *pkt){	struct vsock_sock *vsk = vsock_sk(sk);	struct vsock_sock *vchild;	struct sock *child;	if (le16_to_cpu(pkt->hdr.op) != VIRTIO_VSOCK_OP_REQUEST) {		virtio_transport_reset(vsk, pkt);		return -EINVAL;	}	if (sk_acceptq_is_full(sk)) {		virtio_transport_reset(vsk, pkt);		return -ENOMEM;	}	child = __vsock_create(sock_net(sk), NULL, sk, GFP_KERNEL,			       sk->sk_type, 0);	if (!child) {		virtio_transport_reset(vsk, pkt);		return -ENOMEM;	}	sk->sk_ack_backlog++;	lock_sock_nested(child, SINGLE_DEPTH_NESTING);	child->sk_state = SS_CONNECTED;	vchild = vsock_sk(child);	vsock_addr_init(&vchild->local_addr, le64_to_cpu(pkt->hdr.dst_cid),			le32_to_cpu(pkt->hdr.dst_port));	vsock_addr_init(&vchild->remote_addr, le64_to_cpu(pkt->hdr.src_cid),			le32_to_cpu(pkt->hdr.src_port));	vsock_insert_connected(vchild);	vsock_enqueue_accept(sk, child);	virtio_transport_send_response(vchild, pkt);	release_sock(child);	sk->sk_data_ready(sk);	return 0;}static bool virtio_transport_space_update(struct sock *sk,					  struct virtio_vsock_pkt *pkt){	struct vsock_sock *vsk = vsock_sk(sk);