Linux TCP/IP 协议栈之 Socket的实现分析(Connect客户端发起连接请求)

简介: sys_connect对于客户端来说,当创建了一个套接字后,就可以连接它了。                case SYS_CONNECT:                         err = sys_connect(a0, (struct sockaddr __user ...
sys_connect

对于客户端来说,当创建了一个套接字后,就可以连接它了。
               case SYS_CONNECT:
                        err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
                        break;
 
asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
{
        struct socket *sock;
        char address[MAX_SOCK_ADDR];
        int err;
 
        sock = sockfd_lookup(fd, &err);
        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;
 
        err = sock->ops->connect(sock, (struct sockaddr *) address, addrlen,
                                 sock->file->f_flags);
out_put:
        sockfd_put(sock);
out:
        return err;
}[/code]
 
跟其它操作类似,sys_connect 接着调用 inet_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)
{
        struct sock *sk = sock->sk;
        int err;
        long timeo;
 
        lock_sock(sk);
 
        if (uaddr->sa_family == AF_UNSPEC) {
                err = sk->sk_prot->disconnect(sk, flags);
                sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
                goto out;
        }
 
提交的协议簇不正确,则断开连接。
 
switch (sock->state) {
        default:
                err = -EINVAL;
                goto out;
        case SS_CONNECTED:
                err = -EISCONN;
                goto out;
        case SS_CONNECTING:
                err = -EALREADY;
                /* Fall out of switch with err, set for this state */
                break;

        socket 处于不正确的连接状态,返回相应的错误值。
 
        case SS_UNCONNECTED:
                err = -EISCONN;
                if (sk->sk_state != TCP_CLOSE)
                        goto out;

                /*调用协议的连接函数*/
                err = sk->sk_prot->connect(sk, uaddr, addr_len);
                if (err                         goto out;

                /*协议方面的工作已经处理完成了,但是自己的一切工作还没有完成,所以切换至正在连接中*/
                 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;
        }
 
对于 TCP的实际的连接,是通过调用 tcp_v4_connect()函数来实现的。
 
tcp_v4_connect函数

对于 TCP 协议来说,其连接实际上就是发送一个 SYN 报文,在服务器的应答到来时,回答它一
个 ack 报文,也就是完成三次握手中的第一和第三次。
 
要发送 SYN 报文,也就是说,需要有完整的来源/目的地址,来源/目的端口,目的地址/端口由用户
态提交,但是问题是没有自己的地址和端口,因为并没有调  用过 bind(2),一台主机,对于端口,
可以像 sys_bind()那样,从本地未用端口中动态分配一个,那地址呢?因为一台主机可能会存在多
个 IP地  址,如果随机动态选择,那么有可能选择一个错误的来源地址,将不能正确地到达目的地
址。换句话说,来源地址的选择,是与路由相关的。
 
调用路由查找的核心函数 ip_route_output_slow(),在没有提供来源地址的情况下,会根据实际情况,
调用 inet_select_addr()函数来选择一个合适的。同时,如果路由查找命中,会生成一个相应的路由
缓存项,这个缓存项,不但对当前发送SYN报文有意义,对于后续的所有数据包,都可以起到一
个加速路由查找的作用。这一任务,是通过 ip_route_connect()函数完成的,它返回相应的路由缓存
项(也就是说,来源地址也在其中了):
 
static inline int ip_route_connect(struct rtable **rp, u32 dst,
                                   u32 src, u32 tos, int oif, u8 protocol,
                                   u16 sport, u16 dport, struct sock *sk)
{         struct flowi fl = { .oif = oif,
                            .nl_u = { .ip4_u = { .daddr = dst,
                                                 .saddr = src,
                                                 .tos   = tos } },
                            .proto = protocol,
                            .uli_u = { .ports =
                                       { .sport = sport,
                                         .dport = dport } } };
 
        int err;
        if (!dst || !src) {
                err = __ip_route_output_key(rp, &fl);
                if (err)
                        return err;
                fl.fl4_dst = (*rp)->rt_dst;
                fl.fl4_src = (*rp)->rt_src;
                ip_rt_put(*rp);
                *rp = NULL;
        }
        return ip_route_output_flow(rp, &fl, sk, 0);
}
 
首先,构建一个搜索 key fl,在搜索要素中,来源地址/端口是不存在的。所以,当通过__ip_route_output_key
进行查找时,第一次是不会命中缓存的。 __ip_route_output_key 将继续调用ip_route_output_slow()函数,
在路由表中搜索,并返回一个合适的来源地址,  并且生成一个路由缓存项。 路由查找的更多细节,我会在另一个贴子
中来分析。
 
/* This will initiate an outgoing connection. */
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
        struct inet_sock *inet = inet_sk(sk);
        struct tcp_sock *tp = tcp_sk(sk);
        struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
        struct rtable *rt;
        u32 daddr, nexthop;
        int tmp;
        int err;
 
        if (addr_len                 return -EINVAL;
 
        if (usin->sin_family != AF_INET)
                return -EAFNOSUPPORT;[/code] 校验地址长度和协议簇。
 
        nexthop = daddr = usin->sin_addr.s_addr;[/code]
        将下一跳地址和目的地址的临时变量都暂时设为用户提交的地址。
 
        if (inet->opt && inet->opt->srr) {
                if (!daddr)
                        return -EINVAL;
                nexthop = inet->opt->faddr;
        }
        如果使用了来源地址路由,选择一个合适的下一跳地址。
 
        tmp = ip_route_connect(&rt, nexthop, inet->saddr,
                               RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
                               IPPROTO_TCP,
                               inet->sport, usin->sin_port, sk);
        if (tmp                 return tmp;
 
        if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
                ip_rt_put(rt);
                return -ENETUNREACH;
        }[/code]
        进行路由查找,并校验返回的路由的类型,TCP是不被允许使用多播和广播的。
 
        if (!inet->opt || !inet->opt->srr)
                daddr = rt->rt_dst;[/code]
        更新目的地址临时变量——使用路由查找后返回的值。
 
        if (!inet->saddr)
                inet->saddr = rt->rt_src;
        inet->rcv_saddr = inet->saddr;[/code]
        如果还没有设置源地址,和本地发送地址,则使用路由中返回的值。
 
        if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
                /* Reset inherited state */
                tp->rx_opt.ts_recent           = 0;
                tp->rx_opt.ts_recent_stamp = 0;
                tp->write_seq                   = 0;
        }
 
        if (sysctl_tcp_tw_recycle &&
            !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
                struct inet_peer *peer = rt_get_peer(rt); 
                /* VJ's idea. We save last timestamp seen from
                 * the destination in peer table, when entering state TIME-WAIT
                 * and initialize rx_opt.ts_recent from it, when trying new connection.
                 */
 
                if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
                        tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
                        tp->rx_opt.ts_recent = peer->tcp_ts;
                }
        }
        这个更新初始状态方面的内容,还没有去分析它。
 
        inet->dport = usin->sin_port;
        inet->daddr = daddr;
        保存目的地址及端口。
 
        tp->ext_header_len = 0;
        if (inet->opt)
                tp->ext_header_len = inet->opt->optlen;
 
        tp->rx_opt.mss_clamp = 536;
        设置最小允许的mss值

        tcp_set_state(sk, TCP_SYN_SENT);
        套接字状态被置为 TCP_SYN_SENT,
 
        err = tcp_v4_hash_connect(sk);
        if (err)
                goto failure;
        动态选择一个本地端口,并加入 hash 表,与bind(2)选择端口类似。
 
        err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
        if (err)
                goto failure;
 
        /* OK, now commit destination to socket.  */
        __sk_dst_set(sk, &rt->u.dst);
        tcp_v4_setup_caps(sk, &rt->u.dst);
        因为本地端口已经改变,使用新端口,重新查找路由,并用新的路由缓存项更新 sk 中保存的路由缓存项。
 
        if (!tp->write_seq)
                tp->write_seq = secure_tcp_sequence_number(inet->saddr,                                                            inet->daddr,
                                                           inet->sport,
                                                           usin->sin_port);[/code]
        为 TCP报文计算一个 seq值(实际使用的值是 tp->write_seq+1)。
 
        inet->id = tp->write_seq ^ jiffies;
 
        err = tcp_connect(sk);
        rt = NULL;
        if (err)
                goto failure;
 
        return 0;
        tp_connect()函数用来根据 sk 中的信息,构建一个完成的 syn 报文,并将它发送出去。
        在分析 tcp栈的实现时再来分析它。
 
根据 TCP协议,接下来的问题是,
1. 可能收到了服务器的应答,则要回送一个 ack 报文;
2. 如果超时还没有应答,则使用超时重发定时器;

相关文章
|
3天前
|
存储 Python
Python网络编程基础(Socket编程)UDP客户端编程
【4月更文挑战第9天】在UDP通信中,客户端负责发送数据到服务器,并接收来自服务器的响应。与服务器不同,客户端通常不需要绑定到特定的地址和端口,因为它可以临时使用任何可用的端口来发送数据。下面,我们将详细讲解UDP客户端编程的基本步骤。
|
3天前
|
存储 算法 Linux
【实战项目】网络编程:在Linux环境下基于opencv和socket的人脸识别系统--C++实现
【实战项目】网络编程:在Linux环境下基于opencv和socket的人脸识别系统--C++实现
67 7
|
3天前
|
网络协议 Linux Python
Python网络编程基础(Socket编程)epoll在Linux下的使用
【4月更文挑战第12天】在上一节中,我们介绍了使用`select`模块来实现非阻塞IO的方法。然而,`select`模块在处理大量并发连接时可能会存在性能问题。在Linux系统中,`epoll`机制提供了更高效的IO多路复用方式,能够更好地处理大量并发连接。
|
1天前
|
存储 前端开发 网络协议
所有的 Web 应用其实就是一个 socket 服务端, 而用户使用的浏览器就是一个 socket 客户端程序
所有的 Web 应用其实就是一个 socket 服务端, 而用户使用的浏览器就是一个 socket 客户端程序
5 0
|
3天前
|
网络协议
Socket实现服务器和客户端(手把手教会)
Socket实现服务器和客户端(手把手教会)
|
3天前
|
算法 Linux 调度
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(一)--实时端socket创建流程
xenomai与普通linux进程之间通讯XDDP(一)--实时端socket创建流程
22 1
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(一)--实时端socket创建流程
|
3天前
|
存储 算法 网络协议
【探索Linux】P.26(网络编程套接字基本概念—— socket编程接口 | socket编程接口相关函数详细介绍 )
【探索Linux】P.26(网络编程套接字基本概念—— socket编程接口 | socket编程接口相关函数详细介绍 )
13 0
|
3天前
|
网络协议 Linux Windows
TCP/IP、Http、Socket之间的区别
TCP/IP、Http、Socket之间的区别
|
3天前
|
网络协议 Ubuntu Unix
Linux 下使用 socket 实现 TCP 客户端
Linux 下使用 socket 实现 TCP 客户端
|
3天前
|
网络协议 Ubuntu Unix
Linux 下使用 socket 实现 TCP 服务端
Linux 下使用 socket 实现 TCP 服务端