// 单网卡模式
addrs, err := net.InterfaceAddrs()
if err != nil {
   log.Fatal("无法获取本地网络信息:", err)
}
for i, a := range addrs {
   if ip, ok := a.(*net.IPNet); ok && !ip.IP.IsLoopback() {
       if ip.IP.To4() != nil {
           fmt.Println("IP:", ip.IP)
           fmt.Println("子网掩码:", ip.Mask)
           it, _ := net.InterfaceByIndex(i)
           fmt.Println("Mac地址:", it.HardwareAddr)
           break
       }
   }
}

type IP uint32
// 根据IP和mask换算内网IP范围
func Table(ipNet *net.IPNet) []IP {
    ip := ipNet.IP.To4()
    log.Info("本机ip:", ip)
    var min, max IP
    var data []IP
    for i := 0; i < 4; i++ {
        b := IP(ip[i] & ipNet.Mask[i])
        min += b << ((3 - uint(i)) * 8)
    }
    one, _ := ipNet.Mask.Size()
    max = min | IP(math.Pow(2, float64(32 - one)) - 1)
    log.Infof("内网IP范围:%s --- %s", min, max)
    // max 是广播地址，忽略
    // i & 0x000000ff  == 0 是尾段为0的IP，根据RFC的规定，忽略
    for i := min; i < max; i++ {
        if i & 0x000000ff == 0 {
            continue
        }
        data = append(data, i)
    }
    return data
}

type ARP struct {
	BaseLayer
	AddrType          LinkType     // 硬件类型
	Protocol          EthernetType // 协议类型
	HwAddressSize     uint8        // 硬件地址长度
	ProtAddressSize   uint8        // 协议地址长度
	Operation         uint16       // 操作符(1代表request 2代表reply)
	SourceHwAddress   []byte       // 发送者硬件地址
	SourceProtAddress []byte       // 发送者IP地址
	DstHwAddress      []byte       // 目标硬件地址（可以填写00:00:00:00:00:00)
	DstProtAddress    []byte       // 目标IP地址
}

// 发送arp包
// ip 目标IP地址
func sendArpPackage(ip IP) {
    srcIp := net.ParseIP(ipNet.IP.String()).To4()
    dstIp := net.ParseIP(ip.String()).To4()
    if srcIp == nil || dstIp == nil {
        log.Fatal("ip 解析出问题")
    }
    // 以太网首部
    // EthernetType 0x0806  ARP
    ether := &layers.Ethernet{
        SrcMAC: localHaddr,
        DstMAC: net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
        EthernetType: layers.EthernetTypeARP,
    }
    
    a := &layers.ARP{
        AddrType: layers.LinkTypeEthernet,
        Protocol: layers.EthernetTypeIPv4,
        HwAddressSize: uint8(6),
        ProtAddressSize: uint8(4),
        Operation: uint16(1), // 0x0001 arp request 0x0002 arp response
        SourceHwAddress: localHaddr,
        SourceProtAddress: srcIp,
        DstHwAddress: net.HardwareAddr{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        DstProtAddress: dstIp,
    }
    
    buffer := gopacket.NewSerializeBuffer()
    var opt gopacket.SerializeOptions
    gopacket.SerializeLayers(buffer, opt, ether, a)
    outgoingPacket := buffer.Bytes()
    
    handle, err := pcap.OpenLive(iface, 2048, false, 30 * time.Second)
    if err != nil {
        log.Fatal("pcap打开失败:", err)
    }
    defer handle.Close()
    
    err = handle.WritePacketData(outgoingPacket)
    if err != nil {
        log.Fatal("发送arp数据包失败..")
    }
}

func listenARP(ctx context.Context) {
    handle, err := pcap.OpenLive(iface, 1024, false, 10 * time.Second)
    if err != nil {
        log.Fatal("pcap打开失败:", err)
    }
    defer handle.Close()
    handle.SetBPFFilter("arp")
    ps := gopacket.NewPacketSource(handle, handle.LinkType())
    for {
        select {
        case <-ctx.Done():
            return
        case p := <-ps.Packets():
            arp := p.Layer(layers.LayerTypeARP).(*layers.ARP)
            if arp.Operation == 2 {
                mac := net.HardwareAddr(arp.SourceHwAddress)
                pushData(ParseIP(arp.SourceProtAddress).String(), mac, "", manuf.Search(mac.String()))
                go sendMdns(ParseIP(arp.SourceProtAddress), mac)
                go sendNbns(ParseIP(arp.SourceProtAddress), mac)
            }
        }
    }
}

go sendMdns(ParseIP(arp.SourceProtAddress), mac)
go sendNbns(ParseIP(arp.SourceProtAddress), mac)