深入理解 Linux 的 TCP 三次握手

测试dali协议的软件,DALI2.0和DALI1.0完美兼容同一个模块,测试每项可过协议 DALI2.0和DALI1.0完美兼容同一个模块,测试每项可过协议深圳聚积智能 夏先生 13246760327 QQ 349098308■IEC62386-102(V2.0)通过测试内容IEC62386-102/2.1/Test preambleIEC62386-102/3.1/Polarity testIEC62386-102/3.2/Maximum and minimum system v... 阅读详情

在后端相关岗位的入职面试中,三次握手的出场频率非常的高,甚至说它是必考题也不为过。一般的答案都是说客户端如何发起 SYN 握手进入 SYN_SENT 状态,服务器响应 SYN 并回复 SYNACK,然后进入 SYN_RECV 等诸如此类。但今天我想给出一份不一样的答案。

其实三次握手在内核的实现中,并不只是简单的状态的流转,还包括端口选择,半连接队列、syncookie、全连接队列、重传计时器等关键操作。如果能深刻理解这些,你对线上把握和理解将更进一步。如果有面试官问起你三次握手,相信这份答案一定能帮你在面试官面前赢得非常多的加分。

在基于 TCP 的服务开发中,三次握手的主要流程图如下:

​

编辑

添加图片注释,不超过 140 字(可选)

服务器中的核心代码是创建 socket,绑定端口,listen 监听,最后 accept 接收客户端的请求。

//服务端核心代码
int main(int argc, char const *argv[])
{
 int fd = socket(AF_INET, SOCK_STREAM, 0);
 bind(fd, ...);
 listen(fd, 128);
 accept(fd, ...);
 ...
}

客户端的相关代码是创建 socket,然后调用 connect 连接 server。

//客户端核心代码
int main(){
 fd = socket(AF_INET,SOCK_STREAM, 0);
 connect(fd, ...);
 ...
}

看起来简单的几个系统调用,实际上却包含了非常复杂的内核底层操作。根据内核工作原理,我深度展开一下三次握手过程中的内部操作。

友情提示:本文中内核源码会比较多。如果你能理解的了更好,如果觉得理解起来有困难,那直接重点看本文中的描述性的文字,尤其是加粗部分的即可。另外文章最后有一张总结图归纳和整理了全文内容。

一、服务器的 listen

我们都知道,服务器在开始提供服务之前都需要先 listen 一下。但 listen 内部究竟干了啥,我们平时很少去琢磨。

今天就让我们详细来看看,直接上一段 listen 时执行到的内核代码。

//file: net/core/request_sock.c
int reqsk_queue_alloc(struct request_sock_queue *queue,
     unsigned int nr_table_entries)
{
 size_t lopt_size = sizeof(struct listen_sock);
 struct listen_sock *lopt;

 //计算半连接队列的长度
 nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);
 nr_table_entries = ......

 //为半连接队列申请内存
 lopt_size += nr_table_entries * sizeof(struct request_sock *);
 if (lopt_size > PAGE_SIZE)
  lopt = vzalloc(lopt_size);
 else
  lopt = kzalloc(lopt_size, GFP_KERNEL);

 //全连接队列头初始化
 queue->rskq_accept_head = NULL;

 //半连接队列设置
 lopt->nr_table_entries = nr_table_entries;
 queue->listen_opt = lopt;
 ......
}

在这段代码里,内核计算了半连接队列的长度。然后据此算出半连接队列所需要的实际内存大小,开始申请用于管理半连接队列对象的内存(半连接队列需要快速查找,所以内核是用哈希表来管理半连接队列的,具体在 listen_sock 下的 syn_table 下)。最后将半连接队列挂到了接收队列 queue 上。

另外 queue->rskq_accept_head 代表的是全连接队列,它是一个链表的形式。在 listen 这里因为还没有连接,所以将全连接队列头 queue->rskq_accept_head 设置成 NULL。

当全连接队列和半连接队列中有元素的时候,他们在内核中的结构图大致如下。

在服务器 listen 的时候,主要是进行了全/半连接队列的长度限制计算,以及相关的内存申请和初始化。全/连接队列初始化了以后才可以相应来自客户端的握手请求。

【文章福利】另外小编还整理了一些C++后台开发面试题,教学视频,后端学习路线图免费分享,需要的可以自行添加:群720209036 点击加入~ 群文件共享

