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

static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags){	struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;	struct sock *sk = sock->sk;	int err = 0;	BT_DBG("sk %p", sk);	if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))		return -EINVAL;	if (sk->state != BT_OPEN && sk->state != BT_BOUND)		return -EBADFD;	if (sk->type != SOCK_SEQPACKET)		return -EINVAL;	lock_sock(sk);	/* Set destination address and psm */	bacpy(&bluez_pi(sk)->dst, &sa->sco_bdaddr);	if ((err = sco_connect(sk)))		goto done;	err = bluez_sock_wait_state(sk, BT_CONNECTED,			sock_sndtimeo(sk, flags & O_NONBLOCK));done:	release_sock(sk);	return err;}

int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,		 size_t len){	const struct dccp_sock *dp = dccp_sk(sk);	const int flags = msg->msg_flags;	const int noblock = flags & MSG_DONTWAIT;	struct sk_buff *skb;	int rc, size;	long timeo;	if (len > dp->dccps_mss_cache)		return -EMSGSIZE;	lock_sock(sk);	if (sysctl_dccp_tx_qlen &&	    (sk->sk_write_queue.qlen >= sysctl_dccp_tx_qlen)) {		rc = -EAGAIN;		goto out_release;	}	timeo = sock_sndtimeo(sk, noblock);	/*	 * We have to use sk_stream_wait_connect here to set sk_write_pending,	 * so that the trick in dccp_rcv_request_sent_state_process.	 */	/* Wait for a connection to finish. */	if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))		if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)			goto out_release;	size = sk->sk_prot->max_header + len;	release_sock(sk);	skb = sock_alloc_send_skb(sk, size, noblock, &rc);	lock_sock(sk);	if (skb == NULL)		goto out_release;	skb_reserve(skb, sk->sk_prot->max_header);	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);	if (rc != 0)		goto out_discard;	skb_queue_tail(&sk->sk_write_queue, skb);	/*	 * The xmit_timer is set if the TX CCID is rate-based and will expire	 * when congestion control permits to release further packets into the	 * network. Window-based CCIDs do not use this timer.	 */	if (!timer_pending(&dp->dccps_xmit_timer))		dccp_write_xmit(sk);out_release:	release_sock(sk);	return rc ? : len;out_discard:	kfree_skb(skb);	goto out_release;}

int dccp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,		 size_t len){	const struct dccp_sock *dp = dccp_sk(sk);	const int flags = msg->msg_flags;	const int noblock = flags & MSG_DONTWAIT;	struct sk_buff *skb;	int rc, size;	long timeo;	if (len > dp->dccps_mss_cache)		return -EMSGSIZE;	lock_sock(sk);	timeo = sock_sndtimeo(sk, noblock);	/*	 * We have to use sk_stream_wait_connect here to set sk_write_pending,	 * so that the trick in dccp_rcv_request_sent_state_process.	 */	/* Wait for a connection to finish. */	if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN | DCCPF_CLOSING))		if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)			goto out_release;	size = sk->sk_prot->max_header + len;	release_sock(sk);	skb = sock_alloc_send_skb(sk, size, noblock, &rc);	lock_sock(sk);	if (skb == NULL)		goto out_release;	skb_reserve(skb, sk->sk_prot->max_header);	rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);	if (rc != 0)		goto out_discard;	rc = dccp_write_xmit(sk, skb, &timeo);	/*	 * XXX we don't use sk_write_queue, so just discard the packet.	 *     Current plan however is to _use_ sk_write_queue with	 *     an algorith similar to tcp_sendmsg, where the main difference	 *     is that in DCCP we have to respect packet boundaries, so	 *     no coalescing of skbs.	 *	 *     This bug was _quickly_ found & fixed by just looking at an OSTRA	 *     generated callgraph 8) -acme	 */out_release:	release_sock(sk);	return rc ? : len;out_discard:	kfree_skb(skb);	goto out_release;}

