当connect作用于流套接字的时候，是地址指明的对端建立连接，对于TCP来讲，connect会完成与对端的三次握手建立连接的过程；当connect作用于数据报套接字的时候，用于指明发送的对端地址，并且只能向该地址发送数据，指明之后，可以使用send等发送数据，无需使用sendto的参数再次指明发送地址；
/*
* 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; /* 找到socket */
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (!sock)
goto out; /* 地址复制到内核 */
err = move_addr_to_kernel(uservaddr, addrlen, &address);
if (err < )
goto out_put; /* 安全检查 */
err =
security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
if (err)
goto out_put; /* 调用对应类型的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;
}
建立连接过程中会根据socket的状态做不同的处理，连接并不一定马上完成，所以其也会有从连接中，到连接成功的状态转移；其中还包含了对阻塞socket和非阻塞socket的处理；tcp层的connect实现后续阅读过程中会进行补充；
/*
* 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, int is_sendmsg)
{
struct sock *sk = sock->sk;
int err;
long timeo; /*
* uaddr can be NULL and addr_len can be 0 if:
* sk is a TCP fastopen active socket and
* TCP_FASTOPEN_CONNECT sockopt is set and
* we already have a valid cookie for this socket.
* In this case, user can call write() after connect().
* write() will invoke tcp_sendmsg_fastopen() which calls
* __inet_stream_connect().
*/
/* 地址存在 */
if (uaddr) { /* 检查地址长度 */
if (addr_len < sizeof(uaddr->sa_family))
return -EINVAL; /* 对unspec的特殊处理 */
if (uaddr->sa_family == AF_UNSPEC) {
err = sk->sk_prot->disconnect(sk, flags);
sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
goto out;
}
} /* 根据socket状态对应处理 */
switch (sock->state) {
default:
err = -EINVAL;
goto out;
/* 已连接 */
case SS_CONNECTED:
err = -EISCONN;
goto out;
/* 正在连接 */
case SS_CONNECTING:
/* 对是否发消息做不同处理，fastopen*/
if (inet_sk(sk)->defer_connect)
err = is_sendmsg ? -EINPROGRESS : -EISCONN;
else
err = -EALREADY;
/* Fall out of switch with err, set for this state */
break;
/* 未连接 */
case SS_UNCONNECTED:
err = -EISCONN;
/* 需要为closed状态 */
if (sk->sk_state != TCP_CLOSE)
goto out; /* 传输层协议的connect */
err = sk->sk_prot->connect(sk, uaddr, addr_len);
if (err < )
goto out; /* 标记状态为正在连接 */
sock->state = SS_CONNECTING; /* fastopen */
if (!err && inet_sk(sk)->defer_connect)
goto out; /* Just entered SS_CONNECTING state; the only
* difference is that return value in non-blocking
* case is EINPROGRESS, rather than EALREADY.
*/
/* 非阻塞情况返回inprogress，阻塞返回already */
err = -EINPROGRESS;
break;
} /* 阻塞情况下需要获取超时时间，非阻塞为0 */
timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); /* 已发送或者已收到syn */
if (( << 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 ? : ; /* Error code is set above */
/* 非阻塞退出，阻塞则等待连接，等待剩余时间为0，退出 */
if (!timeo || !inet_wait_for_connect(sk, timeo, writebias))
goto out; /* 处理信号，达到最大调度时间或者被打断 */
err = sock_intr_errno(timeo);
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.
*/ /* 设置为连接状态 */
sock->state = SS_CONNECTED;
err = ;
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;
}
对于阻塞socket，需要加入到等待队列中，等待连接完成；
/* 阻塞等待连接 */
static long inet_wait_for_connect(struct sock *sk, long timeo, int writebias)
{
DEFINE_WAIT_FUNC(wait, woken_wake_function); /* 添加到等待队列 */
add_wait_queue(sk_sleep(sk), &wait);
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.
*/
/* 等待连接状态改变 */
while (( << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
release_sock(sk);
timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
lock_sock(sk);
if (signal_pending(current) || !timeo)
break;
} /* 从等待队列移除 */
remove_wait_queue(sk_sleep(sk), &wait);
sk->sk_write_pending -= writebias;
return timeo;
}