小编强力推荐C++后台开发免费学习地址:C/C++Linux服务器开发高级架构师/C++后台开发架构师​icon-default.png?t=M666https://ke.qq.com/course/417774?flowToken=1013189

​二、客户端 connect

客户端通过调用 connect 来发起连接。在 connect 系统调用中会进入到内核源码的 tcp_v4_connect。

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
 //设置 socket 状态为 TCP_SYN_SENT
 tcp_set_state(sk, TCP_SYN_SENT);

 //动态选择一个端口
 err = inet_hash_connect(&tcp_death_row, sk);

 //函数用来根据 sk 中的信息,构建一个完成的 syn 报文,并将它发送出去。
 err = tcp_connect(sk);
}

在这里将完成把 socket 状态设置为 TCP_SYN_SENT。再通过 inet_hash_connect 来动态地选择一个可用的端口后(端口选择详细过程参考前文《TCP 连接中客户端的端口号是如何确定的?》),进入到 tcp_connect 中。

//file:net/ipv4/tcp_output.c
int tcp_connect(struct sock *sk)
{
 tcp_connect_init(sk);

 //申请 skb 并构造为一个 SYN 包
 ......

 //添加到发送队列 sk_write_queue 上
 tcp_connect_queue_skb(sk, buff);

 //实际发出 syn
 err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
    tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);

 //启动重传定时器
 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
      inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
}

在 tcp_connect 申请和构造 SYN 包,然后将其发出。同时还启动了一个重传定时器,该定时器的作用是等到一定时间后收不到服务器的反馈的时候来开启重传。在 3.10 版本中首次超时时间是 1 s,一些老版本中是 3 s。

总结一下,客户端在 connect 的时候,把本地 socket 状态设置成了 TCP_SYN_SENT,选了一个可用的端口,接着发出 SYN 握手请求并启动重传定时器。

三、服务器响应 SYN

在服务器端,所有的 TCP 包(包括客户端发来的 SYN 握手请求)都经过网卡、软中断,进入到 tcp_v4_rcv。在该函数中根据网络包(skb)TCP 头信息中的目的 IP 信息查到当前在 listen 的 socket。然后继续进入 tcp_v4_do_rcv 处理握手过程。

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
 ...
 //服务器收到第一步握手 SYN 或者第三步 ACK 都会走到这里
 if (sk->sk_state == TCP_LISTEN) {
  struct sock *nsk = tcp_v4_hnd_req(sk, skb);
 }

 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
  rsk = sk;
  goto reset;
 }
}

在 tcp_v4_do_rcv 中判断当前 socket 是 listen 状态后,首先会到 tcp_v4_hnd_req 去查看半连接队列。服务器第一次响应 SYN 的时候,半连接队列里必然是空空如也,所以相当于什么也没干就返回了。

//file:net/ipv4/tcp_ipv4.c
static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
 // 查找 listen socket 的半连接队列
 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
          iph->saddr, iph->daddr);
 ...
 return sk;
}

在 tcp_rcv_state_process 里根据不同的 socket 状态进行不同的处理。

//file:net/ipv4/tcp_input.c
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
     const struct tcphdr *th, unsigned int len)
{
 switch (sk->sk_state) {
  //第一次握手
  case TCP_LISTEN:
   if (th->syn) { //判断是 SYN 握手包
    ...
    if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
     return 1;
 ......
}

其中 conn_request 是一个函数指针,指向 tcp_v4_conn_request。服务器响应 SYN 的主要处理逻辑都在这个 tcp_v4_conn_request 里。

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
{
 //看看半连接队列是否满了
 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
  want_cookie = tcp_syn_flood_action(sk, skb, "TCP");
  if (!want_cookie)
   goto drop;
 }

 //在全连接队列满的情况下,如果有 young_ack,那么直接丢
 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
  NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
  goto drop;
 }
 ...
 //分配 request_sock 内核对象
 req = inet_reqsk_alloc(&tcp_request_sock_ops);

 //构造 syn+ack 包
 skb_synack = tcp_make_synack(sk, dst, req,
  fastopen_cookie_present(&valid_foc) ? &valid_foc : NULL);

 if (likely(!do_fastopen)) {
  //发送 syn + ack 响应
  err = ip_build_and_send_pkt(skb_synack, sk, ireq->loc_addr,
    ireq->rmt_addr, ireq->opt);

  //添加到半连接队列,并开启计时器
  inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
 }else ...
}