static int send_packet(struct kiocb *iocb, struct socket *sock,		       struct msghdr *m, size_t total_len){	struct sock *sk = sock->sk;	struct tipc_port *tport = tipc_sk_port(sk);	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;	long timeout_val;	int res;	/* Handle implied connection establishment */	if (unlikely(dest))		return send_msg(iocb, sock, m, total_len);	if ((total_len > TIPC_MAX_USER_MSG_SIZE) ||	    (m->msg_iovlen > (unsigned)INT_MAX))		return -EMSGSIZE;	if (iocb)		lock_sock(sk);	timeout_val = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);	do {		if (unlikely(sock->state != SS_CONNECTED)) {			if (sock->state == SS_DISCONNECTING)				res = -EPIPE;			else				res = -ENOTCONN;			break;		}		res = tipc_send(tport->ref, m->msg_iovlen, m->msg_iov,				total_len);		if (likely(res != -ELINKCONG))			break;		if (timeout_val <= 0L) {			res = timeout_val ? timeout_val : -EWOULDBLOCK;			break;		}		release_sock(sk);		timeout_val = wait_event_interruptible_timeout(*sk_sleep(sk),			(!tport->congested || !tport->connected), timeout_val);		lock_sock(sk);	} while (1);	if (iocb)		release_sock(sk);	return res;}

/** *	llc_ui_send_data - send data via reliable llc2 connection *	@sk: Connection the socket is using. *	@skb: Data the user wishes to send. *	@addr: Source and destination fields provided by the user. *	@noblock: can we block waiting for data? * *	Send data via reliable llc2 connection. *	Returns 0 upon success, non-zero if action did not succeed. */static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock){	struct llc_sock* llc = llc_sk(sk);	int rc = 0;	if (llc_data_accept_state(llc->state) || llc->p_flag) {		int timeout = sock_sndtimeo(sk, noblock);		rc = llc_ui_wait_for_busy_core(sk, timeout);	}	if (!rc)		rc = llc_build_and_send_pkt(sk, skb);	return rc;}

/* blocks sndbuf producer until at least one byte of free space available */static int smc_tx_wait_memory(struct smc_sock *smc, int flags){	DEFINE_WAIT_FUNC(wait, woken_wake_function);	struct smc_connection *conn = &smc->conn;	struct sock *sk = &smc->sk;	bool noblock;	long timeo;	int rc = 0;	/* similar to sk_stream_wait_memory */	timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);	noblock = timeo ? false : true;	add_wait_queue(sk_sleep(sk), &wait);	while (1) {		sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);		if (sk->sk_err ||		    (sk->sk_shutdown & SEND_SHUTDOWN) ||		    conn->local_tx_ctrl.conn_state_flags.peer_done_writing) {			rc = -EPIPE;			break;		}		if (smc_cdc_rxed_any_close(conn)) {			rc = -ECONNRESET;			break;		}		if (!timeo) {			if (noblock)				set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);			rc = -EAGAIN;			break;		}		if (signal_pending(current)) {			rc = sock_intr_errno(timeo);			break;		}		sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);		if (atomic_read(&conn->sndbuf_space))			break; /* at least 1 byte of free space available */		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);		sk_wait_event(sk, &timeo,			      sk->sk_err ||			      (sk->sk_shutdown & SEND_SHUTDOWN) ||			      smc_cdc_rxed_any_close(conn) ||			      atomic_read(&conn->sndbuf_space),			      &wait);	}	remove_wait_queue(sk_sleep(sk), &wait);	return rc;}

static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,					    unsigned long header_len,					    unsigned long data_len,					    int noblock, int *errcode){	struct sk_buff *skb;	gfp_t gfp_mask;	long timeo;	int err;	gfp_mask = sk->sk_allocation;	if (gfp_mask & __GFP_WAIT)		gfp_mask |= __GFP_REPEAT;	timeo = sock_sndtimeo(sk, noblock);	while (1) {		err = sock_error(sk);		if (err != 0)			goto failure;		err = -EPIPE;		if (sk->sk_shutdown & SEND_SHUTDOWN)			goto failure;		if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {			skb = alloc_skb(header_len, sk->sk_allocation);			if (skb) {				int npages;				int i;				/* No pages, we're done... */				if (!data_len)					break;				npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;				skb->truesize += data_len;				skb_shinfo(skb)->nr_frags = npages;				for (i = 0; i < npages; i++) {					struct page *page;					skb_frag_t *frag;					page = alloc_pages(sk->sk_allocation, 0);					if (!page) {						err = -ENOBUFS;						skb_shinfo(skb)->nr_frags = i;						kfree_skb(skb);						goto failure;					}					frag = &skb_shinfo(skb)->frags[i];					frag->page = page;					frag->page_offset = 0;					frag->size = (data_len >= PAGE_SIZE ?						      PAGE_SIZE :						      data_len);					data_len -= PAGE_SIZE;				}				/* Full success... */				break;			}			err = -ENOBUFS;			goto failure;		}		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);		err = -EAGAIN;		if (!timeo)			goto failure;		if (signal_pending(current))			goto interrupted;		timeo = sock_wait_for_wmem(sk, timeo);	}

