1
Client                          Server
2
  │                               │
3
  │──── SYN, seq=x ──────────→   │  ① 客户端发SYN
4
  │                               │
5
  │←── SYN+ACK, seq=y, ack=x+1 ──│  ② 服务器回SYN+ACK
6
  │                               │
7
  │──── ACK, ack=y+1 ────────→   │  ③ 客户端发ACK
8
  │                               │
9
  │  ═══════ 连接建立 ═══════     │
10

11
为什么是三次而不是两次？
12
  两次: 服务器收到SYN就确认连接
13
  问题: 如果是一个"历史SYN"(网络延迟很久才到达)
14
       → 服务器建立了错误的连接 → 浪费资源
15
  三次: 客户端确认ACK → 证明这个SYN是"新鲜的"

1
Client                          Server
2
  │                               │
3
  │──── FIN, seq=u ──────────→   │  ① 客户端请求关闭
4
  │                               │
5
  │←── ACK, ack=u+1 ─────────   │  ② 服务器确认(但可能还有数据要发)
6
  │                               │
7
  │←── FIN, seq=v ───────────   │  ③ 服务器也请求关闭
8
  │                               │
9
  │──── ACK, ack=v+1 ────────→   │  ④ 客户端确认
10
  │                               │
11
  │  ═══ TIME_WAIT(2MSL) ═══     │  客户端等2MSL后释放
12
  │                               │
13

14
为什么要TIME_WAIT?
15
  ① 如果最后的ACK丢了,服务器会重发FIN → 客户端能重发ACK
2 collapsed lines
16
  ② 确保旧连接的数据包在网络中消失(不影响新连接)
17
  MSL = Maximum Segment Lifetime ≈ 2分钟

1
发送方                          接收方
2
  │ ─── Seq=1, Data ──→         │
3
  │ ─── Seq=2, Data ──→   (丢失)│
4
  │ ─── Seq=3, Data ──→         │
5
  │ ←── ACK=2(期望收到2) ──── │
6
  │ ←── ACK=2(重复ACK) ─────  │
7
  │ ←── ACK=2(重复ACK) ─────  │
8
  │ ─── Seq=2, 重传! ──→       │  ← 快速重传(3个重复ACK)
9
  │ ←── ACK=4 ──────────────── │  ← 确认收到1,2,3

1
发送窗口(发送方维护):
2
  ┌────────┬────────────────┬────────────┬──────────┐
3
  │已确认   │已发送未确认     │可发送       │不可发送   │
4
  └────────┴────────────────┴────────────┴──────────┘
5
           └────────────── 窗口大小 ──────────────┘
6

7
接收窗口(接收方通告):
8
  TCP头部 Window字段 → 告诉发送方"我还能接收多少数据"
9

10
  窗口为0: 发送方停止发送(零窗口探测定时器)
11
  窗口缩小: 出现Silly Window Syndrome(小段数据) → Nagle算法优化

1
Nagle算法规则:
2
  如果有已发送未确认的数据 → 缓存小数据 → 等ACK到后一起发
3
  如果没有未确认数据 → 立即发送
4

5
延迟ACK:
6
  收到数据不立即回ACK → 等待一段时间(~40ms)或等待可以捎带ACK
7

8
二者冲突: Nagle等ACK才发数据, ACK延迟等数据才发ACK → 死锁40ms!
9
解决: 关闭Nagle → TCP_NODELAY

1
// 嵌入式实时通信: 关闭Nagle算法
2
int flag = 1;
3
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));

1
int keepalive = 1;
2
int idle = 60;    // 60秒无数据开始探测
3
int interval = 10; // 每10秒探测一次
4
int count = 3;    // 3次无响应认为断开
5

6
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
7
setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
8
setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &interval, sizeof(interval));
9
setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &count, sizeof(count));

1
客户端SYN到达 → 半连接队列(SYN Queue)
2
                ↓ 完成三次握手
3
             全连接队列(Accept Queue) → accept()取出
4

5
半连接队列满: SYN Flood攻击 → 解决:SYN Cookie
6
全连接队列满: 服务器accept太慢 → 丢弃新连接
7

8
查看:
9
  cat /proc/sys/net/ipv4/tcp_max_syn_backlog  # 半连
10
  ss -ltn  # Recv-Q=当前全连接数, Send-Q=listen backlog

1
实现方案(仿TCP):
2
1. 序列号: 每个包编号
3
2. 确认应答: 接收方发ACK
4
3. 超时重传: 未收到ACK则重传
5
4. 滑动窗口: 流量控制
6

7
简易可靠UDP伪代码:
8
  发送方:
9
    packet.seq = next_seq++;
