第5天：网络命令入门 - ping

# 基本ping
ping baidu.com

# ping 4次后停止
ping -n 4 baidu.com

# 指定包大小（字节）
ping -l 1000 baidu.com

# 持续ping
ping -t baidu.com

# 基本ping
ping baidu.com

# ping 4次后停止
ping -c 4 baidu.com

# 指定包大小（字节）
ping -s 1000 baidu.com

# 快速ping（间隔0.2秒）
ping -i 0.2 baidu.com

$ ping baidu.com

PING baidu.com (220.181.38.148): 56 data bytes
64 bytes from 220.181.38.148: icmp_seq=0 ttl=52 time=28.5 ms
64 bytes from 220.181.38.148: icmp_seq=1 ttl=52 time=27.8 ms
64 bytes from 220.181.38.148: icmp_seq=2 ttl=52 time=28.1 ms
64 bytes from 220.181.38.148: icmp_seq=3 ttl=52 time=29.2 ms

--- baidu.com ping statistics ---
4 packets transmitted, 4 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 27.8/28.4/29.2/0.5 ms

# day05_simple_ping.py
# 功能：实现简单的ping工具

import socket
import struct
import time
import sys

def calculate_checksum(data):
    """
    计算ICMP校验和

    参数：
        data: 要计算校验和的数据（bytes）

    返回：
        校验和（int）

    工作原理：
        1. 将数据按16位分组求和
        2. 如果有进位，将进位加到结果上
        3. 取反码得到校验和
    """
    # 如果数据长度是奇数，补一个字节0
    if len(data) % 2 != 0:
        data += b'\x00'

    # 按16位（2字节）分组求和
    checksum = 0
    for i in range(0, len(data), 2):
        # 将两个字节组合成一个16位整数
        word = (data[i] << 8) + data[i + 1]
        checksum += word

    # 处理进位：将高16位加到低16位
    while checksum >> 16:
        checksum = (checksum & 0xFFFF) + (checksum >> 16)

    # 取反码
    checksum = ~checksum & 0xFFFF

    return checksum

def create_icmp_packet(packet_id, sequence):
    """
    创建ICMP Echo Request数据包

    参数：
        packet_id: 标识符（用于区分不同的ping进程）
        sequence: 序列号（标识第几个包）

    返回：
        完整的ICMP数据包（bytes）

    ICMP包结构：
        [类型(1字节) | 代码(1字节) | 校验和(2字节) |
         标识符(2字节) | 序列号(2字节) | 数据]
    """
    # ICMP类型：8=Echo Request
    icmp_type = 8
    # ICMP代码：0
    icmp_code = 0
    # 校验和：先设为0，稍后计算
    icmp_checksum = 0

    # 打包ICMP头部（不包括校验和）
    # ! = 网络字节序（大端）
    # B = unsigned char (1字节)
    # H = unsigned short (2字节)
    header = struct.pack('!BBHHH', icmp_type, icmp_code, icmp_checksum,
                         packet_id, sequence)

    # 数据部分：发送时间戳（用于计算RTT）
    data = struct.pack('!d', time.time())

    # 计算校验和
    icmp_checksum = calculate_checksum(header + data)

    # 重新打包，加入正确的校验和
    header = struct.pack('!BBHHH', icmp_type, icmp_code, icmp_checksum,
                         packet_id, sequence)

    return header + data

def parse_icmp_reply(packet):
    """
    解析ICMP Echo Reply数据包

    参数：
        packet: 接收到的数据包

    返回：
        (icmp_type, icmp_code, icmp_id, icmp_seq, send_time)
    """
    # IP头部通常是20字节，ICMP从第21字节开始
    icmp_header = packet[20:28]

    # 解析ICMP头部
    icmp_type, icmp_code, checksum, packet_id, sequence = struct.unpack(
        '!BBHHH', icmp_header
    )

    # 解析数据部分的时间戳
    send_time = struct.unpack('!d', packet[28:36])[0]

    return icmp_type, icmp_code, packet_id, sequence, send_time