static int pep_sendmsg(struct kiocb *iocb, struct sock *sk,			struct msghdr *msg, size_t len){	struct pep_sock *pn = pep_sk(sk);	struct sk_buff *skb;	long timeo;	int flags = msg->msg_flags;	int err, done;	if ((msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|				MSG_CMSG_COMPAT)) ||			!(msg->msg_flags & MSG_EOR))		return -EOPNOTSUPP;	skb = sock_alloc_send_skb(sk, MAX_PNPIPE_HEADER + len,					flags & MSG_DONTWAIT, &err);	if (!skb)		return -ENOBUFS;	skb_reserve(skb, MAX_PHONET_HEADER + 3);	err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);	if (err < 0)		goto outfree;	lock_sock(sk);	timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);	if ((1 << sk->sk_state) & (TCPF_LISTEN|TCPF_CLOSE)) {		err = -ENOTCONN;		goto out;	}	if (sk->sk_state != TCP_ESTABLISHED) {		/* Wait until the pipe gets to enabled state */disabled:		err = sk_stream_wait_connect(sk, &timeo);		if (err)			goto out;		if (sk->sk_state == TCP_CLOSE_WAIT) {			err = -ECONNRESET;			goto out;		}	}	BUG_ON(sk->sk_state != TCP_ESTABLISHED);	/* Wait until flow control allows TX */	done = atomic_read(&pn->tx_credits);	while (!done) {		DEFINE_WAIT(wait);		if (!timeo) {			err = -EAGAIN;			goto out;		}		if (signal_pending(current)) {			err = sock_intr_errno(timeo);			goto out;		}		prepare_to_wait(sk_sleep(sk), &wait,				TASK_INTERRUPTIBLE);		done = sk_wait_event(sk, &timeo, atomic_read(&pn->tx_credits));		finish_wait(sk_sleep(sk), &wait);		if (sk->sk_state != TCP_ESTABLISHED)			goto disabled;	}	err = pipe_skb_send(sk, skb);	if (err >= 0)		err = len; /* success! */	skb = NULL;out:	release_sock(sk);outfree:	kfree_skb(skb);	return err;}

