Socket connect 等简要分析

connect 系统调用分析

#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

其中的参数解释如下：
·int sockfd ：套接字描述符。
·const struct sockaddr*addr ：要连接的地址。
·socklen_t addrlen ：要连接的地址长度。
返回值 0 表示成功， -1 表示失败。

connect 的用途是使用指定的套接字去连接指定的地址。对于面向连接的协议（套接字类型为
SOCK_STREAM ）， connect 只能成功一次（当然要如此，因为真正的连接已经建立了）。如果重复调
用 connect ，会返回 -1 表示失败，同时错误码为 EISCONN 。而对于非面向连接的协议（套接字类型为
SOCK_DGRAM ），则可以执行多次 connect （因为这时的 connect 仅仅是设置了默认的目的地址）。

对于 TCP 套接字来说， connect 实际上是要真正地进行三次握手，所以其默认是一个阻塞操作。那么
是否可以写一个非阻塞的 TCP connect 代码呢？

/*

 *	Attempt to connect to a socket with the server address.  The address

 *	is in user space so we verify it is OK and move it to kernel space.

 *

 *	For 1003.1g we need to add clean support for a bind to AF_UNSPEC to

 *	break bindings

 *

 *	NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and

 *	other SEQPACKET protocols that take time to connect() as it doesn't

 *	include the -EINPROGRESS status for such sockets.

 */

SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,

		int, addrlen)

{

	struct socket *sock;

	struct sockaddr_storage address;

	int err, fput_needed;

/* 通过文件描述符fd，找到对应的socket实例。

     * 以fd为索引从当前进程的文件描述符表files_struct实例中找到对应的file实例，

     * 然后从file实例的private_data成员中获取socket实例。

    */

	sock = sockfd_lookup_light(fd, &err, &fput_needed);

	if (!sock)

		goto out;

 /* 把套接字地址从用户空间拷贝到内核空间 */

	err = move_addr_to_kernel(uservaddr, addrlen, &address);

	if (err < 0)

		goto out_put;

	err =

	    security_socket_connect(sock, (struct sockaddr *)&address, addrlen);

	if (err)

		goto out_put;

/* 调用Socket层的操作函数，如果是SOCK_STREAM，则proto_ops为inet_stream_ops，

     * 函数指针指向inet_stream_connect()。

     */

	err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,

				 sock->file->f_flags);

out_put:

	fput_light(sock->file, fput_needed);

out:

	return err;

}

int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,

			int addr_len, int flags)

{

	int err;

	lock_sock(sock->sk);//进入互斥区

	err = __inet_stream_connect(sock, uaddr, addr_len, flags);

	release_sock(sock->sk);

	return err;

}

/*

 *	Connect to a remote host. There is regrettably still a little

 *	TCP 'magic' in here.

 */

int __inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,

			  int addr_len, int flags)

{

	struct sock *sk = sock->sk;

	int err;

	long timeo;

/*  长度合法性检查*/

	if (addr_len < sizeof(uaddr->sa_family))

		return -EINVAL;

	if (uaddr->sa_family == AF_UNSPEC) {/*  如果协议族为

AF_UNSPEC ，则先执行*/

		err = sk->sk_prot->disconnect(sk, flags);

/* 根据是否成功断开连接，来设置socket状态 */

		sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;

		goto out;

	}

	switch (sock->state) {

	default:

		err = -EINVAL;

		goto out;

 /* 此套接口已经和对端的套接口相连接了，即连接已经建立 */

	case SS_CONNECTED:

		err = -EISCONN;/* Transport endpoint is already connected */

		goto out;

	case SS_CONNECTING:/*连接正在建立中 */

		err = -EALREADY;/* Operation already in progress */

		/* Fall out of switch with err, set for this state */

		break;

	case SS_UNCONNECTED:

		err = -EISCONN;

		if (sk->sk_state != TCP_CLOSE)

			goto out;

/* 如果使用的是TCP，则sk_prot为tcp_prot，connect为tcp_v4_connect() */

		err = sk->sk_prot->connect(sk, uaddr, addr_len);/* 发送SYN包 */

		if (err < 0)

			goto out;

/* 发出SYN包后socket状态设为正在连接 */

		sock->state = SS_CONNECTING;

		/* Just entered SS_CONNECTING state; the only

		 * difference is that return value in non-blocking

		 * case is EINPROGRESS, rather than EALREADY.

		 */

		err = -EINPROGRESS;

		break;

	}

 /* sock的发送超时时间，非阻塞则为0 */

	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);

