[Go]取得實體網卡的IPv4網路遮罩(Get device network mask)

January 12th, 2016

##前言

最近在研究一些Golang在UDP上的處理，主要是要抓取網路遮罩(network mask)做一些進階使用．就發現要取得正確的網路遮罩，其實是蠻困難的．由於是無法直接使用到裝置上面的網卡設定．

這邊介紹一下相關的流程:

###先來抓取IPv4

這邊先顯示抓取IP的方式:

func GetIP() net.IP {

	ifaces, err := net.Interfaces()
	// handle err
	if err != nil {
		log.Println("No network:", err)
		return nil
	}

	for _, i := range ifaces {
		//只抓取網路卡名稱為"en0", "en1"...
		if strings.Contains(i.Name, "en") {
			addrs, err := i.Addrs()
			// handle err
			if err != nil {
				log.Println("No IP:", err)
				return nil
			}

			for _, addr := range addrs {
				var ip net.IP
				switch v := addr.(type) {
				case *net.IPNet:
					log.Println("IPNET")
					ip = v.IP
				case *net.IPAddr:
					log.Println("IPAddr")
					ip = v.IP
				}
				
				//這裡會抓取兩種IP，分別是IPv4與IPv6
				if ip[0] == 0 {
					//第一個byte是0為IPv4
					log.Println("Get device:", i.Name)
					return ip
				}
			}
		}
	}

	return nil
}

透過這個方式可以列舉所有的網路卡並且把第一張具有IPv4資料的net.IP傳回來．

###再來找Network Mask

其實透過官方的API，原本就有一個IP.DefaultMask()的函式可以使用．不過抓來的Network Mask是透過計算而來的，而不是跟網卡拿的．透過以下的範例:

 package main

 import (
         "fmt"
         "net"
 )

 func main() {
         addr := net.ParseIP("192.168.1.1")
         mask := addr.DefaultMask()
         fmt.Printf("Address : %s \n Network : %s \n", addr.String(), mask)
        //Mask 255, 255, 255, 0
 
         addr = net.ParseIP("172.16.110.123")
         mask = addr.DefaultMask()
         fmt.Printf("Address : %s \n Network : %s \n", addr.String(), mask)
        //Mask 255, 255, 0, 0
}

這邊可以看到，如果你的內部網路不是設定192.168.XXX.XXX的話，你抓到的mask都會是255.255.0.9．這樣的結果跟你在網路卡上面查到的可能會完全不相同．

###跟網卡拿取資料

比較好也比較不容易有問題的方式，就是直接透過系統的指令(console)去跟OS拿取網卡的資料．這裡貼上兩種方式:

Windows 版本(目前Go 1.5.2 broken，預計Go 1.6會修好)

網路上搜尋到的應該都是透過這個方式，不過在Go 1.5.2似乎broken了，聽說Go 1.6會修好．可以參考這個Go: issue 12551

	package main

	import(
	"fmt"
	"net"
	"os"
	"strings"
	"syscall"
	"unsafe"
	"runtime"
	)

	func main(){
	fmt.Println(runtime.Version())
	fmt.Println(GetV4LansGolang())
	fmt.Println(GetV4LansWinAPI())
	}

	func GetV4LansGolang() ([]*net.IPNet, error) {
	addrs, err := net.InterfaceAddrs()
	if err != nil {
	return nil, err
	}

	nets := make([]*net.IPNet, 0, len(addrs))

	for _, addr := range addrs {
	netw, ok := addr.(*net.IPNet)
	if ok {

	if netw.IP.To4() != nil {
	nets = append(nets, netw)
	}

	}
	}
	return nets, nil
	}

	func getAdapterList() (*syscall.IpAdapterInfo, error) {
	b := make([]byte, 10240)
	l := uint32(len(b))
	a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
	// TODO(mikio): GetAdaptersInfo returns IP_ADAPTER_INFO that
	// contains IPv4 address list only. We should use another API
	// for fetching IPv6 stuff from the kernel.
	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 GetV4LansWinAPI() ([]*net.IPNet, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
	return nil, err
	}

	nets := make([]*net.IPNet, 0, len(ifaces))

	aList, err := getAdapterList()
	if err != nil {
	return nil, err
	}

	for _, ifi := range ifaces {
	for ai := aList; ai != nil; ai = ai.Next {
	index := ai.Index

	if ifi.Index == int(index) {
	ipl := &ai.IpAddressList
	for ; ipl != nil; ipl = ipl.Next {
	ipStr := strings.Trim(string(ipl.IpAddress.String[:]), "\x00")
	maskStr := strings.Trim(string(ipl.IpMask.String[:]), "\x00")
	ip := net.ParseIP(ipStr)
	maskip := net.ParseIP(maskStr)
	if ip.IsUnspecified() \|\| maskip.IsUnspecified() {
	continue
	}
	nets = append(nets, &net.IPNet{
	IP: ip,
	Mask: net.IPv4Mask(
	maskip[net.IPv6len-net.IPv4len],
	maskip[net.IPv6len-net.IPv4len+1],
	maskip[net.IPv6len-net.IPv4len+2],
	maskip[net.IPv6len-net.IPv4len+3],
	),
	})
	}
	}
	}
	}
	return nets, err
	}

view raw getNetworkmaskWIN.go hosted with ❤ by GitHub

Mac OSX的版本，透過Ipconfig指令來抓取

這是我自己尋找的，透過Mac OS X的命令列來抓取資料，其實是比較簡單也比較方便的．不會因為版本有太大的問題．使用方式就是call GetNetMask("en0")

	func GetNetMask(deviceName string) string {
	switch runtime.GOOS {
	case "darwin":
	cmd := exec.Command("ipconfig", "getoption", deviceName, "subnet_mask")
	out, err := cmd.CombinedOutput()
	if err != nil {
	return ""
	}

	nm := strings.Replace(string(out), "\n", "", -1)
	log.Println("netmask=", nm, " OS=", runtime.GOOS)
	return nm
	default:
	return ""
	}
	return ""
	}