static int vsock_stream_sendmsg(struct socket *sock, struct msghdr *msg,				size_t len){	struct sock *sk;	struct vsock_sock *vsk;	ssize_t total_written;	long timeout;	int err;	struct vsock_transport_send_notify_data send_data;	DEFINE_WAIT_FUNC(wait, woken_wake_function);	sk = sock->sk;	vsk = vsock_sk(sk);	total_written = 0;	err = 0;	if (msg->msg_flags & MSG_OOB)		return -EOPNOTSUPP;	lock_sock(sk);	/* Callers should not provide a destination with stream sockets. */	if (msg->msg_namelen) {		err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;		goto out;	}	/* Send data only if both sides are not shutdown in the direction. */	if (sk->sk_shutdown & SEND_SHUTDOWN ||	    vsk->peer_shutdown & RCV_SHUTDOWN) {		err = -EPIPE;		goto out;	}	if (sk->sk_state != TCP_ESTABLISHED ||	    !vsock_addr_bound(&vsk->local_addr)) {		err = -ENOTCONN;		goto out;	}	if (!vsock_addr_bound(&vsk->remote_addr)) {		err = -EDESTADDRREQ;		goto out;	}	/* Wait for room in the produce queue to enqueue our user's data. */	timeout = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);	err = transport->notify_send_init(vsk, &send_data);	if (err < 0)		goto out;	while (total_written < len) {		ssize_t written;		add_wait_queue(sk_sleep(sk), &wait);		while (vsock_stream_has_space(vsk) == 0 &&		       sk->sk_err == 0 &&		       !(sk->sk_shutdown & SEND_SHUTDOWN) &&		       !(vsk->peer_shutdown & RCV_SHUTDOWN)) {			/* Don't wait for non-blocking sockets. */			if (timeout == 0) {				err = -EAGAIN;				remove_wait_queue(sk_sleep(sk), &wait);				goto out_err;			}			err = transport->notify_send_pre_block(vsk, &send_data);			if (err < 0) {				remove_wait_queue(sk_sleep(sk), &wait);				goto out_err;			}			release_sock(sk);			timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, timeout);			lock_sock(sk);			if (signal_pending(current)) {				err = sock_intr_errno(timeout);				remove_wait_queue(sk_sleep(sk), &wait);				goto out_err;			} else if (timeout == 0) {				err = -EAGAIN;				remove_wait_queue(sk_sleep(sk), &wait);				goto out_err;			}		}		remove_wait_queue(sk_sleep(sk), &wait);		/* These checks occur both as part of and after the loop		 * conditional since we need to check before and after		 * sleeping.		 */		if (sk->sk_err) {			err = -sk->sk_err;			goto out_err;		} else if ((sk->sk_shutdown & SEND_SHUTDOWN) ||			   (vsk->peer_shutdown & RCV_SHUTDOWN)) {			err = -EPIPE;			goto out_err;//.........这里部分代码省略.........

static int vsock_accept(struct socket *sock, struct socket *newsock, int flags,			bool kern){	struct sock *listener;	int err;	struct sock *connected;	struct vsock_sock *vconnected;	long timeout;	DEFINE_WAIT(wait);	err = 0;	listener = sock->sk;	lock_sock(listener);	if (sock->type != SOCK_STREAM) {		err = -EOPNOTSUPP;		goto out;	}	if (listener->sk_state != TCP_LISTEN) {		err = -EINVAL;		goto out;	}	/* Wait for children sockets to appear; these are the new sockets	 * created upon connection establishment.	 */	timeout = sock_sndtimeo(listener, flags & O_NONBLOCK);	prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);	while ((connected = vsock_dequeue_accept(listener)) == NULL &&	       listener->sk_err == 0) {		release_sock(listener);		timeout = schedule_timeout(timeout);		finish_wait(sk_sleep(listener), &wait);		lock_sock(listener);		if (signal_pending(current)) {			err = sock_intr_errno(timeout);			goto out;		} else if (timeout == 0) {			err = -EAGAIN;			goto out;		}		prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);	}	finish_wait(sk_sleep(listener), &wait);	if (listener->sk_err)		err = -listener->sk_err;	if (connected) {		listener->sk_ack_backlog--;		lock_sock_nested(connected, SINGLE_DEPTH_NESTING);		vconnected = vsock_sk(connected);		/* If the listener socket has received an error, then we should		 * reject this socket and return.  Note that we simply mark the		 * socket rejected, drop our reference, and let the cleanup		 * function handle the cleanup; the fact that we found it in		 * the listener's accept queue guarantees that the cleanup		 * function hasn't run yet.		 */		if (err) {			vconnected->rejected = true;		} else {			newsock->state = SS_CONNECTED;			sock_graft(connected, newsock);		}		release_sock(connected);		sock_put(connected);	}out:	release_sock(listener);	return err;}

