Go语言如何获取网卡信息

func Interfaces() ([]Interface, error) {}

func InterfaceAddrs() ([]Addr, error) {}

func InterfaceByIndex(index int) (*Interface, error) {}

func InterfaceByName(name string) (*Interface, error) {}

type Interface struct {
	Index        int          // positive integer that starts at one, zero is never used
	MTU          int          // maximum transmission unit
	Name         string       // e.g., "en0", "lo0", "eth0.100"
	HardwareAddr HardwareAddr // IEEE MAC-48, EUI-48 and EUI-64 form
	Flags        Flags        // e.g., FlagUp, FlagLoopback, FlagMulticast
}

type Addr interface {
	Network() string // name of the network (for example, "tcp", "udp", "ip+net")
	String() string  // string form of address (for example, )
}

func getAdapterList() (*syscall.IpAdapterInfo, error) {
	b := make([]byte, 1000)
	l := uint32(len(b))
	a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
	err := syscall.GetAdaptersInfo(a, &l)
	if err == syscall.ERROR_BUFFER_OVERFLOW {
		b = make([]byte, l)
		a = (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
		err = syscall.GetAdaptersInfo(a, &l)
	}
	if err != nil {
		return nil, os.NewSyscallError("GetAdaptersInfo", err)
	}
	return a, nil
}

type IpAdapterInfo struct {
	Next                *IpAdapterInfo
	ComboIndex          uint32
	AdapterName         [MAX_ADAPTER_NAME_LENGTH + 4]byte
	Description         [MAX_ADAPTER_DESCRIPTION_LENGTH + 4]byte
	AddressLength       uint32
	Address             [MAX_ADAPTER_ADDRESS_LENGTH]byte
	Index               uint32
	Type                uint32
	DhcpEnabled         uint32
	CurrentIpAddress    *IpAddrString
	IpAddressList       IpAddrString
	GatewayList         IpAddrString
	DhcpServer          IpAddrString
	HaveWins            bool
	PrimaryWinsServer   IpAddrString
	SecondaryWinsServer IpAddrString
	LeaseObtained       int64
	LeaseExpires        int64
}

func FindAllDevs() (ifs []Interface, err error) {}

type Interface struct {
	Name        string
	Description string
	Flags       uint32
	Addresses   []InterfaceAddress
}
type InterfaceAddress struct {
	IP        net.IP
	Netmask   net.IPMask // Netmask may be nil if we were unable to retrieve it.
	Broadaddr net.IP     // Broadcast address for this IP may be nil
	P2P       net.IP     // P2P destination address for this IP may be nil
}

func OpenLive(device string, snaplen int32, promisc bool, timeout time.Duration) (handle *Handle, _ error) {}
func OpenOffline(file string) (handle *Handle, err error) {}
func OpenOfflineFile(file *os.File) (handle *Handle, err error) {}

package main

import (
	"fmt"
	"github.com/google/gopacket/pcap"
	"log"
	"net"
	"os"
	"syscall"
	"unsafe"
)

func getAdapterList() (*syscall.IpAdapterInfo, error) {
	b := make([]byte, 1000)
	l := uint32(len(b))
	a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
	err := syscall.GetAdaptersInfo(a, &l)
	if err == syscall.ERROR_BUFFER_OVERFLOW {
		b = make([]byte, l)
		a = (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
		err = syscall.GetAdaptersInfo(a, &l)
	}
	if err != nil {
		return nil, os.NewSyscallError("GetAdaptersInfo", err)
	}
	return a, nil
}

func localAddresses() error {
	fmt.Println("测试net.Interfaces()\n")
	ifaces, err := net.Interfaces()
	if err != nil {
		return err
	}
	for _, iface := range ifaces {
		fmt.Printf("%+v\n", iface)
	}
	fmt.Println()

	fmt.Println("测试net.InterfaceAddrs()")
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		return err
	}
	for _, addr := range addrs {
		fmt.Printf("\n%+v\n", addr.String())
		fmt.Printf("%+v\n", addr.Network())
	}
	fmt.Println()
	//net.InterfaceByIndex()
	//net.InterfaceByName()
	//for _, addr := range addrs {
	//	fmt.Printf("%T", addr)
	//	// 这个网络地址是IP地址: ipv4, ipv6
	//	ipNet1, isIpNet1 := addr.(*net.IPNet)
	//	fmt.Println(ipNet1)
	//	fmt.Println(isIpNet1)
	//	if ipNet, isIpNet := addr.(*net.IPNet); isIpNet && !ipNet.IP.IsLoopback() {
	//		// 跳过IPV6
	//		if ipNet.IP.To4() != nil {
	//			ipv4 := ipNet.IP.String() // 192.168.1.1
	//			fmt.Println(ipv4)
	//		}
	//	}
	//}

	fmt.Println("测试基于syscall的getAdapterList()")
	aList, err := getAdapterList()
	if err != nil {
		return err
	}
	for ai := aList; ai != nil; ai = ai.Next {
		fmt.Printf("\nIndex:\t%v\n", ai.Index)
		fmt.Printf("AdapterName:\t%s\n", &ai.AdapterName)
		fmt.Printf("Description:\t%s\n", &ai.Description)
		fmt.Printf("Address:\t%s\n", &ai.Address)
		ipl := &ai.IpAddressList
		gwl := &ai.GatewayList
		dhcpl := &ai.DhcpServer
		for ; ipl != nil; ipl = ipl.Next {
			fmt.Printf("IpAddress:\t%s\n", ipl.IpAddress)
			fmt.Printf("IpMask:\t%s\n", ipl.IpMask)
			fmt.Printf("GatewayIp:\t%s\n", gwl.IpAddress)
			fmt.Printf("DHCPServerIp:\t%s\n", dhcpl.IpAddress)
		}
	}
	fmt.Println()

	return err
}

func main() {
	if e := localAddresses(); e != nil {
		fmt.Println(e)
	}

	fmt.Println("测试pcap.FindAllDevs()")
	// Find all devices
	devices, err := pcap.FindAllDevs()
	if err != nil {
		log.Fatal(err)
	}
	// Print device information
	for _, device := range devices {
		fmt.Println("\nName: ", device.Name)
		fmt.Println("Description: ", device.Description)
		fmt.Println("Devices Flags: ", device.Flags)
		fmt.Println("Devices addresses: ")
		for _, address := range device.Addresses {
			fmt.Println("- IP address: ", address.IP)
			fmt.Println("- Subnet mask: ", address.Netmask)
			fmt.Println("- Broadaddr: ", address.Broadaddr)
		}
	}
}