10
    send(packet);
11
    timer_start(packet.seq, TIMEOUT);
12
    // 收到ACK → 确认, 超时 → 重传
13

14
  接收方:
15
    recv(packet);
7 collapsed lines
16
    if (packet.seq == expected_seq) {
17
        deliver(packet.data);
18
        expected_seq++;
19
    } else {
20
        // 乱序: 缓存或丢弃
21
    }
22
    send_ack(expected_seq);

1
场景: 主机A(192.168.1.1)想发数据给主机B(192.168.1.2)
2

3
1. A查ARP缓存: 有B的MAC吗？
4
   └→ 有: 直接用
5
   └→ 没有: 发送ARP请求(广播)
6

7
2. ARP请求(广播):
8
   "谁是192.168.1.2? 请告诉192.168.1.1(MAC: AA:BB:CC:DD:EE:FF)"
9

10
3. B收到后回复(单播):
11
   "我是192.168.1.2, 我的MAC是11:22:33:44:55:66"
12

13
4. A更新ARP缓存, 后续直接用
14

15
命令:
2 collapsed lines
16
  arp -a            # 查看ARP表
17
  arping 192.168.1.2  # 主动探测

1
内网主机:                     NAT设备:                     外网服务器:
2
192.168.1.2:5000 ──→ 转换为202.1.1.1:10001 ──→ 8.8.8.8:53
3
192.168.1.3:6000 ──→ 转换为202.1.1.1:10002 ──→ 8.8.8.8:53
4

5
NAT表:
6
  内网地址:端口          公网地址:端口
7
  192.168.1.2:5000  ←→  202.1.1.1:10001
8
  192.168.1.3:6000  ←→  202.1.1.1:10002
9

10
嵌入式相关: IoT设备在内网, 需要NAT穿透才能被外部访问
11
穿透方法: STUN/TURN/ICE, 或MQTT等长连接协议

1
TLS握手简化过程:
2
1. Client Hello: 支持的加密套件列表, 随机数
3
2. Server Hello: 选定加密套件, 证书, 随机数
4
3. 客户端验证证书(CA签名)
5
4. 客户端生成预主密钥(用服务器公钥加密发送)
6
5. 双方用三个随机数生成会话密钥
7
6. 后续用对称加密通信(AES等, 高效)
8

9
嵌入式:
10
  - mbedTLS/wolfSSL(轻量级TLS实现)
11
  - 证书体积和内存是挑战
12
  - 硬件加密加速(AES-NI/ARM CE)

1
// 健壮的读取函数
2
ssize_t read_n(int fd, void *buf, size_t count) {
3
    size_t left = count;
4
    char *ptr = buf;
5
    while (left > 0) {
6
        ssize_t n = read(fd, ptr, left);
7
        if (n < 0) {
8
            if (errno == EINTR) continue;
9
            if (errno == EAGAIN) break;
10
            return -1;
11
        }
12
        if (n == 0) break;  // 对端关闭
13
        left -= n;
14
        ptr += n;
15
    }
2 collapsed lines
16
    return count - left;
17
}

1
                    主动打开                  被动打开
2
                      │                        │
3
            ┌─────────▼──────────┐  ┌──────────▼─────────┐
4
            │    SYN_SENT        │  │     LISTEN         │
5
            │  (发送SYN)         │  │   (等待连接)        │
6
            └────────┬───────────┘  └──────────┬─────────┘
7
                     │收到SYN+ACK              │收到SYN
8
            ┌────────▼───────────┐  ┌──────────▼─────────┐
9
            │   ESTABLISHED      │  │    SYN_RCVD        │
10
            │   (连接建立)        │  │  (发送SYN+ACK)     │
11
            └────────┬───────────┘  └──────────┬─────────┘
12
                     │                         │收到ACK
13
                     │                ┌────────▼─────────┐
14
                     │                │   ESTABLISHED     │
15
                     │                └──────────────────┘
3 collapsed lines
16
  关闭连接:
17
  主动关闭:  ESTABLISHED→FIN_WAIT_1→FIN_WAIT_2→TIME_WAIT→CLOSED
18
  被动关闭:  ESTABLISHED→CLOSE_WAIT→LAST_ACK→CLOSED

1
MTU(Maximum Transmission Unit): 数据链路层最大帧长度
2
  以太网MTU = 1500字节
3

4
MSS(Maximum Segment Size): TCP单次发送最大数据量
5
  MSS = MTU - IP头(20) - TCP头(20) = 1460字节
6

7
  ┌─────────────────────────────────────────────────┐
8
  │ 以太网帧头 │ IP头(20B) │ TCP头(20B) │ 数据(≤1460B) │ FCS │