/* 发出SYN包后，等待后续握手的完成 */

	if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {

		int writebias = (sk->sk_protocol == IPPROTO_TCP) &&

				tcp_sk(sk)->fastopen_req &&

				tcp_sk(sk)->fastopen_req->data ? 1 : 0;

/* 如果是非阻塞的，那么就直接返回错误码-EINPROGRESS。

         * socket为阻塞时，使用inet_wait_for_connect()来等待协议栈的处理：

         * 1. 使用SO_SNDTIMEO，睡眠时间超过timeo就返回0，之后返回错误码-EINPROGRESS。

         * 2. 收到信号，就返回剩余的等待时间。之后会返回错误码-ERESTARTSYS或-EINTR。

         * 3. 三次握手成功，被sock I/O事件处理函数唤醒，之后会返回0。

         */

		/* Error code is set above */

		if (!timeo || !inet_wait_for_connect(sk, timeo, writebias))

			goto out;

		err = sock_intr_errno(timeo);

 /* 进程收到信号，如果err为-ERESTARTSYS，接下来库函数会重新调用connect() */

		if (signal_pending(current))

			goto out;

	}

	/* Connection was closed by RST, timeout, ICMP error

	 * or another process disconnected us.

	 */

	if (sk->sk_state == TCP_CLOSE)

		goto sock_error;

	/* sk->sk_err may be not zero now, if RECVERR was ordered by user

	 * and error was received after socket entered established state.

	 * Hence, it is handled normally after connect() return successfully.

	 */

/* 更新socket状态为连接已建立 */

	sock->state = SS_CONNECTED;

	err = 0;

out:

	return err;

sock_error:

	err = sock_error(sk) ? : -ECONNABORTED;

	sock->state = SS_UNCONNECTED;

	if (sk->sk_prot->disconnect(sk, flags))

		sock->state = SS_DISCONNECTING;

	goto out;

}

EXPORT_SYMB

static long inet_wait_for_connect(struct sock *sk, long timeo, int writebias)

{

	DEFINE_WAIT(wait);

/* 把等待任务加入到socket的等待队列头部，把进程的状态设为TASK_INTERRUPTIBLE */

	prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

	sk->sk_write_pending += writebias;

	/* Basic assumption: if someone sets sk->sk_err, he _must_

	 * change state of the socket from TCP_SYN_*.

	 * Connect() does not allow to get error notifications

	 * without closing the socket.

	 */

/* 完成三次握手后，状态就会变为TCP_ESTABLISHED，从而退出循环 */

	while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {

		release_sock(sk);

 /* 进入睡眠，直到超时或收到信号，或者被I/O事件处理函数唤醒。

         * 1. 如果是收到信号退出的，timeo为剩余的jiffies。

         * 2. 如果使用了SO_SNDTIMEO选项，超时退出后，timeo为0。

         * 3. 如果没有使用SO_SNDTIMEO选项，timeo为无穷大，即MAX_SCHEDULE_TIMEOUT，

         *      那么返回值也是这个，而超时时间不定。为了无限阻塞，需要上面的while循环。

         */

		timeo = schedule_timeout(timeo);

		lock_sock(sk);

/* 如果进程有待处理的信号，或者睡眠超时了，退出循环，之后会返回错误码 */

		if (signal_pending(current) || !timeo)

			break;

		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);

	}

 /* 等待结束时，把等待进程从等待队列中删除，把当前进程的状态设为TASK_RUNNING */

	finish_wait(sk_sleep(sk), &wait);

	sk->sk_write_pending -= writebias;

	return timeo;

}

/**/

进程的唤醒

 

三次握手中，当客户端收到SYNACK、发出ACK后，连接就成功建立了。

此时连接的状态从TCP_SYN_SENT或TCP_SYN_RECV变为TCP_ESTABLISHED，sock的状态发生变化，

会调用sock_def_wakeup()来处理连接状态变化事件，唤醒进程，connect()就能成功返回了。

sock_def_wakeup()的函数调用路径如下：

tcp_v4_rcv

tcp_v4_do_rcv

tcp_rcv_state_process

tcp_rcv_synsent_state_process

tcp_finish_connect

sock_def_wakeup

wake_up_interruptible_all

__wake_up

void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)