int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock){	struct sock *sk;	int len = skb->len;	int protocol = ssk->protocol;	long timeo;        DECLARE_WAITQUEUE(wait, current);	timeo = sock_sndtimeo(ssk, nonblock);retry:	sk = netlink_lookup(protocol, pid);	if (sk == NULL)		goto no_dst;#ifdef NL_EMULATE_DEV	if (sk->protinfo.af_netlink->handler) {		skb_orphan(skb);		len = sk->protinfo.af_netlink->handler(protocol, skb);		sock_put(sk);		return len;	}#endif	if (atomic_read(&sk->rmem_alloc) > sk->rcvbuf ||	    test_bit(0, &sk->protinfo.af_netlink->state)) {		if (!timeo) {			if (ssk->protinfo.af_netlink->pid == 0)				netlink_overrun(sk);			sock_put(sk);			kfree_skb(skb);			return -EAGAIN;		}		__set_current_state(TASK_INTERRUPTIBLE);		add_wait_queue(&sk->protinfo.af_netlink->wait, &wait);		if ((atomic_read(&sk->rmem_alloc) > sk->rcvbuf ||		    test_bit(0, &sk->protinfo.af_netlink->state)) &&		    !sk->dead)			timeo = schedule_timeout(timeo);		__set_current_state(TASK_RUNNING);		remove_wait_queue(&sk->protinfo.af_netlink->wait, &wait);		sock_put(sk);		if (signal_pending(current)) {			kfree_skb(skb);			return sock_intr_errno(timeo);		}		goto retry;	}	skb_orphan(skb);	skb_set_owner_r(skb, sk);	skb_queue_tail(&sk->receive_queue, skb);	sk->data_ready(sk, len);	sock_put(sk);	return len;no_dst:	kfree_skb(skb);	return -ECONNREFUSED;}

static int pn_socket_connect(struct socket *sock, struct sockaddr *addr,		int len, int flags){	struct sock *sk = sock->sk;	struct sockaddr_pn *spn = (struct sockaddr_pn *)addr;	long timeo;	int err;	if (len < sizeof(struct sockaddr_pn))		return -EINVAL;	if (spn->spn_family != AF_PHONET)		return -EAFNOSUPPORT;	lock_sock(sk);	switch (sock->state) {	case SS_UNCONNECTED:		sk->sk_state = TCP_CLOSE;		break;	case SS_CONNECTING:		switch (sk->sk_state) {		case TCP_SYN_RECV:			sock->state = SS_CONNECTED;			err = -EISCONN;			goto out;		case TCP_CLOSE:			err = -EALREADY;			if (flags & O_NONBLOCK)				goto out;			goto wait_connect;		}		break;	case SS_CONNECTED:		switch (sk->sk_state) {		case TCP_SYN_RECV:			err = -EISCONN;			goto out;		case TCP_CLOSE:			sock->state = SS_UNCONNECTED;			break;		}		break;	case SS_DISCONNECTING:	case SS_FREE:		break;	}	sk->sk_state = TCP_CLOSE;	sk_stream_kill_queues(sk);	sock->state = SS_CONNECTING;	err = sk->sk_prot->connect(sk, addr, len);	if (err < 0) {		sock->state = SS_UNCONNECTED;		sk->sk_state = TCP_CLOSE;		goto out;	}	err = -EINPROGRESS;wait_connect:	if (sk->sk_state != TCP_SYN_RECV && (flags & O_NONBLOCK))		goto out;	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);	release_sock(sk);	err = -ERESTARTSYS;	timeo = wait_event_interruptible_timeout(*sk_sleep(sk),			sk->sk_state != TCP_CLOSE,			timeo);	lock_sock(sk);	if (timeo < 0)		goto out; /* -ERESTARTSYS */	err = -ETIMEDOUT;	if (timeo == 0 && sk->sk_state != TCP_SYN_RECV)		goto out;	if (sk->sk_state != TCP_SYN_RECV) {		sock->state = SS_UNCONNECTED;		err = sock_error(sk);		if (!err)			err = -ECONNREFUSED;		goto out;	}	sock->state = SS_CONNECTED;	err = 0;out:	release_sock(sk);	return err;}