9
  │   14B      │           │            │              │  4B │
10
  └─────────────────────────────────────────────────┘
11

12
  如果数据>MTU → IP分片(尽量避免,影响性能)
13
  TCP通过MSS协商避免IP层分片

1
// backlog定义了全连接队列的最大长度
2
listen(listen_fd, 128);  // 最多允许128个完成三次握手但未accept的连接
3

4
// 如果队列满: 新的SYN可能被丢弃或返回RST
5
// 嵌入式设备: 根据预期并发连接数设置合理值
6
// 高并发服务器: 设置较大值(如1024)

1
TCP头部(20字节+可选):
2
  ┌────────────────────────────────────────┐
3
  │ 源端口(16)      │ 目的端口(16)         │
4
  ├────────────────────────────────────────┤
5
  │ 序列号(32)                              │
6
  ├────────────────────────────────────────┤
7
  │ 确认号(32)                              │
8
  ├────────────────────────────────────────┤
9
  │ 头部长度│保留│URG ACK PSH RST SYN FIN│窗口(16)│
10
  ├────────────────────────────────────────┤
11
  │ 校验和(16)       │ 紧急指针(16)         │
12
  └────────────────────────────────────────┘
13

14
UDP头部(8字节):
15
  ┌────────────────────────────────────────┐
4 collapsed lines
16
  │ 源端口(16)      │ 目的端口(16)         │
17
  ├────────────────────────────────────────┤
18
  │ 长度(16)        │ 校验和(16)           │
19
  └────────────────────────────────────────┘

1
DHCP四步交互(DORA):
2
1. Discover(广播): 客户端:"谁是DHCP服务器？"
3
2. Offer(广播):    服务器:"我可以给你192.168.1.100"
4
3. Request(广播):  客户端:"我要192.168.1.100"
5
4. ACK(广播):      服务器:"确认,有效期24小时"
6

7
嵌入式中:
8
  - 设备启动时通过DHCP获取IP
9
  - 服务器可根据MAC分配固定IP(静态绑定)
10
  - 没有DHCP服务器: 使用链路本地地址(169.254.x.x)

1
// lwIP基本使用(raw API)
2
#include "lwip/tcp.h"
3

4
struct tcp_pcb *pcb = tcp_new();
5
tcp_bind(pcb, IP_ADDR_ANY, 8080);
6
pcb = tcp_listen(pcb);
7
tcp_accept(pcb, accept_callback);
8

9
err_t accept_callback(void *arg, struct tcp_pcb *newpcb, err_t err) {
10
    tcp_recv(newpcb, recv_callback);
11
    return ERR_OK;
12
}
13

14
err_t recv_callback(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) {
15
    if (p != NULL) {
6 collapsed lines
16
        // 处理数据
17
        tcp_write(pcb, response, resp_len, TCP_WRITE_FLAG_COPY);
18
        pbuf_free(p);
19
    }
20
    return ERR_OK;
21
}

1
// 优雅关闭(等待数据发完)
2
shutdown(fd, SHUT_WR);  // 关闭写端,发FIN
3
// 继续读取对方剩余数据...
4
while (read(fd, buf, sizeof(buf)) > 0);
5
close(fd);
6

7
// 强制关闭(RST，丢弃未发数据)
8
struct linger lg = { .l_onoff = 1, .l_linger = 0 };
9
setsockopt(fd, SOL_SOCKET, SO_LINGER, &lg, sizeof(lg));
10
close(fd);  // 发RST而非FIN
11

12
// 半关闭
13
shutdown(fd, SHUT_WR);  // 关写不关读(常用于通知对方数据发完)
14
shutdown(fd, SHUT_RD);  // 关读不关写

1
// 网络字节序=大端
2
// x86/ARM(通常)=小端
3

4
// 不同字节序的表示:
5
// 数值: 0x12345678
6
// 大端(网络): [12][34][56][78] (高位在前)
7
// 小端(主机): [78][56][34][12] (低位在前)
8

9
// 转换
10
uint32_t host_val = 0x12345678;
11
uint32_t net_val = htonl(host_val);  // 主机→网络
12

13
// 结构体网络传输(必须处理字节序)
14
typedef struct __attribute__((packed)) {
15
    uint16_t cmd;    // 必须htons
2 collapsed lines
16
    uint32_t param;  // 必须htonl
17
} NetPacket;

1
零窗口场景:
2
  接收方处理慢 → 接收缓冲满 → 通告窗口=0 → 发送方停止
3

4
  发送方如何知道窗口恢复？
5
  → 窗口探测机制(Persist Timer):
