import struct

def parse_mss_option(data):
    """解析 MSS 选项"""
    # Kind=2, Length=4, Value=2 bytes
    if len(data) >= 4 and data[0] == 2 and data[1] == 4:
        mss = struct.unpack('!H', data[2:4])[0]
        return mss
    return None

# 解析示例
mss_option = bytes([2, 4, 0x05, 0xB4])  # MSS = 1460
mss = parse_mss_option(mss_option)
print(f"MSS: {mss}")  # MSS: 1460

def window_scale_calculation():
    """窗口缩放计算示例"""
    
    # 握手时协商的缩放因子
    sender_scale = 7   # 发送方的缩放因子
    receiver_scale = 8  # 接收方的缩放因子
    
    # 窗口字段值（16 位）
    window_field = 65535
    
    # 发送方的窗口（使用接收方通告的缩放因子）
    actual_window = window_field << receiver_scale
    print(f"接收方窗口: {actual_window:,} 字节 = {actual_window/1024/1024:.2f} MB")
    
    # 接收方的窗口（使用发送方通告的缩放因子）
    actual_window = window_field << sender_scale
    print(f"发送方窗口: {actual_window:,} 字节 = {actual_window/1024/1024:.2f} MB")

window_scale_calculation()

def calculate_bdp(bandwidth_mbps, rtt_ms):
    """计算带宽延迟积 (BDP)"""
    # BDP = 带宽 × RTT
    bandwidth_bytes = bandwidth_mbps * 1_000_000 / 8
    rtt_sec = rtt_ms / 1000
    bdp = bandwidth_bytes * rtt_sec
    return bdp

def required_window_scale(bandwidth_mbps, rtt_ms):
    """计算需要的窗口缩放因子"""
    bdp = calculate_bdp(bandwidth_mbps, rtt_ms)
    
    # 需要的缩放因子
    import math
    if bdp <= 65535:
        return 0
    scale = math.ceil(math.log2(bdp / 65535))
    return min(scale, 14)

# 不同场景的窗口需求
scenarios = [
    ("局域网", 1000, 1),      # 1Gbps, 1ms
    ("宽带", 100, 20),        # 100Mbps, 20ms
    ("跨省", 100, 50),        # 100Mbps, 50ms
    ("跨洋", 1000, 200),      # 1Gbps, 200ms
]

print("场景 | 带宽 | RTT | BDP | 需要缩放")
print("-" * 50)
for name, bw, rtt in scenarios:
    bdp = calculate_bdp(bw, rtt)
    scale = required_window_scale(bw, rtt)
    print(f"{name:6} | {bw:4}Mbps | {rtt:3}ms | {bdp:12,.0f}B | {scale}")

class TimestampRTT:
    """使用时间戳测量 RTT"""
    
    def __init__(self):
        self.sent_time = {}  # {tsv: send_time}
    
    def send_segment(self, tsv):
        """发送段时记录时间戳"""
        import time
        self.sent_time[tsv] = time.time()
    
    def receive_ack(self, tsr):
        """收到 ACK 时计算 RTT"""
        import time
        if tsr in self.sent_time:
            rtt = time.time() - self.sent_time[tsr]
            del self.sent_time[tsr]
            return rtt
        return None

# 使用示例
rtt_calc = TimestampRTT()
rtt_calc.send_segment(1000)
# ... 网络传输 ...
rtt = rtt_calc.receive_ack(1000)
if rtt:
    print(f"RTT: {rtt*1000:.2f} ms")

import struct

def encode_sack_block(left, right):
    """编码 SACK 块"""
    return struct.pack('!II', left, right)

def decode_sack_blocks(data):
    """解码 SACK 块列表"""
    blocks = []
    for i in range(0, len(data) - 7, 8):
        left, right = struct.unpack('!II', data[i:i+8])
        blocks.append((left, right))
    return blocks

# 示例
blocks = [
    (1000, 2000),  # 已收到 1000-1999
    (4000, 5000),  # 已收到 4000-4999
]

# 编码
encoded = b''.join(encode_sack_block(l, r) for l, r in blocks)
print(f"编码后: {encoded.hex()}")

# 解码
decoded = decode_sack_blocks(encoded)
print(f"解码后: {decoded}")  # [(1000, 2000), (4000, 5000)]

def parse_tcp_options(data):
    """解析所有 TCP 选项"""
    options = []
    i = 0
    
    while i < len(data):
        kind = data[i]
        
        if kind == 0:  # EOL
            break
        
        elif kind == 1:  # NOP
            options.append({'type': 'NOP'})
            i += 1
        
        elif i + 1 < len(data):
            length = data[i + 1]
            
            if kind == 2:  # MSS
                if length == 4 and i + 4 <= len(data):
                    mss = struct.unpack('!H', data[i+2:i+4])[0]
                    options.append({'type': 'MSS', 'value': mss})
            
            elif kind == 3:  # Window Scale
                if length == 3 and i + 3 <= len(data):
                    scale = data[i+2]
                    options.append({'type': 'WindowScale', 'value': scale})
            
            elif kind == 4:  # SACK Permitted
                options.append({'type': 'SACK_Permitted'})
            
            elif kind == 5:  # SACK
                blocks = []
                for j in range(i+2, i+length-7, 8):
                    if j+8 <= i+length:
                        left, right = struct.unpack('!II', data[j:j+8])
                        blocks.append((left, right))
                options.append({'type': 'SACK', 'blocks': blocks})
            
            elif kind == 8:  # Timestamp
                if length == 10 and i + 10 <= len(data):
                    tsv, tsr = struct.unpack('!II', data[i+2:i+10])
                    options.append({'type': 'Timestamp', 'tsv': tsv, 'tsr': tsr})
            
            else:
                options.append({'type': f'Unknown({kind})', 'length': length})
            
            i += length
        else:
            break
    
    return options

# 示例
# MSS(4) + NOP(1) + WScale(3) + NOP(1) + SACK_OK(2) + NOP(1) + TS(10) = 22 bytes
options_data = bytes([
    2, 4, 0x05, 0xB4,          # MSS = 1460
    1,                          # NOP
    3, 3, 7,                    # Window Scale = 7
    1,                          # NOP
    4, 2,                       # SACK Permitted
    1,                          # NOP
    8, 10, 0, 0, 0, 100, 0, 0, 0, 0  # Timestamp
])

parsed = parse_tcp_options(options_data)
for opt in parsed:
    print(opt)

# 启用 TFO
$ sysctl -w net.ipv4.tcp_fastopen=3
# 0: 禁用
# 1: 客户端启用
# 2: 服务器启用
# 3: 双方启用

# 查看 TFO 状态
$ cat /proc/net/netstat | grep TcpExtTCPFastOpen