在这里首先判断半连接队列是否满了,如果满了的话进入 tcp_syn_flood_action 去判断是否开启了 tcp_syncookies 内核参数。如果队列满,且未开启 tcp_syncookies,那么该握手包将直接被丢弃!!

接着还要判断全连接队列是否满。因为全连接队列满也会导致握手异常的,那干脆就在第一次握手的时候也判断了。如果全连接队列满了,且有 young_ack 的话,那么同样也是直接丢弃。

young_ack 是半连接队列里保持着的一个计数器。记录的是刚有 SYN 到达,没有被 SYN_ACK 重传定时器重传过 SYN_ACK,同时也没有完成过三次握手的 sock 数量

接下来是构造 synack 包,然后通过 ip_build_and_send_pkt 把它发送出去。

最后把当前握手信息添加到半连接队列,并开启计时器。计时器的作用是如果某个时间之内还收不到客户端的第三次握手的话,服务器会重传 synack 包。

总结一下,服务器响应 ack 是主要工作是判断下接收队列是否满了,满的话可能会丢弃该请求,否则发出 synack。申请 request_sock 添加到半连接队列中,同时启动定时器。

四、客户端响应 SYNACK

客户端收到服务器端发来的 synack 包的时候,也会进入到 tcp_rcv_state_process 函数中来。不过由于自身 socket 的状态是 TCP_SYN_SENT,所以会进入到另一个不同的分支中去。

//file:net/ipv4/tcp_input.c
//除了 ESTABLISHED 和 TIME_WAIT,其他状态下的 TCP 处理都走这里
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
     const struct tcphdr *th, unsigned int len)
{
 switch (sk->sk_state) {
  //服务器收到第一个ACK包
  case TCP_LISTEN:
   ...
  //客户端第二次握手处理
  case TCP_SYN_SENT:
   //处理 synack 包
   queued = tcp_rcv_synsent_state_process(sk, skb, th, len);
   ...
   return 0;
}

tcp_rcv_synsent_state_process 是客户端响应 synack 的主要逻辑。

//file:net/ipv4/tcp_input.c
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
      const struct tcphdr *th, unsigned int len)
{
 ...

 tcp_ack(sk, skb, FLAG_SLOWPATH);

 //连接建立完成
 tcp_finish_connect(sk, skb);

 if (sk->sk_write_pending ||
   icsk->icsk_accept_queue.rskq_defer_accept ||
   icsk->icsk_ack.pingpong)
  //延迟确认...
 else {
  tcp_send_ack(sk);
 }
}

tcp_ack()->tcp_clean_rtx_queue()

//file: net/ipv4/tcp_input.c
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
       u32 prior_snd_una)
{
 //删除发送队列
 ...

 //删除定时器
 tcp_rearm_rto(sk);
}

//file: net/ipv4/tcp_input.c
void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
{
 //修改 socket 状态
 tcp_set_state(sk, TCP_ESTABLISHED);

 //初始化拥塞控制
 tcp_init_congestion_control(sk);
 ...

 //保活计时器打开
 if (sock_flag(sk, SOCK_KEEPOPEN))
  inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
}

客户端修改自己的 socket 状态为 ESTABLISHED,接着打开 TCP 的保活计时器。

//file:net/ipv4/tcp_output.c
void tcp_send_ack(struct sock *sk)
{
 //申请和构造 ack 包
 buff = alloc_skb(MAX_TCP_HEADER, sk_gfp_atomic(sk, GFP_ATOMIC));
 ...

 //发送出去
 tcp_transmit_skb(sk, buff, 0, sk_gfp_atomic(sk, GFP_ATOMIC));
}

在 tcp_send_ack 中构造 ack 包,并把它发送了出去。

客户端响应来自服务器端的 synack 时清除了 connect 时设置的重传定时器,把当前 socket 状态设置为 ESTABLISHED,开启保活计时器后发出第三次握手的 ack 确认。

五、服务器响应 ACK

服务器响应第三次握手的 ack 时同样会进入到 tcp_v4_do_rcv

//file: net/ipv4/tcp_ipv4.c
int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
{
 ...
 if (sk->sk_state == TCP_LISTEN) {
  struct sock *nsk = tcp_v4_hnd_req(sk, skb);

  if (nsk != sk) {
   if (tcp_child_process(sk, nsk, skb)) {
    ...
   }
   return 0;
  }
 }
 ...
}

不过由于这已经是第三次握手了,半连接队列里会存在上次第一次握手时留下的半连接信息。所以 tcp_v4_hnd_req 的执行逻辑会不太一样。