{

	struct tcp_sock *tp = tcp_sk(sk);

	struct inet_connection_sock *icsk = inet_csk(sk);

	tcp_set_state(sk, TCP_ESTABLISHED);

	------------------------

        ----------------------------   

	if (!sock_flag(sk, SOCK_DEAD)) {

		sk->sk_state_change(sk);---->// 指向sock_def_wakeup

/* 如果使用了异步通知，则发送SIGIO通知进程可写 */

		sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);

	}

}    

static inline void sk_wake_async(struct sock *sk, int how, int band)

{

	if (sock_flag(sk, SOCK_FASYNC))

		sock_wake_async(sk->sk_socket, how, band);

}

static void sock_def_wakeup(struct sock *sk)

{

	struct socket_wq *wq;

	rcu_read_lock();

	wq = rcu_dereference(sk->sk_wq);

	if (wq_has_sleeper(wq))

		wake_up_interruptible_all(&wq->wait);

	rcu_read_unlock();

}

//最终调用__wake_up_common()，由于nr_exclusive为0，会把此socket上所有的等待进程都唤醒

udp_prot 是 UDP 协议中所有自定义操作函数的集合。其 connect 的实现函数为 ip4_datagram_connect 。
其主要是设置了目的 IP 、端口和路由信息

int ip4_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)

{

	struct inet_sock *inet = inet_sk(sk);

	struct sockaddr_in *usin = (struct sockaddr_in *) uaddr;

	struct flowi4 *fl4;

	struct rtable *rt;

	__be32 saddr;

	int oif;

	int err;

	if (addr_len < sizeof(*usin))

		return -EINVAL;

	if (usin->sin_family != AF_INET)

		return -EAFNOSUPPORT;

	//复位路由高速缓冲区的入口地址

	sk_dst_reset(sk);

	lock_sock(sk);

	//和套接字绑定的网络设备索引号

	oif = sk->sk_bound_dev_if;

	saddr = inet->inet_saddr;

	//如果建立连接的地址是组传送地址，meiyou jiu 重新初始化oif和原地址

	if (ipv4_is_multicast(usin->sin_addr.s_addr)) {

		if (!oif)

			oif = inet->mc_index;

		if (!saddr)

			saddr = inet->mc_addr;

	}

	fl4 = &inet->cork.fl.u.ip4;

	/*

	调用ip_route_connet寻找路由，

	源路由主要根据源地址、源端口、目的地址、目的端口、输出网络设备额索引号，

	如果寻找路由失败就返回错误，如果寻找的路由是广播地址路由就要是否路由在高速

	缓冲区的入口并返回错误。寻找路由成功就把套接字的状态变量sk_state设置为TCP_ESTABLISHED，

	并把路由保存到套接字的sk->sk_dst_cache数据域

	*/

	rt = ip_route_connect(fl4, usin->sin_addr.s_addr, saddr,

			      RT_CONN_FLAGS(sk), oif,

			      sk->sk_protocol,

			      inet->inet_sport, usin->sin_port, sk, true);

	if (IS_ERR(rt)) {

		err = PTR_ERR(rt);

		if (err == -ENETUNREACH)

			IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);

		goto out;

	}

	//寻找的路由是广播地址路由，则释放该路由在路由缓冲区的入口

	if ((rt->rt_flags & RTCF_BROADCAST) && !sock_flag(sk, SOCK_BROADCAST)) {

		ip_rt_put(rt);

		err = -EACCES;

		goto out;

	}

	if (!inet->inet_saddr)//从路由表中获取的信息更新udp的原地址

		inet->inet_saddr = fl4->saddr;	/* Update source address */

	if (!inet->inet_rcv_saddr) {

		inet->inet_rcv_saddr = fl4->saddr;

		if (sk->sk_prot->rehash)

			sk->sk_prot->rehash(sk);

	}//更新目的地址和目的端口，源端口已经给定了

	inet->inet_daddr = fl4->daddr;

	inet->inet_dport = usin->sin_port;

	sk->sk_state = TCP_ESTABLISHED;

	inet->inet_id = jiffies;

	sk_dst_set(sk, &rt->dst);

	err = 0;

out:

	release_sock(sk);

	return err;

}

巴特西

Socket connect 等简要分析

connect 系统调用分析

最新文章

热门文章

巴特西

Socket connect 等简要分析

connect 系统调用 分析

最新文章

热门文章

connect 系统调用分析