# 错误做法
sock.close()  # 完全关闭，销毁文件描述符
# → 无法接收对端剩余数据
# → 无法重用该socket

# 正确做法
sock.shutdown(socket.SHUT_WR)  # 半关闭
# → 保留接收能力
# → 等待对端发送完数据
# → 然后才调用close()

// 完全关闭（销毁socket）
int close(int sockfd);

// 半关闭（保留接收能力）
int shutdown(int sockfd, int how);
// how: SHUT_RD(0), SHUT_WR(1), SHUT_RDWR(2)

# 追踪Python程序的socket系统调用
strace -e trace=socket,connect,send,recv,close,shutdown -f python server.py

# 关键输出示例：
# close(3)                    = 0
# shutdown(3, SHUT_WR)        = 0

# 实时查看socket状态转换
watch -n 0.1 'ss -tan | grep :8080'

# 输出字段：
# State: ESTABLISHED, CLOSE_WAIT, FIN_WAIT1, FIN_WAIT2, TIME_WAIT, LAST_ACK
# Recv-Q: 接收缓冲区数据量
# Send-Q: 发送缓冲区数据量

# 抓取TCP FIN包
tcpdump -i lo -n 'tcp port 8080 and (tcp[tcpflags] & tcp-fin != 0)'

# 完整抓包（包含Seq/Ack）
tcpdump -i lo -n 'tcp port 8080' -X -vv

# Wireshark GUI过滤器：
# tcp.flags.fin == 1 || tcp.flags.reset == 1

# 查看TCP超时配置
sysctl net.ipv4.tcp_fin_timeout
# 默认60秒（TIME_WAIT状态时长）

# 查看TCP状态统计
cat /proc/net/tcp | awk '{print $4}' | sort | uniq -c

import socket
import time

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('127.0.0.1', 8080))
sock.listen(1)
print("[Server] 等待连接...")
conn, addr = sock.accept()
print(f"[Server] 客户端已连接: {addr}")

while True:
    data = conn.recv(1024)
    if not data:
        print("[Server] 收到FIN，连接半关闭")
        # 关键：此时仍可发送数据
        conn.send(b"Server: 我收到了你的FIN，但我还能发送")
        time.sleep(1)
        conn.send(b"Server: 第二条消息")
        break
    print(f"[Server] 收到: {data.decode()}")

conn.close()
sock.close()

import socket
import time

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 8080))

sock.send(b"Client: 第一条消息")
time.sleep(0.5)
sock.close()  # 完全关闭
print("[Client] 已调用close()")
# sock.send(b"Client: 不会再发送")  # 会报错

import socket
import time

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 8080))

sock.send(b"Client: 第一条消息")
time.sleep(0.5)
sock.shutdown(socket.SHUT_WR)  # 半关闭
print("[Client] 已调用shutdown(SHUT_WR)")

# 关键：此时仍可接收数据
data = sock.recv(1024)
print(f"[Client] 收到: {data.decode()}")

data = sock.recv(1024)
print(f"[Client] 收到: {data.decode()}")

sock.close()

# Terminal 1: 启动抓包（观测网络层）
tcpdump -i lo -n 'tcp port 8080' -vv -S

# Terminal 2: 查看socket状态（观测内核层）
watch -n 0.1 'ss -tan | grep :8080'

# Terminal 3: 运行server
python server.py

# Terminal 4: 运行client_close实验
python client_close.py

# Terminal 4: 重新运行client_shutdown实验
python client_shutdown.py

def graceful_shutdown(sock):
    """实现graceful shutdown的完整流程"""

    # Step 1: 告知对端"我不再发送数据"
    sock.shutdown(socket.SHUT_WR)

    # Step 2: 等待对端发送完剩余数据
    while True:
        data = sock.recv(4096)
        if not data:
            break  # 对端也调用shutdown了
        print(f"收到剩余数据: {data}")

    # Step 3: 现在可以安全close了
    sock.close()
    print("连接已优雅关闭")

# chat_client.py - 支持重连的聊天客户端
import socket
import select
import time

class ChatClient:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.sock = None
        self.message_queue = []  # 未发送消息缓存

    def connect(self):
        """重新连接逻辑"""
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self.sock.connect((self.host, self.port))
            print(f"[Client] 已连接到 {self.host}:{self.port}")
            # 重发缓存消息
            for msg in self.message_queue:
                self.sock.send(msg)
            self.message_queue.clear()
            return True
        except ConnectionRefusedError:
            print("[Client] 服务器未启动，3秒后重试...")
            time.sleep(3)
            return self.connect()

    def graceful_disconnect(self):
        """优雅断开连接"""
        if not self.sock:
            return

        # 1. 半关闭
        self.sock.shutdown(socket.SHUT_WR)
        print("[Client] 已发送FIN，等待服务器剩余数据...")

        # 2. 接收剩余消息
        while True:
            data = self.sock.recv(1024)
            if not data:
                break
            print(f"[Client] 收到: {data.decode()}")

        # 3. 完全关闭
        self.sock.close()
        self.sock = None
        print("[Client] 连接已优雅关闭")

    def send_message(self, message):
        """发送消息（支持离线缓存）"""
        if not self.sock:
            self.message_queue.append(message.encode())
            print("[Client] 离线，消息已缓存")
            return

        try:
            self.sock.send(message.encode())
        except (ConnectionResetError, BrokenPipeError):
            print("[Client] 连接断开，缓存消息")
            self.message_queue.append(message.encode())
            self.sock = None
            self.connect()

# 使用示例
client = ChatClient('127.0.0.1', 8080)
client.connect()
client.send_message("Hello Server")
time.sleep(1)
client.graceful_disconnect()

# 陷阱1: 直接close()丢失数据
sock.send(data)
sock.close()  # 数据可能在缓冲区未发送

# 正确: 确保数据发送
sock.sendall(data)  # 阻塞直到全部发送
sock.shutdown(socket.SHUT_WR)
sock.close()

# 陷阱2: 双方同时close()导致RST
# Client:
sock.close()
# Server（同时）:
sock.close()  # 可能收到RST

# 正确: 应用层协调
# Client发送FIN后等待Server处理
sock.shutdown(socket.SHUT_WR)
sock.recv(1024)  # 等待Server响应
sock.close()