主要内容：客户端调用connect()时的TCP层实现。
内核版本：3.15.2
我的博客：http://blog.csdn.net/zhangskd
connect的TCP层实现
SOCK_STREAM类socket的TCP层操作函数集实例为tcp_prot，其中客户端使用tcp_v4_connect()来发送SYN段。
struct proto tcp_prot = {
.name = "TCP",
...
.connect = tcp_v4_connect,
...
.h.hashinfo = &tcp_hashinfo,
...
};
tcp_v4_connect()主要做了以下事情：
1. 检查socket的地址长度和使用的协议族。
2. 查找路由缓存。
3. 设置本端的IP。
4. 如果传输控制块已经被使用过了，则重新初始化相关变量。
5. 记录服务器端的IP和端口。
6. 把连接的状态更新为TCP_SYN_SENT。
7. 选取本地端口，可以是未被使用过的端口，也可以是允许重用的端口。
这部有点复杂，下一篇会详细介绍。
8. 把sock链入本地端口的使用者哈希队列，把sock链入ehash哈希表。
9. 如果源端口或者目的端口发生改变，则需要重新查找路由。
10. 根据四元组，设置本端的初始序列号。
11. 根据初始序号和当前时间，设置IP首部ID字段值。
12. 构造一个SYN段，并发送出去。
/* This will initiate an outgoing connection. */ 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;
struc rtable *rt;
int err;
struct ip_options_rcu *inet_opt; /* Socket地址的长度不正确 */
if (addr_len < sizeof(struct sockaddr_in))
return -EINVAL; /* Socket地址的协议族不正确 */
if (usin->sin_family != AF_INET)
return -EAFNOSUPPORT; nexthop = daddr = usin->sin_addr.s_addr; /* 服务器IP */ inet_opt = rcu_dereference_protected(inet->inet_opt, sock_owned_by_user(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; /* 查找路由缓存项 */
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 == -ENETUREACH)
IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
return err;
} /* 不能使用类型为多播或广播的路由缓存 */
if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
ip_rt_put(rt);
return -ENETUNREACH;
} /* 如果没有使用源路由选项 */
if (! inet_opt || ! inet_opt->opt.srr)
daddr = fl4->daddr; /* 如果本端的源IP还没有设置 */
if (! inet->inet_saddr)
inet->inet_saddr = fl4->saddr;
inet->inet_rcv_saddr = 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; /* 使用TCP_REPAIR选项时，不会重置当前发送缓存的最后一个字节的序号 */
if (likely(! tp->repair))
tp->write_seq = 0; /* Tail +1 of data held in tcp send buffer */
} /* 如果启用了tcp_tw_recycle，那么从路由缓存中获取时间戳来初始化相关变量 */
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; /* 记录服务器端口 */
inet->inet_daddr = daddr; /* 记录服务器IP */
inet_csk(sk)->icsk_ext_hdr_len = 0; /* IP选项长度 */ if (inet_opt)
inet_csk(sk)->icsk_ext_hdr_len = inet_opt->opt.optlen; /* IP选项长度 */
tp->rx_opt.mss_clamp = TCP_MSS_DEFAULT; /* 默认对端的MSS，之后会更新 */ /* 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 complete
* initialization after this.
*/
tcp_set_state(sk, TCP_SYN_SENT); /* 把连接状态更新为TCP_SYN_SENT */ /* 选取本地端口，把sk链入端口的使用者队列，把sk链入ehash哈希表 */
err = inet_hash_connect(&tcp_death_row, sk);
if (err)
goto failure; /* 如果源端口或者目的端口发生改变，需要重新查找路由 */
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); /* 根据路由缓存，设置网卡的特性 */ /* 根据四元组，设置本端的初始序列号，计算方式和服务器端的一样。
* 如果使用了TCP_REPAIR选项，就不用重新计算。
*/
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; /* 根据初始序号和当前时间，设置IP首部ID字段值 */ err = tcp_connect(sk); /* 构造一个SYN段，并发送出去 */ 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;
}
SYN段的构造和发送
tcp_connect()用于构造和发送SYN段，主要做了以下事情：
1. 初始化传输控制块中和TCP层或连接相关的变量。
2. 申请一个skb，进行控制字段的初始化。
3. 把skb插入到发送队列的尾部，并更新相关的变量。
4. 调用发送函数，把skb传递到IP层。
5. 开启超时重传定时器，SYN段的初始超时时间为1s。
/* Build a SYN and send it off. */ int tcp_connect(struct sock *sk)
{
struct tcp_sock *tp = tcp_sk(sk);
struct sk_buff *buff;
int err; /* 初始化TCP控制块中的相关变量 */
tcp_connect_init(sk); /* 如果使用TCP_REPAIR选项，那么不发送SYN和等待SYNACK，而是直接进入成功状态 */
if (unlikely(tp->repair)) {
tcp_finsih_connect(sk, NULL);
} buff = alloc_skb_fclone(MAX_TCP_HEADER + 15, sk->sk_allocation);
if (unlikely(buff == NULL))
return -ENOBUFS; /* No buffer space available */ /* Reserve space for headers. 预留报文头部的空间*/
skb_reserve(buff, MAX_TCP_HEADER); /* 初始化不携带数据的skb的一些控制字段 */
tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
tp->retrans_stamp = TCP_SKB_CB(buff)->when = tcp_time_stamp; /* 记下SYN的发送时间 */
tcp_connect_queue_skb(sk, buff); /* 把skb加入到发送队列的尾部，并更新相关变量 */
TCP_ECN_send_syn(sk, buff); /* 设置ECN相关变量 */ /* 根据是否使用TCP Fast Open选项，来选择SYN段的发送函数 */
err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
if (err = -ECONNREFUSED) /* Connection refused */
return err; /* We change tp->snd_nxt after the tcp_transmit_skb() call in order to
* make this packet get counted in tcpOutSegs.
*/
tp->snd_nxt = tp->write_seq;
tp->pushed_seq = tp->write_seq; /* Last pushed seq, required to talk to windows */
TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS); /* Timer for repeating the SYN until an answer.
* 开启超时重传定时器，SYN段的初始超时时间为1s。
*/
inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
}
对tcp_sock和inet_connection_sock中的部分变量进行初始化。
/* Do all connect socket setups that can be done AF independent. */ static void tcp_connect_init(struct sock *sk)
{
const struct dst_entry *dst = __sk_dst_get(sk); /* 路由缓存 */
struct tcp_sock *tp = tcp_sk(sk);
__u8 rcv_wscale; /* We'll fix this up when we get a response from the other end.
* See tcp_input.c: tcp_rcv_state_process case TCP_SYN_SENT.
*/
tp->tcp_header_len = sizeof(struct tcphdr) +
(sysctl_tcp_timestamp ? TCPOLEN_TSTAMP_ALIGNED : 0); /* TCP报头长度，包含时间戳选项 */ #ifdef CONFIG_TCP_MD5SIG
if (tp->af_specific->md5_lookup(sk, sk) != NULL)
tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED; /* MD5SIG选项 */
#endif /* If user gave his TCP_MAXSEG, record it to clamp */
/* 如果用户通过TCP_MAXSEG选项设置了MSS上限 */
if (tp->rx_opt.user_mss)
tp->rx_opt.mss_clamp = tp->rx_opt.user_mss; /* 设置对端的接收MSS上限 */ tp->max_window = 0; /* 见过的对端最大接收窗口 */
tcp_mtup_init(sk); /* TCP的PMTU初始化 */
tcp_sync_mss(sk, dst_mtu(dst)); /* 更新MSS */ if (! tp->window_clamp) /* 本端接收窗口的上限 */
tp->window_clamp = dst_metric(dst, RTAX_WINDOW);
tp->advmss = dst_metric_advmss(dst); /* 本端在建立连接时通告的MSS */ if (tp->rx_opt.user_mss && tp->rx_opt.user_mss < tp->advmss)
tp->advmss = tp->rx_opt.user_mss; /* 不能超过用户设置的MSS */ tcp_initialize_rcv_mss(sk); /* 对端有效的发送MSS估算值做初始化 */ /* 如果用户使用SO_RCVBUF选项限制接收缓存。
* limit the window selection if the user enforce a smaller rx buffer.
*/
if (sk->sk_userlocks & SOCK_RCVBUF_LOCK &&
(tp->window_clamp > tcp_full_space(sk) || tp->window_clamp == 0))
tp->window_clamp = tcp_full_space(sk); /* 3/4 sk->sk_rcvbuf */ /* 获取接收窗口的初始值、窗口扩大因子和接收窗口的上限 */
tcp_select_initial_window(tcp_full_space(sk),
tp->advmss - (tp->rx_opt.ts_recent_stamp? tp->tcp_header_len - sizeof(struct tcphdr) : 0),
&tp->rcv_wnd,
&tp->window_clamp,
sysctl_tcp_window_scaling,
&rcv_wscale,
dst_metric(dst, RTAX_INITRWND)); tp->rx_opt.rcv_wscale = rcv_wscale; /* 设置接收窗口的扩大因子 */
tp->rcv_ssthresh = tp->rcv_wnd; sk->sk_err = 0;
sock_reset_flag(sk, SOCK_DONE);
tp->snd_wnd = 0;
tcp_init_wl(tp, 0); /* tp->snd_wl1为最近更新发送窗口的ACK段序号 */
tp->snd_una = tp->write_seq;
tp->snd_sml = tp->write_seq;
tp->snd_up = tp->write_seq;
tp->snd_nxt = tp->write_seq; if (likely(! tp->repair)) /* TCP Repair选项相关 */
tp->rcv_nxt = 0;
else
tp->rcv_tstamp = tcp_time_stamp; tp->rcv_wup = tp->rcv_nxt;
tp->copied_seq = tp->rcv_nxt; inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT; /* RTO的初始值为1s */
inet_csk(sk)->icsk_retransmits = 0;
tcp_clear_retrans(tp);
}
把skb加入到发送队列的尾部，并更新相关变量。
static void tcp_connect_queue_skb(struct sock *sk, struct sk_buff *skb)
{
struct tcp_sock *tp = tcp_sk(sk);
struct tcp_skb_cb *tcb = TCP_SKB_CB(skb); tcb->end_seq += skb->len;
skb_header_release(skb); /* 增加skb负荷部分的引用计数 */ __tcp_add_write_queue_tail(sk, skb); /* 把skb放入发送队列的尾部 */ /* sk_wmem_queued为发送队列的总大小，包含发送队列中skb数据区、
* sk_buff、sk_shared_info结构体，以及协议头等额外开销。
*/
sk->sk_wmem_queued += skb->truesize; /* 更新发送队列的总大小 */
sk_mem_charge(sk, skb->truesize); /* 减少预分配但未使用的内存 */ tp->write_seq += tcb->end_seq; /* 更新发送缓存中的最后一个字节序号(+1) */
tp->packets_out += tcp_skb_pcount(skb); /* 更新发送且未确认的数据段个数 */
}
/* skb_header_release - release reference to header
* @skb: buffer to operate on
*
* Drop a reference to the header part of the buffer.
* This is done by acquiring a payload reference.
* You must not read from the header part of skb->data after this.
*/
static inline void skb_header_release(struct sk_buff *skb)
{
BUG_ON(skb->nohdr);
skb->nohdr = 1; /* skb没有协议头 */ /* 增加skb负荷部分的引用计数 */
atomic_add(1 << SKB_DATAREF_SHIFT, &skb_shinfo(skb)->dataref);
} /* We divide dataref into two halves. The higher 16 bits hold references to
* the payload part of skb->data. The lower 16 bits hold references to the
* entire skb->data. A clone of a headerless skb holds the length of the header
* in skb->hdr_len.
*
* All users must obey the rule that the skb->data reference count must be greater
* than or equal to the payload reference count.
*
* Holding a reference to the payload part means that the user does not care about
* modifications to the header part of skb->data.
*/
#define SKB_DATAREF_SHIFT 16
#define SKB_DATAREF_MASK ((1 << SKB_DATAREF_SHIFT - 1)
SYN段的ECN标志设置。
/* Packet ECN state for a SYN. */ static inline void TCP_ECN_send_syn(struct sock *sk, struct sk_buff *skb)
{
struct tcp_sock *tp = tcp_sk(sk);
tp->ecn_flags = 0; /* 如果支持ECN */
if (sock_net(sk)->ipv4.sysctl_tcp_ecn == 1) {
TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
tp->ecn_flags = TCP_ECN_OK;
}
}