tcp 客户端 发送syn
简介
sys_connect->inet_stream_connect->inet_stream_connect->tcp_v4_connect->tcp_connect 对于tcp,inet_stream_connect()调用tcp_v4_connect发送三次握手的第一次syn请求， 并根据socket是否阻塞来决定是否调用inet_wait_for_connect来等待
tcp_v4_connect
- 调用ip_route_connect和ip_route_newports创建或者获取路由缓存，并决定发送地址/设备， 下一跳
- 更新状态机TCP_CLOSE->TCP_SYN_SENT
- inet_hash_connect(&tcp_death_row, sk); 如果socket没有bind到特定端口，这里选择端口进行bind, 如果是reuseport判断能否recycle tw
- tp->write_seq = secure_tcp_sequence_number() 生产初始seq序号
- tcp_connect()发送握手包
/* This will initiate an outgoing connection.
检查socket的地址长度和使用的协议族。
查找路由缓存。
设置本端的IP。
如果传输控制块已经被使用过了，则重新初始化相关变量。
记录服务器端的IP和端口。
把连接的状态更新为TCP_SYN_SENT。
选取本地端口，可以是未被使用过的端口，也可以是允许重用的端口。
把sock链入本地端口的使用者哈希队列，把sock链入ehash哈希表。
如果源端口或者目的端口发生改变，则需要重新查找路由。
根据四元组，设置本端的初始序列号。
根据初始序号和当前时间，设置IP首部ID字段值。
构造一个SYN段，并发送出去。
调用ip_route_connect和ip_route_newports创建或者获取路由缓存，并决定发送地址/设备， 下一跳
更新状态机TCP_CLOSE->TCP_SYN_SENT
inet_hash_connect(&tcp_death_row, sk); 如果socket没有bind到特定端口，这里选择端口进行bind, 如果是reuseport判断能否recycle tw
tp->write_seq = secure_tcp_sequence_number() 生产初始seq序号
tcp_connect()发送握手包
*/
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
struct inet_sock *inet = inet_sk(sk);
struct tcp_sock *tp = tcp_sk(sk);
__be16 orig_sport, orig_dport;
__be32 daddr, nexthop;
struct flowi4 *fl4;
struct rtable *rt;
int err;
struct ip_options_rcu *inet_opt;if (addr_len < sizeof(struct sockaddr_in))
return -EINVAL;if (usin->sin_family != AF_INET)
return -EAFNOSUPPORT;
//connect的时候s_addr里面对应的是目的地址，即对端ip地址
nexthop = daddr = usin->sin_addr.s_addr;
inet_opt = rcu_dereference_protected(inet->inet_opt,
lockdep_sock_is_held(sk));
if (inet_opt && inet_opt->opt.srr) {
if (!daddr)
return -EINVAL;
nexthop = inet_opt->opt.faddr;
}orig_sport = inet->inet_sport;
orig_dport = usin->sin_port;
fl4 = &inet->cork.fl.u.ip4;
/*根据fl4，查找或创建路由缓存
* 调用ip_route_connect()根据下一跳地址等信息查找目的路由缓存项，如果路由查找命中，则生成一个相应的路由缓存项，这个缓存项不但
* 可以用于当前待发送SYN段，而且对后续的所有数据包都可以起到一个加速路由查找的作用。
*/
rt = ip_route_connect(fl4, nexthop, inet->inet_saddr,
RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
IPPROTO_TCP,
orig_sport, orig_dport, sk);
if (IS_ERR(rt)) {
err = PTR_ERR(rt);
if (err == -ENETUNREACH)
IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
return err;
}
/*TCP不能使用类型为组播或多播的路由缓存项。*/
if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) { // tcp不支持多播和广播
ip_rt_put(rt);
return -ENETUNREACH;
}
/* 如果没有启用源路由选项，则使用获取到路由缓存项中的目的地址。*/
if (!inet_opt || !inet_opt->opt.srr)
daddr = fl4->daddr;
/* 如果还未设置传输控制块中的源地址，则使用路由缓存项中的源地址对其进行设置。*/
//这里说明了客户端在连接的时候可以不用指明本地IP地址，由路由缓存找到对应目的IP的时候，就可以确定本地IP地址了。
if (!inet->inet_saddr)
inet->inet_saddr = fl4->saddr;
sk_rcv_saddr_set(sk, inet->inet_saddr);
/* 如果传输控制块中的时间戳和目的地址已被使用过，则说明该传输控制块之前已建立连接并进行过通信，需重新初始化相关成员。 */
if (tp->rx_opt.ts_recent_stamp && inet->inet_daddr != daddr) {
/* Reset inherited state */
tp->rx_opt.ts_recent = 0;
tp->rx_opt.ts_recent_stamp = 0;
if (likely(!tp->repair))
tp->write_seq = 0;
}
/* 如果启用了sysctl_tw_recycle并接收过时间戳选项，从对端信息块中获取相应的值来初始化ts_recent_stamp和ts_recent。*/
if (tcp_death_row.sysctl_tw_recycle &&
!tp->rx_opt.ts_recent_stamp && fl4->daddr == daddr)
tcp_fetch_timewait_stamp(sk, &rt->dst);inet->inet_dport = usin->sin_port;
sk_daddr_set(sk, daddr);inet_csk(sk)->icsk_ext_hdr_len = 0;
if (inet_opt)
inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen;tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT;
/* Socket identity is still unknown (sport may be zero).
* However we set state to SYN-SENT and not releasing socket
* lock select source port, enter ourselves into the hash tables and
* complete initialization after this.
*/
/* 将TCP设置为SYN_SENT，动态绑定一个本地端口，并将传输控制块添加到ehash散列表中。由于在动态分配端口时，如果找到的是已使用的端口，则
* 需在TIME_WAIT状态中进行相应的确认，因此调用inet_hash_connect()时需用timewait传输控制块和参数管理器tcp_death_row作为参数。*/
tcp_set_state(sk, TCP_SYN_SENT);
//bind local port，tw_recycle
/*/没有bind端口，随机生成一个偏移，随机化端口分配过程*/
err = inet_hash_connect(&tcp_death_row, sk);
if (err)
goto failure;sk_set_txhash(sk);
rt = ip_route_newports(fl4, rt, orig_sport, orig_dport,
inet->inet_sport, inet->inet_dport, sk);
if (IS_ERR(rt)) {
err = PTR_ERR(rt);
rt = NULL;
goto failure;
}
/* OK, now commit destination to socket. */
sk->sk_gso_type = SKB_GSO_TCPV4;
sk_setup_caps(sk, &rt->dst);/*
* 如果write_seq字段值为零，则说明该传输控制块还
* 未设置初始序号，因此需调用secure_tcp_sequence_number()，
* 根据双方的地址、端口计算初始序列号，同时根据
* 发送需要和当前时间得到用于设置IP首部ID域的值。
*/
if (!tp->write_seq && likely(!tp->repair))
tp->write_seq = secure_tcp_sequence_number(inet->inet_saddr,
inet->inet_daddr,
inet->inet_sport,
usin->sin_port);inet->inet_id = tp->write_seq ^ jiffies;
err = tcp_connect(sk);
rt = NULL;
if (err)
goto failure;return 0;
failure:
/*
* This unhashes the socket and releases the local port,
* if necessary.
*/
tcp_set_state(sk, TCP_CLOSE);
ip_rt_put(rt);
sk->sk_route_caps = 0;
inet->inet_dport = 0;
return err;
}
EXPORT_SYMBOL(tcp_v4_connect);
- 对于已经bind端口的socket
- 判断是否有人reuseport， 如果只有自己bind到这个port， 则调用inet_ehash_nolisten(sk, NULL);插入ehash中
- 如果有其他人bind到这个端口，则调用__inet_check_established，
-确认其他人是否在ehash中，不在ehash中，则可以使用这个port
-在ehash中，并存在满足五元组的timewait状态sk，则调用tcp_twsk_unique判断是否能被回收
-在ehash中，但是满足五元组的sk不是timewait状态，则不能使用这个port来connect。 这个就说明了两个tcp connect(), 开启reuseport后bind到相同端口，bind()能成功，但是第二个connect会失败
- 对于没有bind端口的socket, 则需要尝试分配端口
- inet_sk_port_offset随机生成一个port_offset, 通过port_offset来保证端口搜索区间的随机性， 遍历这个区间，尝试分配
- 在bhash中查找是否有其他socket bind到这个端口上，没有则表示可以分配
- 如果有其他socket在相同的bhash bucket上，调用__inet_check_established来确认是否能分配这个端口， 过程同上
- 分配成功后inet_bind_hash,设置端口和bhash， 并调用inet_ehash_nolisten插入ehash中
- 如果需要，还需要释放tw socket
/*
* Bind a port for a connect operation and hash it.
*/
/*
* inet_hash_connect()主要用于在主动连接时动态绑定一个端口。
* 1)在动态端口范围内，从通过源地址、目的地址和目的端口
* 计算得到的偏移开始，确认一个可用的端口号
* 2)如果该端口已使用，则进而确定该端口是否能使用，不能
* 则递增端口号继续确认；能使用则可用端口已找到。
* 3)如果该端口未使用，则可使用该端口
* 4)最后完成绑定过程。
*/
/* 动态绑定一个本地端口，并将传输控制块添加到ehash散列表中。由于在动态分配端口时，如果找到的是已使用的端口，则
* 需在TIME_WAIT状态中进行相应的确认，因此调用inet_hash_connect()时需用timewait传输控制块和参数管理器tcp_death_row作为参数。*/
//这里面会把sk添加到ehash中，虽然连接还没建立起来。该函数外的tcp_connect才是真正发送SYN报文的地方
int inet_hash_connect(struct inet_timewait_death_row *death_row,
struct sock *sk)
{
return __inet_hash_connect(death_row, sk, inet_sk_port_offset(sk),
__inet_check_established, __inet_hash_nolisten);
}
/*从这个函数的实现可以看出，主要是由于可用的端口被占满了，所以找不到一个可用的端口，导致连接失败。
运行netstat可以发现确实存在很多TIME_WAIT状态的socket，这些socket将可用端口占满了。
netstat -n | awk '/^tcp/ {++state[$NF]} END {for(key in state)
print key,"\t",state[key]}'
TIME_WAIT 26837
ESTABLISHED 30
*/
//参考:http://www.yunstorage.org/%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B/socket-connect-error-99cannot-assign-requested-address/
//如果快速回收TIME_WAIT状态的端口
int __inet_hash_connect(struct inet_timewait_death_row *death_row,
struct sock *sk, u32 port_offset,
int (*check_established)(struct inet_timewait_death_row *,
struct sock *, __u16, struct inet_timewait_sock **))
{
struct inet_hashinfo *hinfo = death_row->hashinfo;
/* 通过tcp_death_row中的成员hashinfo，获取指向TCP中散列表管理器hashinfo。 */
struct inet_timewait_sock *tw = NULL;
struct inet_bind_hashbucket *head;
int port = inet_sk(sk)->inet_num;
struct net *net = sock_net(sk);
struct inet_bind_bucket *tb;
u32 remaining, offset;
int ret, i, low, high;
static u32 hint;
if (port) {//如果是应用程序bind的时候指定了端口，则无需端口复用检查。
head = &hinfo->bhash\[inet\_bhashfn(net, port,
hinfo->bhash\_size)\];
tb = inet\_csk(sk)->icsk\_bind\_hash;
spin\_lock\_bh(&head->lock);
if (sk\_head(&tb->owners) == sk && !sk->sk\_bind\_node.next) {//也就是说只有自己bind到这个端口， 没有reuseport
inet\_ehash\_nolisten(sk, NULL);//插入ehash
spin\_unlock\_bh(&head->lock);
return 0;
}
spin\_unlock(&head->lock);
/\* No definite answer... Walk to established hash table \*/
//否则检查ehash,查看bind到相同端口的socket是否进入timewait，进入timewait则判断是否能recycle，否则就是说还在连接状态或是没在ehash中
ret = check\_established(death\_row, sk, port, NULL);
local\_bh\_enable();
return ret;
}
inet\_get\_local\_port\_range(net, &low, &high);
high++; /\* \[32768, 60999\] -> \[32768, 61000\[ \*/
remaining = high - low;
if (likely(remaining > 1))
remaining &= ~1U;
offset = (hint + port\_offset) % remaining;
/\* In first pass we try ports of @low parity.
\* inet\_csk\_get\_port() does the opposite choice.
\*/
offset &= ~1U; other_parity_scan:
port = low + offset;
for (i = 0; i < remaining; i += 2, port += 2) {
if (unlikely(port >= high))
port -= remaining;
if (inet_is_local_reserved_port(net, port))
continue;
head = &hinfo->bhash[inet_bhashfn(net, port,
hinfo->bhash_size)];
spin_lock_bh(&head->lock);
/\* Does not bother with rcv\_saddr checks, because
\* the established check is already unique enough.
\*/
inet\_bind\_bucket\_for\_each(tb, &head->chain) {
if (net\_eq(ib\_net(tb), net) && tb->port == port) {
if (tb->fastreuse >= 0 ||
tb->fastreuseport >= 0)
goto next\_port;
WARN\_ON(hlist\_empty(&tb->owners));
if (!check\_established(death\_row, sk,
port, &tw))//在ehash中查找timewait，如果满足五元组，并调用tcp\_twsk\_unique判断
goto ok;
goto next\_port;
}
}
tb = inet\_bind\_bucket\_create(hinfo->bind\_bucket\_cachep,
net, head, port);
if (!tb) {
spin\_unlock\_bh(&head->lock);
return -ENOMEM;
}
tb->fastreuse = -1;
tb->fastreuseport = -1;
goto ok; next_port:
spin_unlock_bh(&head->lock);
cond_resched();
}
offset++;
if ((offset & 1) && remaining > 1)
goto other\_parity\_scan;
return -EADDRNOTAVAIL;ok:
hint += i + 2;
/\* Head lock still held and bh's disabled \*/
inet\_bind\_hash(sk, tb, port);//设置snum和tb
if (sk\_unhashed(sk)) {
inet\_sk(sk)->inet\_sport = htons(port);
inet\_ehash\_nolisten(sk, (struct sock \*)tw);//删除tw，插入sk
}
if (tw)
inet\_twsk\_bind\_unhash(tw, hinfo);//删除tw的bind关系
spin\_unlock(&head->lock);
if (tw)
inet\_twsk\_deschedule\_put(tw);//回收tw
local\_bh\_enable();
return 0; }
手机扫一扫
移动阅读更方便
你可能感兴趣的文章