static int send_msg(struct kiocb *iocb, struct socket *sock,		    struct msghdr *m, size_t total_len){	struct sock *sk = sock->sk;	struct tipc_port *tport = tipc_sk_port(sk);	struct sockaddr_tipc *dest = (struct sockaddr_tipc *)m->msg_name;	int needs_conn;	long timeout_val;	int res = -EINVAL;	if (unlikely(!dest))		return -EDESTADDRREQ;	if (unlikely((m->msg_namelen < sizeof(*dest)) ||		     (dest->family != AF_TIPC)))		return -EINVAL;	if ((total_len > TIPC_MAX_USER_MSG_SIZE) ||	    (m->msg_iovlen > (unsigned)INT_MAX))		return -EMSGSIZE;	if (iocb)		lock_sock(sk);	needs_conn = (sock->state != SS_READY);	if (unlikely(needs_conn)) {		if (sock->state == SS_LISTENING) {			res = -EPIPE;			goto exit;		}		if (sock->state != SS_UNCONNECTED) {			res = -EISCONN;			goto exit;		}		if ((tport->published) ||		    ((sock->type == SOCK_STREAM) && (total_len != 0))) {			res = -EOPNOTSUPP;			goto exit;		}		if (dest->addrtype == TIPC_ADDR_NAME) {			tport->conn_type = dest->addr.name.name.type;			tport->conn_instance = dest->addr.name.name.instance;		}		/* Abort any pending connection attempts (very unlikely) */		reject_rx_queue(sk);	}	timeout_val = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT);	do {		if (dest->addrtype == TIPC_ADDR_NAME) {			res = dest_name_check(dest, m);			if (res)				break;			res = tipc_send2name(tport->ref,					     &dest->addr.name.name,					     dest->addr.name.domain,					     m->msg_iovlen,					     m->msg_iov,					     total_len);		} else if (dest->addrtype == TIPC_ADDR_ID) {			res = tipc_send2port(tport->ref,					     &dest->addr.id,					     m->msg_iovlen,					     m->msg_iov,					     total_len);		} else if (dest->addrtype == TIPC_ADDR_MCAST) {			if (needs_conn) {				res = -EOPNOTSUPP;				break;			}			res = dest_name_check(dest, m);			if (res)				break;			res = tipc_multicast(tport->ref,					     &dest->addr.nameseq,					     m->msg_iovlen,					     m->msg_iov,					     total_len);		}		if (likely(res != -ELINKCONG)) {			if (needs_conn && (res >= 0))				sock->state = SS_CONNECTING;			break;		}		if (timeout_val <= 0L) {			res = timeout_val ? timeout_val : -EWOULDBLOCK;			break;		}		release_sock(sk);		timeout_val = wait_event_interruptible_timeout(*sk_sleep(sk),					       !tport->congested, timeout_val);		lock_sock(sk);	} while (1);exit:	if (iocb)		release_sock(sk);	return res;}

long rtl_sk_sndtimeo(struct sock *sk, int flags){	return sock_sndtimeo(sk, flags & MSG_DONTWAIT);}

static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,			      int alen, int flags){	struct sock *sk = sock->sk;	struct l2cap_chan *chan = l2cap_pi(sk)->chan;	struct sockaddr_l2 la;	int len, err = 0;	BT_DBG("sk %p", sk);	if (!addr || alen < sizeof(addr->sa_family) ||	    addr->sa_family != AF_BLUETOOTH)		return -EINVAL;	memset(&la, 0, sizeof(la));	len = min_t(unsigned int, sizeof(la), alen);	memcpy(&la, addr, len);	if (la.l2_cid && la.l2_psm)		return -EINVAL;	if (!bdaddr_type_is_valid(la.l2_bdaddr_type))		return -EINVAL;	/* Check that the socket wasn't bound to something that	 * conflicts with the address given to connect(). If chan->src	 * is BDADDR_ANY it means bind() was never used, in which case	 * chan->src_type and la.l2_bdaddr_type do not need to match.	 */	if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&	    bdaddr_type_is_le(la.l2_bdaddr_type)) {		/* Old user space versions will try to incorrectly bind		 * the ATT socket using BDADDR_BREDR. We need to accept		 * this and fix up the source address type only when		 * both the source CID and destination CID indicate		 * ATT. Anything else is an invalid combination.		 */		if (chan->scid != L2CAP_CID_ATT ||		    la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))			return -EINVAL;		/* We don't have the hdev available here to make a		 * better decision on random vs public, but since all		 * user space versions that exhibit this issue anyway do		 * not support random local addresses assuming public		 * here is good enough.		 */		chan->src_type = BDADDR_LE_PUBLIC;	}	if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)		return -EINVAL;	if (bdaddr_type_is_le(la.l2_bdaddr_type)) {		/* We only allow ATT user space socket */		if (la.l2_cid &&		    la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))			return -EINVAL;	}	if (chan->psm && bdaddr_type_is_le(chan->src_type))		chan->mode = L2CAP_MODE_LE_FLOWCTL;	err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),				 &la.l2_bdaddr, la.l2_bdaddr_type);	if (err)		return err;	lock_sock(sk);	err = bt_sock_wait_state(sk, BT_CONNECTED,				 sock_sndtimeo(sk, flags & O_NONBLOCK));	release_sock(sk);	return err;}