//file:net/ipv4/tcp_ipv4.c
static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
{
 ...
 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
          iph->saddr, iph->daddr);
 if (req)
  return tcp_check_req(sk, skb, req, prev, false);
 ...
}

inet_csk_search_req 负责在半连接队列里进行查找,找到以后返回一个半连接 request_sock 对象。然后进入到 tcp_check_req 中。

//file:net/ipv4/tcp_minisocks.c
struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
      struct request_sock *req,
      struct request_sock **prev,
      bool fastopen)
{
 ...
 //创建子 socket
 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
 ...

 //清理半连接队列
 inet_csk_reqsk_queue_unlink(sk, req, prev);
 inet_csk_reqsk_queue_removed(sk, req);

 //添加全连接队列
 inet_csk_reqsk_queue_add(sk, req, child);
 return child;
}

5.1 创建子 socket

icsk_af_ops->syn_recv_sock 对应的是 tcp_v4_syn_recv_sock 函数。

//file:net/ipv4/tcp_ipv4.c
const struct inet_connection_sock_af_ops ipv4_specific = {
 ......
 .conn_request      = tcp_v4_conn_request,
 .syn_recv_sock     = tcp_v4_syn_recv_sock,

//三次握手接近就算是完毕了,这里创建 sock 内核对象
struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
      struct request_sock *req,
      struct dst_entry *dst)
{
 //判断接收队列是不是满了
 if (sk_acceptq_is_full(sk))
  goto exit_overflow;

 //创建 sock && 初始化
 newsk = tcp_create_openreq_child(sk, req, skb);

注意,在第三次握手的这里又继续判断一次全连接队列是否满了,如果满了修改一下计数器就丢弃了。如果队列不满,那么就申请创建新的 sock 对象。

5.2 删除半连接队列

把连接请求块从半连接队列中删除。

//file: include/net/inet_connection_sock.h
static inline void inet_csk_reqsk_queue_unlink(struct sock *sk, struct request_sock *req,
 struct request_sock **prev)
{
 reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);
}

reqsk_queue_unlink 中把连接请求块从半连接队列中删除。

5.3 添加全连接队列

接着添加到全连接队列里边来。

//file:net/ipv4/syncookies.c
static inline void inet_csk_reqsk_queue_add(struct sock *sk,
      struct request_sock *req,
      struct sock *child)
{
 reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);
}

在 reqsk_queue_add 中将握手成功的 request_sock 对象插入到全连接队列链表的尾部。

//file: include/net/request_sock.h
static inline void reqsk_queue_add(...)
{
 req->sk = child;
 sk_acceptq_added(parent);

 if (queue->rskq_accept_head == NULL)
  queue->rskq_accept_head = req;
 else
  queue->rskq_accept_tail->dl_next = req;

 queue->rskq_accept_tail = req;
 req->dl_next = NULL;
}

5.4 设置连接为 ESTABLISHED

tcp_v4_do_rcv => tcp_child_process => tcp_rcv_state_process

//file:net/ipv4/tcp_input.c
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
     const struct tcphdr *th, unsigned int len)
{
 ...
 switch (sk->sk_state) {

  //服务端第三次握手处理
  case TCP_SYN_RECV:

   //改变状态为连接
   tcp_set_state(sk, TCP_ESTABLISHED);
   ...
 }
}

将连接设置为 TCP_ESTABLISHED 状态。

服务器响应第三次握手 ack 所做的工作是把当前半连接对象删除,创建了新的 sock 后加入到全连接队列中,最后将新连接状态设置为 ESTABLISHED。

六、服务器 accept

最后 accept 一步咱们长话短说。

//file: net/ipv4/inet_connection_sock.c
struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
{
 //从全连接队列中获取
 struct request_sock_queue *queue = &icsk->icsk_accept_queue;
 req = reqsk_queue_remove(queue);

 newsk = req->sk;
 return newsk;
}

reqsk_queue_remove 这个操作很简单,就是从全连接队列的链表里获取出第一个元素返回就行了。

//file:include/net/request_sock.h
static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
{
 struct request_sock *req = queue->rskq_accept_head;

 queue->rskq_accept_head = req->dl_next;
 if (queue->rskq_accept_head == NULL)
  queue->rskq_accept_tail = NULL;

 return req;
}

所以,accept 的重点工作就是从已经建立好的全连接队列中取出一个返回给用户进程。