def ping(host, count=4, timeout=3):
    """
    ping指定主机

    参数：
        host: 目标主机名或IP地址
        count: ping的次数
        timeout: 超时时间（秒）

    返回：
        统计信息字典
    """
    print(f"PING {host}")
    print()

    # 解析主机名为IP地址
    try:
        dest_ip = socket.gethostbyname(host)
        print(f"目标IP: {dest_ip}")
        print("-" * 60)
    except socket.gaierror:
        print(f"❌ 无法解析主机名: {host}")
        return None

    # 创建原始socket（需要root权限）
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
        sock.settimeout(timeout)
    except PermissionError:
        print("❌ 需要管理员权限运行此程序")
        print("💡 Linux/Mac: sudo python day05_simple_ping.py")
        print("💡 Windows: 以管理员身份运行")
        return None

    # 统计信息
    packet_id = 12345  # 可以用进程ID
    sent = 0
    received = 0
    rtt_list = []

    # 发送ping包
    for seq in range(count):
        try:
            # 创建ICMP包
            packet = create_icmp_packet(packet_id, seq)

            # 发送
            send_time = time.time()
            sock.sendto(packet, (dest_ip, 0))
            sent += 1

            # 接收回复
            try:
                reply_packet, addr = sock.recvfrom(1024)
                recv_time = time.time()

                # 解析回复
                icmp_type, icmp_code, reply_id, reply_seq, packet_send_time = \
                    parse_icmp_reply(reply_packet)

                # 检查是否是我们的包的回复
                if icmp_type == 0 and reply_id == packet_id and reply_seq == seq:
                    # 计算RTT
                    rtt = (recv_time - packet_send_time) * 1000  # 转换为毫秒
                    rtt_list.append(rtt)
                    received += 1

                    # 获取TTL
                    ttl = struct.unpack('!B', reply_packet[8:9])[0]

                    print(f"✅ 来自 {dest_ip}: icmp_seq={seq} ttl={ttl} "
                          f"time={rtt:.2f} ms")
                else:
                    print(f"⚠️  收到意外的ICMP包 type={icmp_type}")

            except socket.timeout:
                print(f"⏱️  icmp_seq={seq} 请求超时")

            # 等待1秒再发送下一个包
            if seq < count - 1:
                time.sleep(1)

        except Exception as e:
            print(f"❌ 发送失败: {e}")

    sock.close()

    # 打印统计信息
    print()
    print("-" * 60)
    print(f"📊 {host} ping统计信息:")
    print(f"   发送: {sent} 个包")
    print(f"   接收: {received} 个包")
    print(f"   丢失: {sent - received} 个包 ({((sent-received)/sent*100):.1f}% loss)")

    if rtt_list:
        print(f"   RTT: 最小={min(rtt_list):.2f}ms, "
              f"平均={sum(rtt_list)/len(rtt_list):.2f}ms, "
              f"最大={max(rtt_list):.2f}ms")
    print("-" * 60)

    return {
        'sent': sent,
        'received': received,
        'rtt_list': rtt_list
    }

def main():
    """
    主函数
    """
    print("=" * 60)
    print("简易Ping工具".center(60))
    print("=" * 60)
    print()

    # 获取目标主机
    if len(sys.argv) > 1:
        host = sys.argv[1]
    else:
        host = input("请输入要ping的主机名或IP: ").strip()
        if not host:
            host = "baidu.com"  # 默认

    # 执行ping
    result = ping(host, count=4, timeout=3)

    if result and result['received'] > 0:
        print()
        print("🎉 Ping完成！")
    else:
        print()
        print("❌ Ping失败或网络不可达")

if __name__ == "__main__":
    main()

# Linux/Mac（需要root权限）
sudo python code/day05/day05_simple_ping.py baidu.com

# Windows（以管理员身份运行）
python code\day05\day05_simple_ping.py baidu.com

# 不带参数运行，会提示输入主机名
sudo python code/day05/day05_simple_ping.py

sock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)

# 原理：
1. 将数据按16位分组
2. 所有分组相加
3. 如果有进位，加到低16位
4. 对结果取反码

# 接收方验证：
1. 对收到的数据（包括校验和）做同样的计算
2. 如果结果是0xFFFF，说明数据完整
3. 否则说明数据损坏

# 发送时在数据部分嵌入时间戳
data = struct.pack('!d', time.time())

# 收到回复时，解析时间戳
send_time = struct.unpack('!d', packet[28:36])[0]

# 计算RTT
rtt = (recv_time - send_time) * 1000  # 毫秒

# 基本用法
ping 目标主机

# 常用选项
-c 次数      # Linux/Mac: 指定ping次数
-n 次数      # Windows: 指定ping次数
-i 间隔      # 指定发送间隔（秒）
-s 大小      # 指定数据包大小
-t           # Windows: 持续ping

# Linux/Mac
ping -M do -s 1472 baidu.com

# Windows
ping -f -l 1472 baidu.com

# 如果成功，说明MTU >= 1500
# 如果失败，逐渐减小数值直到成功

# Linux（需要root权限）
sudo ping -f baidu.com

# 说明：尽可能快地发送包，用于压力测试
# ⚠️ 注意：不要对公共服务器使用，可能被视为攻击