int tls_sw_sendpage(struct sock *sk, struct page *page,		    int offset, size_t size, int flags){	struct tls_context *tls_ctx = tls_get_ctx(sk);	struct tls_sw_context *ctx = tls_sw_ctx(tls_ctx);	int ret = 0;	long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);	bool eor;	size_t orig_size = size;	unsigned char record_type = TLS_RECORD_TYPE_DATA;	struct scatterlist *sg;	bool full_record;	int record_room;	if (flags & ~(MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL |		      MSG_SENDPAGE_NOTLAST))		return -ENOTSUPP;	/* No MSG_EOR from splice, only look at MSG_MORE */	eor = !(flags & (MSG_MORE | MSG_SENDPAGE_NOTLAST));	lock_sock(sk);	sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);	if (tls_complete_pending_work(sk, tls_ctx, flags, &timeo))		goto sendpage_end;	/* Call the sk_stream functions to manage the sndbuf mem. */	while (size > 0) {		size_t copy, required_size;		if (sk->sk_err) {			ret = sk->sk_err;			goto sendpage_end;		}		full_record = false;		record_room = TLS_MAX_PAYLOAD_SIZE - ctx->sg_plaintext_size;		copy = size;		if (copy >= record_room) {			copy = record_room;			full_record = true;		}		required_size = ctx->sg_plaintext_size + copy +			      tls_ctx->overhead_size;		if (!sk_stream_memory_free(sk))			goto wait_for_sndbuf;alloc_payload:		ret = alloc_encrypted_sg(sk, required_size);		if (ret) {			if (ret != -ENOSPC)				goto wait_for_memory;			/* Adjust copy according to the amount that was			 * actually allocated. The difference is due			 * to max sg elements limit			 */			copy -= required_size - ctx->sg_plaintext_size;			full_record = true;		}		get_page(page);		sg = ctx->sg_plaintext_data + ctx->sg_plaintext_num_elem;		sg_set_page(sg, page, copy, offset);		ctx->sg_plaintext_num_elem++;		sk_mem_charge(sk, copy);		offset += copy;		size -= copy;		ctx->sg_plaintext_size += copy;		tls_ctx->pending_open_record_frags = ctx->sg_plaintext_num_elem;		if (full_record || eor ||		    ctx->sg_plaintext_num_elem ==		    ARRAY_SIZE(ctx->sg_plaintext_data)) {push_record:			ret = tls_push_record(sk, flags, record_type);			if (ret) {				if (ret == -ENOMEM)					goto wait_for_memory;				goto sendpage_end;			}		}		continue;wait_for_sndbuf:		set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);wait_for_memory:		ret = sk_stream_wait_memory(sk, &timeo);		if (ret) {			trim_both_sgl(sk, ctx->sg_plaintext_size);			goto sendpage_end;		}		if (tls_is_pending_closed_record(tls_ctx))			goto push_record;		goto alloc_payload;//.........这里部分代码省略.........