本文总结

在后端相关岗位的入职面试中,三次握手的出场频率非常的高。其实在三次握手的过程中,不仅仅是一个握手包的发送 和 TCP 状态的流转。还包含了端口选择,连接队列创建与处理等很多关键技术点。通过今天一篇文章,我们深度去了解了三次握手过程中内核中的这些内部操作。

全文洋洋洒洒上万字字,其实可以用一幅图总结起来。

  • 服务器 listen 时,计算了全/半连接队列的长度,还申请了相关内存并初始化。

  • 客户端 connect 时,把本地 socket 状态设置成了 TCP_SYN_SENT,选则一个可用的端口,发出 SYN 握手请求并启动重传定时器。

  • 服务器响应 ack 时,会判断下接收队列是否满了,满的话可能会丢弃该请求。否则发出 synack,申请 request_sock 添加到半连接队列中,同时启动定时器。

  • 客户端响应 synack 时,清除了 connect 时设置的重传定时器,把当前 socket 状态设置为 ESTABLISHED,开启保活计时器后发出第三次握手的 ack 确认。

  • 服务器响应 ack 时,把对应半连接对象删除,创建了新的 sock 后加入到全连接队列中,最后将新连接状态设置为 ESTABLISHED。

  • accept 从已经建立好的全连接队列中取出一个返回给用户进程。

另外要注意的是,如果握手过程中发生丢包(网络问题,或者是连接队列溢出),内核会等待定时器到期后重试,重试时间间隔在 3.10 版本里分别是 1s 2s 4s ...。在一些老版本里,比如 2.6 里,第一次重试时间是 3 秒。最大重试次数分别由 tcp_syn_retries 和 tcp_synack_retries 控制。

如果你的线上接口正常都是几十毫秒内返回,但偶尔出现了 1 s、或者 3 s 等这种偶发的响应耗时变长的问题,那么你就要去定位一下看看是不是出现了握手包的超时重传了。

以上就是三次握手中一些更详细的内部操作。深度理解这个握手过程对于你排查线上问题会有极大的帮助的。下一讲我们来介绍三次握手中常见的异常问题。

参考资料

推荐一个零声教育C/C++后台开发的免费公开课程,个人觉得老师讲得不错,分享给大家:C/C++后台开发高级架构师,内容包括Linux,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK等技术内容,立即学习

原文:深入理解 Linux 的 TCP 三次握手

车载监控系统升级指南:如何用XS9950A替换TP9950实现高清视频解码(附配置代码) 本文提供了从TP9950升级至XS9950A车载视频解码芯片的完整实战指南。详细解析了硬件设计调整、PCB布局要点,并重点分享了通过I2C配置寄存器实现高清HDCCTV视频解码与同轴音频集成的软件驱动代码与调试技巧,助力工程师平滑完成系统升级。 阅读详情

相关推荐

论文解读--Phase Noise in FMCW Radar Systems

相位噪声是现代雷达、通信、光谱和计量系统的基本性能参数之一。本文提出了一种适用于FMCW雷达系统的相位噪声理论。导出了一个新的设计方程,用于确定雷达系统中允许的源相位噪声电平的最大界。分析了在传输延迟小于参考振荡器相干时间时,相干混频引起的非线性相位噪声去相关函数;讨论了在传输延迟大于参考振荡器相干时间时,目标响应的频谱展宽。提出了收发链中各子系统的影响,并讨论了一种新的ADC相位噪声模型。介绍了相位噪声建模技术,然后将锁相环频率合成器与低噪声频率合成器进行比较,以演示减少相位噪声边带以改善检测和跟踪性能。

奔袭的算法工程师 3767

当TCP和UDP使用的fd描述符是同一个时,会发生什么?

最近在一个项目中遇到了一个非常奇葩的问题,简单来说就是程序会创建一条tcp客户端连接与tcp服务端通信,另外还有一个udp用来组播发送报文。 现在遇到的问题是不知道什么原因,tcp和udp通过socket接口返回的描述符竟然是一样的,结果就会导致不管是tcp调用send还是udp调用sendto,实际上报文都是发送到了tco服务端,最终就会导致tcp服务端认为tcp客户端存在问题,会主动将连接close掉。导致tcp客户端一直不停的重连,连正常的报文通信都会受到影响。因为出现这种情况后,即使clos...

u011983700的专栏 734

【TM1650】STM8S TM1650芯片控制程序