6
    定期发送1字节探测包 → 等待对方回复新窗口值
7

8
  问题: 如果窗口更新ACK丢失 → 死锁(双方互相等待)
9
  → 所以需要Persist Timer

1
// 发送紧急数据
2
send(fd, "X", 1, MSG_OOB);
3

4
// 接收紧急数据
5
recv(fd, buf, 1, MSG_OOB);
6

7
// 或通过SIGURG信号通知
8
signal(SIGURG, oob_handler);
9
fcntl(fd, F_SETOWN, getpid());
10

11
// 实际应用: Telnet中Ctrl+C中断、FTP中止传输
12
// 嵌入式: 紧急停止命令

1
// SO_REUSEADDR: TIME_WAIT状态也能绑定(基本必设)
2
int opt = 1;
3
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
4

5
// SO_REUSEPORT: 多个socket绑定同一端口(内核负载均衡)
6
setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
7
// 多进程/多线程各自listen同一端口 → 内核分发连接

1
IPv6地址: 128位, 如 2001:0db8:85a3::8a2e:0370:7334
2
IPv4地址: 32位, 如 192.168.1.1
3

4
IPv6优势:
5
  - 地址空间巨大(每个IoT设备都可有全球唯一地址)
6
  - 无需NAT(端到端直达)
7
  - 内置IPsec
8
  - 自动配置(SLAAC)
9

10
嵌入式:
11
  struct sockaddr_in6 addr6;
12
  addr6.sin6_family = AF_INET6;
13
  inet_pton(AF_INET6, "::1", &addr6.sin6_addr);

1
// 应用层心跳设计
2
#define HEARTBEAT_INTERVAL 30  // 30秒
3
#define HEARTBEAT_TIMEOUT  90  // 3倍间隔无心跳则断开
4

5
// 发送心跳
6
void *heartbeat_thread(void *arg) {
7
    while (connected) {
8
        send_heartbeat_packet(fd);
9
        sleep(HEARTBEAT_INTERVAL);
10
    }
11
}
12

13
// 检测心跳超时
14
void check_timeout(void) {
15
    time_t now = time(NULL);
5 collapsed lines
16
    if (now - last_heartbeat_time > HEARTBEAT_TIMEOUT) {
17
        // 连接断开,执行重连
18
        reconnect();
19
    }
20
}

1
JSON:   {"temp":23.5,"humi":65}  →  28字节(文本)
2
Protobuf: [二进制编码]           →  ~8字节(紧凑)
3
MessagePack: [二进制]            →  ~12字节
4

5
嵌入式优势:
6
  - 更小体积(节省带宽)
7
  - 更快解析(无字符串解析)
8
  - 跨语言兼容(设备C/云端Python)
9

10
嵌入式常用:
11
  - nanopb(C语言Protobuf实现,适合MCU)
12
  - CBOR(类JSON的二进制格式)
13
  - FlatBuffers(零拷贝反序列化)

1
QoS 1流程:
2
  Publisher → PUBLISH(msgid=1) → Broker
3
  Publisher ← PUBACK(msgid=1) ← Broker
4
  (如果超时没收到PUBACK → 重发PUBLISH)
5

6
QoS 2流程(四步):
7
  Publisher → PUBLISH → Broker
8
  Publisher ← PUBREC  ← Broker  (收到了)
9
  Publisher → PUBREL  → Broker  (确认释放)
10
  Publisher ← PUBCOMP ← Broker  (完成)

1
mDNS:
2
  设备宣告: "我是mydevice.local, IP是192.168.1.50"
3
  其他设备解析: ping mydevice.local → 192.168.1.50
4
  使用多播地址: 224.0.0.251:5353
5

6
DNS-SD(Service Discovery):
7
  设备宣告服务: "_http._tcp.local" → "MyDevice Web Server"
8
  其他设备查询: "有哪些HTTP服务？" → 列出所有
9

10
嵌入式应用:
11
  - 打印机发现(AirPrint)
12
  - IoT设备自动发现(不需要知道IP)
13
  - Apple Bonjour / Linux Avahi

1
// 嵌入式WebSocket简化实现(基于mongoose库)
2
#include "mongoose.h"
3

4
void event_handler(struct mg_connection *c, int ev, void *ev_data) {
5
    if (ev == MG_EV_HTTP_MSG) {
6
        struct mg_http_message *hm = ev_data;
7
        if (mg_http_match_uri(hm, "/ws")) {
8
            mg_ws_upgrade(c, hm, NULL);
9
        }
10
    } else if (ev == MG_EV_WS_MSG) {
11
        struct mg_ws_message *wm = ev_data;
12
        // 收到WebSocket消息
13
        mg_ws_send(c, "ACK", 3, WEBSOCKET_OP_TEXT);
14
    }
15
}

