// +build darwin package net import ( "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/common" ) // example of netstat -idbn output on yosemite // Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll Drop // lo0 16384 869107 0 169411755 869107 0 169411755 0 0 // lo0 16384 ::1/128 ::1 869107 - 169411755 869107 - 169411755 - - // lo0 16384 127 127.0.0.1 869107 - 169411755 869107 - 169411755 - - func NetIOCounters(pernic bool) ([]NetIOCountersStat, error) { out, err := exec.Command("/usr/sbin/netstat", "-ibdn").Output() if err != nil { return nil, err } lines := strings.Split(string(out), "\n") ret := make([]NetIOCountersStat, 0, len(lines)-1) exists := make([]string, 0, len(ret)) for _, line := range lines { values := strings.Fields(line) if len(values) < 1 || values[0] == "Name" { // skip first line continue } if common.StringsHas(exists, values[0]) { // skip if already get continue } exists = append(exists, values[0]) base := 1 // sometimes Address is ommitted if len(values) < 11 { base = 0 } parsed := make([]uint64, 0, 7) vv := []string{ values[base+3], // Ipkts == PacketsRecv values[base+4], // Ierrs == Errin values[base+5], // Ibytes == BytesRecv values[base+6], // Opkts == PacketsSent values[base+7], // Oerrs == Errout values[base+8], // Obytes == BytesSent } if len(values) == 12 { vv = append(vv, values[base+10]) } for _, target := range vv { if target == "-" { parsed = append(parsed, 0) continue } t, err := strconv.ParseUint(target, 10, 64) if err != nil { return nil, err } parsed = append(parsed, t) } n := NetIOCountersStat{ Name: values[0], PacketsRecv: parsed[0], Errin: parsed[1], BytesRecv: parsed[2], PacketsSent: parsed[3], Errout: parsed[4], BytesSent: parsed[5], } if len(parsed) == 7 { n.Dropout = parsed[6] } ret = append(ret, n) } if pernic == false { return getNetIOCountersAll(ret) } return ret, nil } // Return a list of network connections opened. func NetConnections(kind string) ([]NetConnectionStat, error) { return NetConnectionsPid(kind, 0) } // Return a list of network connections opened by a process. func NetConnectionsPid(kind string, pid int32) ([]NetConnectionStat, error) { var ret []NetConnectionStat args := []string{"-i"} switch strings.ToLower(kind) { default: fallthrough case "": fallthrough case "all": fallthrough case "inet": args = append(args, "tcp") case "inet4": args = append(args, "4") case "inet6": args = append(args, "6") case "tcp": args = append(args, "tcp") case "tcp4": args = append(args, "4tcp") case "tcp6": args = append(args, "6tcp") case "udp": args = append(args, "udp") case "udp4": args = append(args, "6udp") case "udp6": args = append(args, "6udp") case "unix": return ret, common.NotImplementedError } // we can not use -F filter to get all of required information at once. r, err := common.CallLsof(invoke, pid, args...) if err != nil { return nil, err } for _, rr := range r { if strings.HasPrefix(rr, "COMMAND") { continue } n, err := parseNetLine(rr) if err != nil { // fmt.Println(err) // TODO: should debug print? continue } ret = append(ret, n) } return ret, nil }