以下为.h文件: #ifndef __TM1650_I2C_H #define __TM1650_I2C_H #include "stm8s.h" #include "stm8s_gpio.h" #include "tim1.h" #include "usart2.h" #include &lt;iostm8s103f3.h&gt; #include &lt;intrinsics....

cxw312864660的博客 1万+

网络通信的详解

网络通信

m0_72553196的博客 346

JESD204B系统设计实战:如何用SYSREF信号搞定多设备时钟同步(附时序图详解)

本文深入探讨了JESD204B系统中SYSREF信号在多设备时钟同步中的关键作用与实现技巧。通过详细分析SYSREF信号的生成、PCB布局和时序调整,提供了一套完整的解决方案,帮助工程师解决高速数据转换器与FPGA协同工作中的时钟同步问题。文章还包含时序图详解和实测调试技巧,助力提升系统性能。

weixin_29313239的博客 457

关于 MCU 芯片外围电路的快速入门介绍

MCU 外围电路的核心是“围绕 MCU 需求,搭建稳定、匹配的外部支撑”,入门阶段无需掌握复杂设计,只需先吃透供电、复位、时钟、IO 驱动、基础通信这五大模块,再逐步扩展存储、显示、传感器等进阶功能。实践中多调试、多参考成熟方案,是快速掌握外围电路设计的关键。码字不易,若觉得本文对你有用,欢迎,相关技术热点时时看🔥🔥🔥​​​…

JiaWen的博客 1650

【Linux】三次握手和四次挥手详解

​ TCP 协议提供的是:面向连接、可靠的、字节流服务。使用 TCP 协议通信的双发必须先建立连接,然后才能开始数据的读写。双方都必须为该连接分配必要的内核资源,以管理连接的状态和连接上数据的传输。TCP 连接是全双工的,双方的数据可以通过一个连接进行读写。完成数据交换之后,通信双方都必须断开连接以释放系统资源。

Demok123的博客 873

MATLAB配置MinGW编译器的完整指南

本文提供了在Windows系统上为MATLAB配置MinGW编译器的完整指南。详细介绍了通过MATLAB附加功能管理器在线安装和手动离线安装两种核心方法,并重点说明了如何解决常见的“未找到支持的编译器”等错误。指南包含从版本检查、环境变量配置到最终使用mex命令验证的每一步,帮助用户顺利完成MATLAB与MinGW的集成,以支持C/C++代码编译。

weixin_29031057的博客 265

Linux网络:传输层协议TCP(二)三次挥手四次握手详解

详细介绍了TCP协议中三次挥手四次握手的含义与原理,阐述其必要性和可靠性,以及其设计原理和在一些特定场景下TCP协议面对三次挥手四次握手出现异常时的处理机制

2201_75880188的博客 1989

车牌识别系统

随这图形图像技术的发展,现在的车牌识别技术准确率越来越高,识别速度越来越快。无论何种形式的车牌识别系统,它们都是由触发、图像采集、图像识别模块、辅助光源和通信模块组成的。车牌识别系统涉及光学、电器、电子控制、数字图像处理、计算视觉、人工智能等多项技术。触发模块负责在车辆到达合适位置时,给出触发信号,控制抓拍。辅助光源提供辅助照明,保证系统在不同的光照条件下都能拍摄到高质量的图像。图像预处理程序对抓拍的图像进行处理,去除噪声,并进行参数调整。然后通过车牌定位、字符识别,最后将识别结果输出。 牌照自动识别是一

FPGA/MATLAB学习教程/源码/项目合作开发 2万+

DeepCAD: 使用深度自监督学习技术在Python中进行钙成像去噪的全面指南

钙成像是一种用于观察神经活动的技术,通过检测细胞内钙离子的变化来推断神经元的活动。由于其高时空分辨率和对活体组织的适应性,钙成像已经成为神经科学研究中的重要工具。然而,钙成像数据往往伴随着各种噪声,这些噪声可能来自于设备、生物样本或环境。为了获得准确的神经活动信息,去噪是非常关键的。深度自监督学习是一种使用未标记数据进行训练的机器学习方法。与传统的监督学习不同,它不需要大量的标记数据,而是通过学习数据的内部结构和模式来提取有用的特征。DeepCAD是一个基于深度自监督学习的钙成像去噪工具。

qq_38334677的博客 759

Linux——TCP协议(三次握手(从数据包名,双方连接状态,包序管理分析),四次挥手(从数据包名,双方连接状态分析))