1
// 定义服务(sensor.proto)
2
syntax = "proto3";
3
service SensorService {
4
    rpc GetData(SensorRequest) returns (SensorData);
5
    rpc StreamData(SensorRequest) returns (stream SensorData);
6
}
7
message SensorRequest { int32 sensor_id = 1; }
8
message SensorData { float temperature = 1; float humidity = 2; }

1
配网方案:
2
1. AP模式: 设备开热点→手机连接→配置WiFi信息→切回
3
2. SmartConfig: 手机APP广播WiFi密码→设备嗅探获取
4
3. BLE辅助: 通过BLE传递WiFi凭证(更可靠)
5
4. WPS: 按路由器WPS键→自动配对(简单但不安全)
6
5. 二维码: 扫码获取设备信息→APP配网
7

8
代码流程(Linux wpa_supplicant):
9
  // 生成配置
10
  echo 'network={ssid="MyWiFi" psk="password"}' > /etc/wpa_supplicant.conf
11
  // 启动连接
12
  wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant.conf
13
  dhclient wlan0   // 获取IP

1
特性:
2
  - 固定长度输出
3
  - 不可逆(不能从哈希值还原数据)
4
  - 雪崩效应(输入微小变化→输出完全不同)
5
  - 抗碰撞(不同输入很难产生相同哈希)
6

7
常用:
8
  MD5:    128位(已不安全,仅用于校验)
9
  SHA-256: 256位(安全标准)
10
  CRC32:  32位(错误检测,非加密)
11

12
嵌入式应用:
13
  - 固件校验: SHA-256(firmware.bin) = 已知哈希？
14
  - 密码存储: bcrypt(password + salt)
15
  - 数据去重: 内容hash作为唯一标识

1
签名过程(发送方):
2
  1. 计算数据的哈希: H = SHA256(data)
3
  2. 用私钥加密哈希: Sig = RSA_Encrypt(H, private_key)
4
  3. 发送: data + Sig
5

6
验证过程(接收方):
7
  1. 用公钥解密签名: H1 = RSA_Decrypt(Sig, public_key)
8
  2. 计算数据哈希: H2 = SHA256(data)
9
  3. 比较: H1 == H2? → 验证通过
10

11
嵌入式安全启动:
12
  BootROM中固化公钥 → 验证U-Boot签名 → 验证Kernel签名

1
// CRC-16/MODBUS实现
2
uint16_t crc16_modbus(uint8_t *data, uint16_t len) {
3
    uint16_t crc = 0xFFFF;
4
    for (uint16_t i = 0; i < len; i++) {
5
        crc ^= data[i];
6
        for (uint8_t j = 0; j < 8; j++) {
7
            if (crc & 0x0001)
8
                crc = (crc >> 1) ^ 0xA001;
9
            else
10
                crc >>= 1;
11
        }
12
    }
13
    return crc;
14
}
15

5 collapsed lines
16
// 使用(通信帧校验)
17
uint8_t frame[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x02};
18
uint16_t crc = crc16_modbus(frame, 6);
19
frame[6] = crc & 0xFF;        // CRC低字节
20
frame[7] = (crc >> 8) & 0xFF; // CRC高字节

1
// 使用mbedTLS的AES-128-CBC
2
#include "mbedtls/aes.h"
3

4
uint8_t key[16] = "0123456789abcdef";
5
uint8_t iv[16] = "fedcba9876543210";
6
uint8_t plaintext[32] = "Hello, Embedded!";
7
uint8_t ciphertext[32];
8

9
mbedtls_aes_context ctx;
10
mbedtls_aes_init(&ctx);
11
mbedtls_aes_setkey_enc(&ctx, key, 128);
12
mbedtls_aes_crypt_cbc(&ctx, MBEDTLS_AES_ENCRYPT, 32, iv, plaintext, ciphertext);
13
mbedtls_aes_free(&ctx);

1
安全启动链:
2
  BootROM(不可修改) → 验证SPL签名 → SPL验证U-Boot → U-Boot验证Kernel
3

4
实现方法:
5
  1. 密钥对: 服务器持有私钥(签名), 设备持有公钥(验证)
6
  2. 签名: 每次构建固件时用私钥签名
7
  3. 验证: 启动时每级验证下一级签名
8
  4. 回退: 验证失败→不启动/回退旧版本
9

10
密钥安全存储:
11
  - OTP/eFuse: 一次性可编程(写入后不可修改)
12
  - Secure Element(SE): 硬件安全芯片
13
  - TrustZone: ARM安全世界隔离