func getNetDevStats() (map[string]map[string]string, error) { netDev := map[string]map[string]string{} var ifap, ifa *C.struct_ifaddrs if C.getifaddrs(&ifap) == -1 { return nil, errors.New("getifaddrs() failed") } defer C.freeifaddrs(ifap) for ifa = ifap; ifa != nil; ifa = ifa.ifa_next { if ifa.ifa_addr.sa_family == C.AF_LINK { devStats := map[string]string{} data := (*C.struct_if_data)(ifa.ifa_data) devStats["receive_packets"] = strconv.Itoa(int(data.ifi_ipackets)) devStats["transmit_packets"] = strconv.Itoa(int(data.ifi_opackets)) devStats["receive_errs"] = strconv.Itoa(int(data.ifi_ierrors)) devStats["transmit_errs"] = strconv.Itoa(int(data.ifi_oerrors)) devStats["receive_bytes"] = strconv.Itoa(int(data.ifi_ibytes)) devStats["transmit_bytes"] = strconv.Itoa(int(data.ifi_obytes)) devStats["receive_multicast"] = strconv.Itoa(int(data.ifi_imcasts)) devStats["transmit_multicast"] = strconv.Itoa(int(data.ifi_omcasts)) devStats["receive_drop"] = strconv.Itoa(int(data.ifi_iqdrops)) devStats["transmit_drop"] = strconv.Itoa(int(data.ifi_oqdrops)) netDev[C.GoString(ifa.ifa_name)] = devStats } } return netDev, nil }
func getNetDevStats(ignore *regexp.Regexp) (map[string]map[string]string, error) { netDev := map[string]map[string]string{} var ifap, ifa *C.struct_ifaddrs if C.getifaddrs(&ifap) == -1 { return nil, errors.New("getifaddrs() failed") } defer C.freeifaddrs(ifap) for ifa = ifap; ifa != nil; ifa = ifa.ifa_next { if ifa.ifa_addr.sa_family == C.AF_LINK { dev := C.GoString(ifa.ifa_name) if ignore.MatchString(dev) { log.Debugf("Ignoring device: %s", dev) continue } devStats := map[string]string{} data := (*C.struct_if_data)(ifa.ifa_data) devStats["receive_packets"] = strconv.FormatUint(uint64(data.ifi_ipackets), 10) devStats["transmit_packets"] = strconv.FormatUint(uint64(data.ifi_opackets), 10) devStats["receive_errs"] = strconv.FormatUint(uint64(data.ifi_ierrors), 10) devStats["transmit_errs"] = strconv.FormatUint(uint64(data.ifi_oerrors), 10) devStats["receive_bytes"] = strconv.FormatUint(uint64(data.ifi_ibytes), 10) devStats["transmit_bytes"] = strconv.FormatUint(uint64(data.ifi_obytes), 10) devStats["receive_multicast"] = strconv.FormatUint(uint64(data.ifi_imcasts), 10) devStats["transmit_multicast"] = strconv.FormatUint(uint64(data.ifi_omcasts), 10) netDev[dev] = devStats } } return netDev, nil }
// We currently only set up information for interfaces with IPv4 // addresses associated with them. // // Solaris's getifaddrs() (currently) only returns results for // interfaces that have been configured with IP addresses. // Inactive interfaces are thus silently omitted, unlike on eg // Linux. // // TODO: I should figure out some scheme of first trying the // net.Interfaces() stuff, so that when Go 1.x finally gets // support for it on Solaris we'll automatically start to // use it. func setupNetinfo() error { var ifap *C.struct_ifaddrs rc, err := C.getifaddrs(&ifap) if rc != 0 || err != nil { C.freeifaddrs(ifap) return err } ifaces := make(set) // Note that the ifap list has one entry *per IP*; if a single // interface has multiple IPs associated with it, via eg // aliases, the interface will show up multiple times as we // traverse the list. This is unlike net.Interfaces(). for fi := ifap; fi != nil; fi = fi.ifa_next { // sorry, I only deal with IPv4 right now. if fi.ifa_addr.sa_family != C.AF_INET { continue } iname := C.GoString(fi.ifa_name) ifaces.add(iname) if (fi.ifa_flags & C.IFF_LOOPBACK) > 0 { netinfo.loopbacks.add(iname) } if (fi.ifa_flags & C.IFF_POINTOPOINT) > 0 { netinfo.pointtopoint.add(iname) } // Get the IPv4 address associated with this entry. // We set it up as a string. // // Reverse engineering what the sin_addr field is // called by CGo was a pain in the ass. Thank goodness // for %#v is all I can say; CGo apparently takes the // leading _ off what is really '_S_un' for its own // reasons. // // Because this is a union, CGo sets it up as a // uint8 buffer. This is very convenient for us because // we want to interpret it that way anyways so we can // just Sprintf() the bytes into a string. t := (*C.struct_sockaddr_in)(unsafe.Pointer(fi.ifa_addr)).sin_addr.S_un ipstr := fmt.Sprintf("%d.%d.%d.%d", t[0], t[1], t[2], t[3]) netinfo.ipmap.add(ipstr, iname) } C.freeifaddrs(ifap) netinfo.ifaces = ifaces.members() return nil }
func NewInterfaces() ([]InterfaceTotal, string) { var ifaces *C.struct_ifaddrs if getrc, _ := C.getifaddrs(&ifaces); getrc != 0 { return []InterfaceTotal{}, "" } defer C.freeifaddrs(ifaces) ifs := []InterfaceTotal{} IP := "" for fi := ifaces; fi != nil; fi = fi.ifa_next { if fi.ifa_addr == nil { continue } ifa_name := C.GoString(fi.ifa_name) if IP == "" && fi.ifa_addr.sa_family == C.AF_INET && ifa_name != "lo" && !rx_lo.Match([]byte(ifa_name)) && realInterfaceName(ifa_name) { sa_in := (*C.struct_sockaddr_in)(unsafe.Pointer(fi.ifa_addr)) if C.inet_ntop( C.int(fi.ifa_addr.sa_family), // C.AF_INET, unsafe.Pointer(&sa_in.sin_addr), &C.ADDR[0], C.socklen_t(unsafe.Sizeof(C.ADDR))) != nil { IP = C.GoString((*C.char)(unsafe.Pointer(&C.ADDR))) } } if fi.ifa_addr.sa_family != C.AF_LINK { continue } data := fi.ifa_data if C.Ibytes(data) == 0 && C.Obytes(data) == 0 { continue } ifs = append(ifs, InterfaceTotal{ Name: ifa_name, In: uint(C.Ibytes(data)), Out: uint(C.Obytes(data)), }) } return ifs, IP }
// Getifaddrs returns a list of IfData. Unlike with getifaddrs(3) the // IfData has merged link level and interface address data. func Getifaddrs() ([]IfData, error) { var ifaces *C.struct_ifaddrs if rc, err := C.getifaddrs(&ifaces); rc != 0 { return []IfData{}, err } defer C.freeifaddrs(ifaces) ips := make(map[string]string) ifs := []IfData{} for fi := ifaces; fi != nil; fi = fi.ifa_next { if fi.ifa_addr == nil { continue } ifaName := C.GoString(fi.ifa_name) if ip, ok := ntop(fi); ok { ips[ifaName] = ip continue // fi.ifa_addr.sa_family == C.AF_INET } if fi.ifa_addr.sa_family != C.AF_LINK { continue } data := fi.ifa_data it := IfData{ Name: ifaName, InBytes: uint(C.Ibytes(data)), OutBytes: uint(C.Obytes(data)), InPackets: uint(C.Ipackets(data)), OutPackets: uint(C.Opackets(data)), InErrors: uint(C.Ierrors(data)), OutErrors: uint(C.Oerrors(data)), } if ip, ok := ips[ifaName]; ok { it.IP = ip } ifs = append(ifs, it) } for i, ifdata := range ifs { if ifdata.IP != "" { continue } if ip, ok := ips[ifdata.Name]; ok { ifs[i].IP = ip } } return ifs, nil }
func NewInterfaces(CH chan InterfacesInfo) { var ifaces *C.struct_ifaddrs if getrc, _ := C.getifaddrs(&ifaces); getrc != 0 { CH <- InterfacesInfo{} return } defer C.freeifaddrs(ifaces) ifs := []InterfaceInfo{} IP := "" for fi := ifaces; fi != nil; fi = fi.ifa_next { if fi.ifa_addr == nil { continue } ifa_name := C.GoString(fi.ifa_name) if IP == "" && fi.ifa_addr.sa_family == C.AF_INET && !rx_lo.Match([]byte(ifa_name)) && realInterfaceName(ifa_name) { sa_in := (*C.struct_sockaddr_in)(unsafe.Pointer(fi.ifa_addr)) if C.inet_ntop( C.int(fi.ifa_addr.sa_family), // C.AF_INET, unsafe.Pointer(&sa_in.sin_addr), &C.ADDR[0], C.socklen_t(unsafe.Sizeof(C.ADDR))) != nil { IP = C.GoString((*C.char)(unsafe.Pointer(&C.ADDR))) } } if fi.ifa_addr.sa_family != C.AF_LINK { continue } data := fi.ifa_data it := InterfaceInfo{ Name: ifa_name, InBytes: uint(C.Ibytes(data)), OutBytes: uint(C.Obytes(data)), InPackets: uint(C.Ipackets(data)), OutPackets: uint(C.Opackets(data)), InErrors: uint(C.Ierrors(data)), OutErrors: uint(C.Oerrors(data)), } if it.InBytes == 0 && it.OutBytes == 0 && it.InPackets == 0 && it.OutPackets == 0 && it.InErrors == 0 && it.OutErrors == 0 { continue } ifs = append(ifs, it) } CH <- InterfacesInfo{ List: ifs, IP: IP, } }