文章目录:前言1. 三次握手1.1 从数据包名和连接双方状态分析三次握手1.2 包序管理1.2.1 抓网络数据包1.2.2 分析TCP网络数据包1.2.3 分析TCP包序号 前言 TCP协议的连接是面向连接,可靠传输,面向字节流的,而TCP之所以能保持可靠传输是因为三次握手和四次挥手 1. 三次握手 1.1 从数据包名和连接双方状态分析三次握手 首先我们通过数据包名和连接双方的连接状态来了解三次握手的过程 如下图所示 客户端在发送SYN数据包后客户端的状态变为SYN_SENT,当服务端接收到客户端发送的

HanMeng的博客 905

【YOLO11[基础]】分类任务的热力图可视化实践 | 论文必备 | 分类任务 | 即插即用 | 可选GradCAMPlusPlus, GradCAM, XGradCAM, EigenCAM, HiR

【YOLO11[基础]】分类任务的热力图可视化实践 | 论文必备 | 分类任务 | 即插即用 | 可选GradCAMPlusPlus, GradCAM, XGradCAM, EigenCAM, HiResCAM, LayerCAM, RandomCAM, EigenGradCAM等

静谧、淡雅 2390

深入理解TCP三次握手与Linux内核调优

TCP三次握手是网络通信中建立可靠连接的基础协议,其核心原理是通过SYN、SYN-ACK和ACK三个步骤确认双方收发能力。在Linux系统中,内核通过tcp_max_syn_backlog等参数控制握手队列,利用tcp_syn_retries管理超时重试。理解这些机制对诊断连接超时、队列溢出等生产环境问题至关重要。现代观测工具如eBPF和tracepoint能深入分析握手延迟,而针对电商、视频直播等不同场景,需要动态调整内核参数。通过结合网络栈原理与实战调优,可有效提升系统吞吐量和稳定性。

weixin_33788244的博客 441

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

深入理解Linux网络——TCP协议三次握手和四次挥手详细流程

并且假如说节省第二次挥手的ACK包,那么因为下一个FIN的时间是不确定的,有可能很久,那么实现的时候得让FIN_WAIT_1等待一个很久的时间。如果是发生了如网络错误、断线或程序崩溃等错误或异常,那么自己这边的系统可能关闭所有的网络接口,释放所有的网络相关的内存等(取决于操作系统和协议栈的实现),而对端发送的保活数据包将接收不到ACK,重试几次后,就会进行连接的关闭,这个时候是不会进行四次挥手的。:等到一定时间后收不到服务端的反馈的时候来开启重传。每次超时时间为2的指数递增(1,2,4,8,16,32)

qq_25046827的博客 1143

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

深入理解Linux网络——TCP连接建立过程(三次握手源码详解)

icsk->icsk_accept_queue定义在inet_connection_sock下,是一个request_sock_queue类型的对象,是内核用来接收客户端请求的主要数据结构。我们平时说的全连接队列、半连接队列全都是在这个数据结构里实现的。我们来看具体的代码。// 全连接队列 struct request_sock * rskq_accept_head;// 半连接队列 struct listen_sock * listen_opt;

qq_25046827的博客 3130

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

TCP源码浅读(3)三次握手-主动方发送SYN

客户端调用 connect() 函数向服务端发起连接请求,经典的三次握手就是从这个时刻开启的。 我们按照三次握手的流程来梳理。 第一次握手,客户端发送 SYN 包。 第一次握手主要流程: 1、设置 sock 状态为 SYN_SENT; 2、绑定端口,将 sock 加入到 bhash 和 ehash 中; 3、构造 SYN 包,发送给服务端。

Chlapis的博客 1927

Linux服务器编程实践23-TCP三次握手建立连接:过程、时序与状态变化

