type IPv4Conn
    func ListenIPv4(ifi *net.Interface, cfg IPv4Config) (*IPv4Conn, error)
    func (c *IPv4Conn) Close() error
    func (c *IPv4Conn) ReadFrom(ctx context.Context) (*icmp.Message, netip.Addr, error)
    func (c *IPv4Conn) SetTOS(tos int) error
    func (c *IPv4Conn) WriteTo(ctx context.Context, msg *icmp.Message, dst netip.Addr) error

var (
	count        = pflag.IntP("count", "c", 0, "count, 0 means non-setting")
	tos          = pflag.IntP("tos", "z", 0, "tos, 0 means non-setting")
	packetSize   = pflag.IntP("size", "s", 64, "packet size")
	timeout      = pflag.DurationP("timeout", "t", time.Second, "timeout")
	rate         = pflag.IntP("rate", "r", 100, "rate, 100 means 100 packets per second for each target")
	delay        = pflag.IntP("delay", "d", 3, "delay seconds")
	bitflipCheck = pflag.BoolP("bitflip", "", false, "check bitflip")
)

   addrs := qianmo.NonLoopbackAddrs()
if len(addrs) == 0 {
	return errors.New("no non-loopback address")
}
iface, err := qianmo.InterfaceByIP(addrs[0])
if err != nil {
	return fmt.Errorf("failed to get interface by ip: %w", err)
}
conn, err := icmpx.ListenIPv4(iface, icmpx.IPv4Config{
	Filter: icmpx.IPv4AllowOnly(ipv4.ICMPTypeEchoReply),
})
   ...
go send(conn) // 发包
go printStat() // 定期统计输出
return read(conn) // 读包

func send(conn *icmpx.IPv4Conn) {
	defer connOnce.Do(func() { conn.Close() })
    // 限流器，按照我们需要的速率发送
	limiter := ratelimit.New(*rate, ratelimit.Per(time.Second))
	...... // 准备发送的数据
	sentPackets := 0
	for {
		seq++ // 用来将发送的包和回来的包匹配
		ts := time.Now().UnixNano()
		binary.LittleEndian.PutUint64(data[len(msgPrefix):], uint64(ts)) // 把发送时的时间戳放入payload, 以便计算时延
        // 发送的icmp包
		req := &icmp.Message{
			Type: ipv4.ICMPTypeEcho,
			Body: &icmp.Echo{
				ID:   int(id),
				Seq:  int(seq),
				Data: data,
			},
		}
		limiter.Take() // 获取一个令牌，开始发包
		for _, target := range targetAddrs { //对每一个目标，都使用这个conn发送
			key := ts / int64(time.Second)
			stat.Add(key, &Result{ // 统计发包
				ts:     ts,
				target: target,
				seq:    seq,
			})
			ctx, cancel := context.WithTimeout(context.Background(), *timeout)
			err := conn.WriteTo(ctx, req, netip.MustParseAddr(target)) // 写入
			cancel()
			if err != nil {
				return
			}
		}
		......
	}
}

func read(conn *icmpx.IPv4Conn) error {
	defer connOnce.Do(func() { conn.Close() })
	for {
		ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration((*delay)))
        // 读取ICMP返回的包
		msg, addr, err := conn.ReadFrom(ctx)
		cancel()
		if err != nil {
			return nil
		}
        
        ......
		switch pkt := msg.Body.(type) {
		case *icmp.Echo:
			if uint16(pkt.ID) != id { // 检查id
				continue
			}
			if len(pkt.Data) < len(msgPrefix)+8 {
				continue
			}
			if !bytes.HasPrefix(pkt.Data, msgPrefix) { //检查前缀是否匹配
				continue
			}
			ts := int64(binary.LittleEndian.Uint64(pkt.Data[len(msgPrefix):])) // 获取时间戳
			key := ts / int64(time.Second)
			bitflip := false
			if *bitflipCheck { // 检查是否有改包
				bitflip = !bytes.Equal(pkt.Data[len(msgPrefix)+8:], payload)
			}
			stat.Add(key, &Result{ // 统计回包
				ts:       ts,
				target:   target,
				latency:  time.Now().UnixNano() - ts,
				received: true,
				seq:      uint16(pkt.Seq),
				bitflip:  bitflip,
			})
		}
	}
}

func printStat() {
	delayInSeconds := int64(*delay) // 5s
	ticker := time.NewTicker(time.Second)
	var lastKey int64
	for range ticker.C {
		if bucket.Key <= time.Now().UnixNano()/int64(time.Second)-delayInSeconds {
			pop := stat.Pop().(*Bucket)
			......
			targetResult := make(map[string]*TargetResult)
			for _, r := range pop.Value {
				target := r.target
				tr := targetResult[target]
				if tr == nil {
					tr = &TargetResult{}
					targetResult[target] = tr
				}
				tr.latency += r.latency // 把时延加在一起，输出的时候算平均值
				if r.received { // 如果是回包，回包数加一
					tr.received++ 
				} else { // 否则丢包数加一
					tr.loss++
				}
				if *bitflipCheck && r.bitflip { // 改包的数
					tr.bitflipCount++
				}
			}
			for target, tr := range targetResult {
				......
				if *bitflipCheck {
					...... // 输出统计信息
                    log.Printf("%s: sent:%d, recv:%d,  loss rate: %.2f%%, latency: %v, bitflip: %d\n", target, total, tr.received, lossRate*100, time.Duration(tr.latency/int64(tr.received)), tr.bitflipCount)
				} else {
                    ...... // 输出统计信息
				}
			}
		}
	}
}