int tls_sw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size){	struct tls_context *tls_ctx = tls_get_ctx(sk);	struct tls_sw_context *ctx = tls_sw_ctx(tls_ctx);	int ret = 0;	int required_size;	long timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);	bool eor = !(msg->msg_flags & MSG_MORE);	size_t try_to_copy, copied = 0;	unsigned char record_type = TLS_RECORD_TYPE_DATA;	int record_room;	bool full_record;	int orig_size;	if (msg->msg_flags & ~(MSG_MORE | MSG_DONTWAIT | MSG_NOSIGNAL))		return -ENOTSUPP;	lock_sock(sk);	if (tls_complete_pending_work(sk, tls_ctx, msg->msg_flags, &timeo))		goto send_end;	if (unlikely(msg->msg_controllen)) {		ret = tls_proccess_cmsg(sk, msg, &record_type);		if (ret)			goto send_end;	}	while (msg_data_left(msg)) {		if (sk->sk_err) {			ret = sk->sk_err;			goto send_end;		}		orig_size = ctx->sg_plaintext_size;		full_record = false;		try_to_copy = msg_data_left(msg);		record_room = TLS_MAX_PAYLOAD_SIZE - ctx->sg_plaintext_size;		if (try_to_copy >= record_room) {			try_to_copy = record_room;			full_record = true;		}		required_size = ctx->sg_plaintext_size + try_to_copy +				tls_ctx->overhead_size;		if (!sk_stream_memory_free(sk))			goto wait_for_sndbuf;alloc_encrypted:		ret = alloc_encrypted_sg(sk, required_size);		if (ret) {			if (ret != -ENOSPC)				goto wait_for_memory;			/* Adjust try_to_copy according to the amount that was			 * actually allocated. The difference is due			 * to max sg elements limit			 */			try_to_copy -= required_size - ctx->sg_encrypted_size;			full_record = true;		}		if (full_record || eor) {			ret = zerocopy_from_iter(sk, &msg->msg_iter,						 try_to_copy);			if (ret)				goto fallback_to_reg_send;			copied += try_to_copy;			ret = tls_push_record(sk, msg->msg_flags, record_type);			if (!ret)				continue;			if (ret == -EAGAIN)				goto send_end;			copied -= try_to_copy;fallback_to_reg_send:			iov_iter_revert(&msg->msg_iter,					ctx->sg_plaintext_size - orig_size);			trim_sg(sk, ctx->sg_plaintext_data,				&ctx->sg_plaintext_num_elem,				&ctx->sg_plaintext_size,				orig_size);		}		required_size = ctx->sg_plaintext_size + try_to_copy;alloc_plaintext:		ret = alloc_plaintext_sg(sk, required_size);		if (ret) {			if (ret != -ENOSPC)				goto wait_for_memory;			/* Adjust try_to_copy according to the amount that was			 * actually allocated. The difference is due			 * to max sg elements limit			 */			try_to_copy -= required_size - ctx->sg_plaintext_size;			full_record = true;			trim_sg(sk, ctx->sg_encrypted_data,//.........这里部分代码省略.........

/* * send data through a socket * - must be called in process context * - caller holds the socket locked */static int rxrpc_send_data(struct kiocb *iocb,			   struct rxrpc_sock *rx,			   struct rxrpc_call *call,			   struct msghdr *msg, size_t len){	struct rxrpc_skb_priv *sp;	unsigned char __user *from;	struct sk_buff *skb;	struct iovec *iov;	struct sock *sk = &rx->sk;	long timeo;	bool more;	int ret, ioc, segment, copied;	_enter(",,,{%zu},%zu", msg->msg_iovlen, len);	timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);	/* this should be in poll */	clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);	if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))		return -EPIPE;	iov = msg->msg_iov;	ioc = msg->msg_iovlen - 1;	from = iov->iov_base;	segment = iov->iov_len;	iov++;	more = msg->msg_flags & MSG_MORE;	skb = call->tx_pending;	call->tx_pending = NULL;	copied = 0;	do {		int copy;		if (segment > len)			segment = len;		_debug("SEGMENT %d @%p", segment, from);		if (!skb) {			size_t size, chunk, max, space;			_debug("alloc");			if (CIRC_SPACE(call->acks_head, call->acks_tail,				       call->acks_winsz) <= 0) {				ret = -EAGAIN;				if (msg->msg_flags & MSG_DONTWAIT)					goto maybe_error;				ret = rxrpc_wait_for_tx_window(rx, call,							       &timeo);				if (ret < 0)					goto maybe_error;			}			max = call->conn->trans->peer->maxdata;			max -= call->conn->security_size;			max &= ~(call->conn->size_align - 1UL);			chunk = max;			if (chunk > len && !more)				chunk = len;			space = chunk + call->conn->size_align;			space &= ~(call->conn->size_align - 1UL);			size = space + call->conn->header_size;			_debug("SIZE: %zu/%zu/%zu", chunk, space, size);			/* create a buffer that we can retain until it's ACK'd */			skb = sock_alloc_send_skb(				sk, size, msg->msg_flags & MSG_DONTWAIT, &ret);			if (!skb)				goto maybe_error;			rxrpc_new_skb(skb);			_debug("ALLOC SEND %p", skb);			ASSERTCMP(skb->mark, ==, 0);			_debug("HS: %u", call->conn->header_size);			skb_reserve(skb, call->conn->header_size);			skb->len += call->conn->header_size;			sp = rxrpc_skb(skb);			sp->remain = chunk;			if (sp->remain > skb_tailroom(skb))				sp->remain = skb_tailroom(skb);//.........这里部分代码省略.........