摘要: TCP三次握手是Linux服务器编程中建立可靠连接的核心机制,通过客户端与服务器交换SYN和ACK报文段,确保双方通信能力正常。流程包括:客户端发送SYN→服务器回复SYN+ACK→客户端确认ACK,最终双方进入ESTABLISHED状态。关键点包括状态转移(如SYN_SENT、SYN_RCVD)、初始序号(ISN)生成及端口号分配。实战中可通过tcpdump抓包验证,利用netstat或ss工具诊断状态异常(如连接超时、SYN Flood攻击)。常见问题解决方案包括调整内核参数(如tcp_sync

文石_2009的博客 936

Linux系统编程——TCP协议详解(TCP报文、三次握手、四次挥手、TIME_WAIT状态、滑动窗口、拥塞控制、粘包问题、状态转换图)

我们知道服务端收到ACK,关闭连接。但是客户端无法知道ACK是否已经到达服务端,于是开始等待?等待什么呢?假如ACK没有到达服务端,服务端会为FIN这个消息超时重传 timeout retransmit ,那如果客户端等待时间足够,又收到FIN消息,说明ACK没有到达服务端,于是再发送ACK,直到在足够的时间内没有收到FIN,说明ACK成功到达。这个等待时间至少是:服务端的timeout + FIN的传输时间,为了保证可靠,采用更加保守的等待时间2MSL。

qq_74811378的博客 1387

游戏服务器tcp优化,TCP三次握手与Linux的TCP内核参数优化

感谢各位技术大佬的资料分享,这里我把我理解的内容做一个整理一:TCP的三次握手1、TCP简述TCP是一个面向连接的协议,在连接双方发送数据之前,首先需要建立一条连接。TCP建立连接可以简单称为:三次握手(说白了就是建立一个TCP连接的时候,客户端和服务端总共要发3个包,socket编程里面执行connect()的时候,将触发三次握手),断开TCP连接可以叫做四次握手(socket编程里面任何一方执...

weixin_34526733的博客 327

深入理解TCP实现|经典PDF分享

hi 大家好,今天给大家分享一个经典的TCP源码分析PDF(文末有获取方式),基于比较新的内核版本-Linux 4.4.0,从用户态TCP编程,到TCP RFC协议,TCP收发路径,TCP...

极客重生 541

Linux 软件编程(十)网络编程:网络协议,UDP 与 TCP 知识点

UDP 和 TCP 的核心区别连接性:UDP 无连接,TCP 有连接可靠性:UDP 不可靠,TCP 可靠数据形式:UDP 面向数据包,TCP 面向数据流开销:UDP 开销小,TCP 开销大适用场景:UDP 适用于实时通信,TCP 适用于可靠传输TCP 三次握手和四次挥手的意义三次握手:确保双方收发能力正常,避免无效连接四次挥手:保证双方都已完成数据传输,避免数据丢失TCP 粘包问题的本质源于 TCP 的流式传输特性,没有数据包边界,需在应用层解决TCP 编程的核心要点。

2302_80202237的博客 1026

Linux:(UDP与TCP协议,三次握手,四次挥手,滑动窗口,拥塞控制,listen第二个参数)

目录一、再谈端口号1.端口号2.五元组3.端口号划分(1)知名端口号(2)操作系统动态分配的端口号(3)端口号与进程之间的关系4.一些Linux指令(1)netstat(2)pidof二、UDP2.解包和分用(1)解包(2)分用3.特点4.TCP缓冲区5.UDP缓冲区6.常见的基于UDP的应用层协议三、TCP1.协议格式2.解包和分用3.缓冲区4.面向字节流5.粘包问题6.网络协议和协议栈四、确认应答机制1.通信的可靠性2.确认应答(ACK)机制3.超时重传机制五、TCP报头信息的理解1.序号和确认序号2.

weixin_70067429的博客 1041

linux——简单的Tcp通信

https://blog.youkuaiyun.com/u012198575/article/details/103493100?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162942256916780274183616%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=162942256916780274183616&biz_id=0&

maple_zmz的博客 219

Linux网络之TCP协议

相对于序号字段指示的序号的偏移量。​ TCP的“紧急数据”机制允许发送方中断对方的数据流,通知其有重要数据(如终端的中断命令Ctrl+C)。但实际中应用较少。

2301_79969685的博客 971

深入理解网络TCP通信

文章目录网络相关的Linux命令传输控制层网络层数据链路层 网络相关的Linux命令 #1.进入到当前Shell程序的进程 cd /proc/$$/ #2.一切皆为文件,获取该进程的文件描述符 cd fd #3.将7文件描述符重定向到 /dev/tcp/www.baidu.com/80,这个命令实际上就是当前进程和百度的服务器进程简历了Socket连接 exec 7<> /dev/tcp/www.baidu.com/80 #4.先百度通过http协议发送请求 # "GET / HTTP/1.0\

小毅毅的博客 421
上一篇: 分布式锁用 Redis 还是 Zookeeper?
下一篇: 彻底了解C++异步从理论到实践
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值