// IsGlobalIP determs passed ip address is global or not.
// if ip address is global , it returns address type(ip4 or ip6).
func IsGlobalIP(trial net.IP) string {
type localIPrange struct {
from net.IP
to net.IP
}
locals := []localIPrange{
localIPrange{net.ParseIP("10.0.0.0"), net.ParseIP("10.255.255.255")},
localIPrange{net.ParseIP("172.16.0.0"), net.ParseIP("172.31.255.255")},
localIPrange{net.ParseIP("192.168.0.0"), net.ParseIP("192.168.255.255")}}
if trial == nil || trial.IsLoopback() {
return ""
}
//for udp6
if trial.To4() == nil {
if trial.IsGlobalUnicast() {
return "ip6"
}
return ""
}
//for udp4
for _, r := range locals {
if bytes.Compare(trial, r.from) >= 0 && bytes.Compare(trial, r.to) <= 0 {
return ""
}
}
return "ip4"
}
// Get IP addresses
//
// http://play.golang.org/p/BDt3qEQ_2H
func getIPStringAddresses() []string {
addrStrings := []string{}
if ifaces, err := net.Interfaces(); err == nil {
for _, iface := range ifaces {
// skip
if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
continue
}
if addrs, err := iface.Addrs(); err == nil {
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue
}
addrStrings = append(addrStrings, ip.String())
}
}
}
}
return addrStrings
}
// LocalIpv4Addrs scan all ip addresses with loopback excluded.
func LocalIpv4Addrs() ([]string, error) {
addrs, err := net.InterfaceAddrs()
if err != nil {
return nil, err
}
ips := make([]string, 0)
for _, addr := range addrs {
var ip net.IP
switch x := addr.(type) {
case *net.IPNet:
ip = x.IP
case *net.IPAddr:
ip = x.IP
default:
err = fmt.Errorf("unknown interface address type for: %+v", x)
return nil, err
}
if ip.IsLoopback() || ip.To4() == nil {
// loopback excluded, ipv6 excluded
continue
}
ips = append(ips, ip.String())
}
return ips, nil
}
func getv4loopback() (string, error) {
ifaces, err := net.Interfaces()
if err != nil {
return "", err
}
for _, iface := range ifaces {
if iface.Flags&net.FlagLoopback != 0 {
addrs, err := iface.Addrs()
if err != nil {
return "", err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
ip = ip.To4()
if ip == nil {
continue
}
if ip.IsLoopback() {
return ip.String(), nil
}
}
}
}
return "", errors.New("you do not have loopback?")
}
func getIP() net.IP {
ifaces, err := net.Interfaces()
if err != nil {
return nil
}
for _, iface := range ifaces {
if iface.Flags&net.FlagUp == 0 {
continue // interface down
}
if iface.Flags&net.FlagLoopback != 0 {
continue // loopback interface
}
addrs, err := iface.Addrs()
if err != nil {
return nil
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
return ip
}
}
return net.IPv6loopback
}
// getFirstLocalIPAddr returns the first available IP address of the local machine
// This is a fix for Beaglebone Black where net.LookupIP(hostname) return no IP address.
func getFirstLocalIPAddr() (net.IP, error) {
addrs, err := net.InterfaceAddrs()
if err != nil {
return nil, err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() || ip.IsUnspecified() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip, nil
}
return nil, errors.New("Could not determine ip address")
}
// findLoopbackDevice iterates through all the interfaces on a machine and
// returns the ip addr, mask of the loopback device
func (a *Agent) findLoopbackDevice() (string, string, string, error) {
var ifcs []net.Interface
var err error
ifcs, err = net.Interfaces()
if err != nil {
return "", "", "", err
}
for _, ifc := range ifcs {
addrs, err := ifc.Addrs()
if err != nil {
return "", "", "", err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip.IsLoopback() {
if ip.To4() == nil {
continue
}
return ifc.Name, ip.String(), addr.String(), nil
}
}
}
return "", "", "", fmt.Errorf("no loopback devices with IPV4 addr found")
}
func validateRemoteAddr(ip net.IP) bool {
if ip == nil {
return false
}
if ip.IsInterfaceLocalMulticast() {
return false
}
if ip.IsLinkLocalMulticast() {
return false
}
if ip.IsLinkLocalUnicast() {
return false
}
if ip.IsLoopback() {
return false
}
if ip.IsMulticast() {
return false
}
if ip.IsUnspecified() {
return false
}
if isBroadcasty(ip) {
return false
}
return true
}
func getIfaceIP(iface string) string {
i, err := net.InterfaceByName(iface)
if err != nil {
time.Sleep(time.Second * 5)
panic(err)
}
addrs, err := i.Addrs()
if err != nil {
time.Sleep(time.Second * 5)
panic(err)
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip.String()
}
panic("No IP for " + iface)
}
// 一个接口上的所有ip4地址
func addrsOfOneInterface(iface net.Interface) (addrs []*net.IPAddr) {
ifaddrs, err := iface.Addrs()
if (err != nil) || (len(ifaddrs) == 0) {
return
}
for _, ifaddr := range ifaddrs {
var ip net.IP
switch v := ifaddr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
default:
continue
}
if ip.IsLoopback() {
return
}
ip = ip.To4()
if ip != nil {
addr, _ := net.ResolveIPAddr("ip", ip.String())
addrs = append(addrs, addr)
}
}
return
}
// GetLocalIP return the first external-IP4 configured for the first
// interface connected to this node.
func GetLocalIP() (net.IP, error) {
interfaces, err := net.Interfaces()
if err != nil {
return nil, err
}
for _, iface := range interfaces {
if (iface.Flags & net.FlagUp) == 0 {
continue // interface down
}
if (iface.Flags & net.FlagLoopback) != 0 {
continue // loopback interface
}
addrs, err := iface.Addrs()
if err != nil {
return nil, err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip != nil && !ip.IsLoopback() {
if ip = ip.To4(); ip != nil {
return ip, nil
}
}
}
}
return nil, errors.New("cannot find local IP address")
}
func macAddress() (string, error) {
ifaces, err := net.Interfaces()
if err != nil {
return "", err
}
for _, iface := range ifaces {
if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
// interface down or loopback interface
continue
}
addrs, err := iface.Addrs()
if err != nil {
return "", err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() || ip.To4() == nil {
continue
}
return iface.HardwareAddr.String(), nil
}
}
return "", errors.New("not connected to the network")
}
// print interfaces to know where the proxy is listening
func printInterfaces() {
addrs, err := net.InterfaceAddrs()
if err != nil {
fmt.Println("Can't get interfaces. You have to have at least one network connection.")
log.Fatal("No interface found")
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPAddr:
case *net.IPNet:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
fmt.Println("http://" + ip.String() + Config.Service.Listen)
}
}
// GetIPAddress : Used to get IP of the running machine
func GetIPAddress() string {
ifaces, _ := net.Interfaces()
// handle err
for _, i := range ifaces {
addrs, _ := i.Addrs()
// handle err
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip.String()
// process IP address
}
}
return ""
}
func GetFirstInterface() (name string, ip string) {
ifaces, _ := net.Interfaces()
for _, iface := range ifaces {
addrs, _ := iface.Addrs()
ipV4 := false
ipAddrs := []string{}
for _, addr := range addrs {
var ip net.IP
if ipnet, ok := addr.(*net.IPNet); ok {
ip = ipnet.IP
} else if ipaddr, ok := addr.(*net.IPAddr); ok {
ip = ipaddr.IP
}
if ip != nil && ip.To4() != nil && !ip.IsLoopback() {
ipstr := addr.String()
idx := strings.Index(ipstr, "/")
if idx >= 0 {
ipstr = ipstr[:idx]
}
ipAddrs = append(ipAddrs, ipstr)
ipV4 = true
}
}
if !ipV4 {
continue
}
return iface.Name, ipAddrs[0]
}
return "", "0.0.0.0"
}
func getHost() (string, error) {
ifaces, err := net.Interfaces()
if err != nil {
return "", err
}
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
return "", err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip.String(), nil // process IP address
}
}
return "", fmt.Errorf("No interfaces found")
}
func routableIP(network string, ip net.IP) net.IP {
if !ip.IsLoopback() && !ip.IsLinkLocalUnicast() && !ip.IsGlobalUnicast() {
return nil
}
switch network {
case "ip4":
if ip := ip.To4(); ip != nil {
return ip
}
case "ip6":
if ip.IsLoopback() { // addressing scope of the loopback address depends on each implementation
return nil
}
if ip := ip.To16(); ip != nil && ip.To4() == nil {
return ip
}
default:
if ip := ip.To4(); ip != nil {
return ip
}
if ip := ip.To16(); ip != nil {
return ip
}
}
return nil
}
func getPublicIPv6(addresses []net.Addr) (net.IP, error) {
var candidates []net.IP
// Find public IPv6 address
for _, rawAddr := range addresses {
var ip net.IP
switch addr := rawAddr.(type) {
case *net.IPAddr:
ip = addr.IP
case *net.IPNet:
ip = addr.IP
default:
continue
}
if ip.To4() != nil {
continue
}
if ip.IsLinkLocalUnicast() || isUniqueLocalAddress(ip) || ip.IsLoopback() {
continue
}
candidates = append(candidates, ip)
}
numIps := len(candidates)
switch numIps {
case 0:
return nil, fmt.Errorf("No public IPv6 address found")
case 1:
return candidates[0], nil
default:
return nil, fmt.Errorf("Multiple public IPv6 addresses found. Please configure one.")
}
}
func ifaceToIp(iface *net.Interface) (string, error) {
addrs, err := iface.Addrs()
if err != nil {
return "", err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip.String(), nil
}
return "", errors.New("Node not connected to the network.")
}
func getIP() string {
ifaces, err := net.Interfaces()
if err != nil {
logger.WithField("_block", "getIP").Error(err)
return "127.0.0.1"
}
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
logger.WithField("_block", "getIP").Error(err)
return "127.0.0.1"
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPAddr:
ip = v.IP
case *net.IPNet:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
return ip.String()
}
}
return "127.0.0.1"
}
func GetLocalIP() (ip net.IP, err error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, err
}
// handle err
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
return nil, err
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
log.Println(ip.String())
if !ip.IsLoopback() && ip.String() != "0.0.0.0" && ip.To4() != nil {
return ip, nil
}
}
}
return nil, err
}
// If bind-address is usable, return it directly
// If bind-address is not usable (unset, 0.0.0.0, or loopback), we will use the host's default
// interface.
func ValidPublicAddrForMaster(bindAddress net.IP) (net.IP, error) {
if bindAddress == nil || bindAddress.IsUnspecified() || bindAddress.IsLoopback() {
hostIP, err := ChooseHostInterface()
if err != nil {
return nil, err
}
bindAddress = hostIP
}
return bindAddress, nil
}
func isLoopback(host string) bool {
if host == "localhost" {
return true
}
var ip net.IP
if ip = net.ParseIP(host); ip != nil {
return ip.IsLoopback()
}
return false
}
func (m *ipMatcher) Match(ip net.IP) bool {
if ip.IsLoopback() {
return true
}
for _, matchNet := range m.nets {
if matchNet.Contains(ip) {
return true
}
}
return false
}
func IntranetIP() (ips []string, err error) {
ips = make([]string, 0)
ifaces, e := net.Interfaces()
if e != nil {
return ips, e
}
for _, iface := range ifaces {
if iface.Flags&net.FlagUp == 0 {
continue // interface down
}
if iface.Flags&net.FlagLoopback != 0 {
continue // loopback interface
}
// ignore docker and warden bridge
if strings.HasPrefix(iface.Name, "docker") || strings.HasPrefix(iface.Name, "w-") {
continue
}
addrs, e := iface.Addrs()
if e != nil {
return ips, e
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
ipStr := ip.String()
if IsIntranet(ipStr) {
ips = append(ips, ipStr)
}
}
}
return ips, nil
}
// Helper function to check if a given IP is not public (non-routable).
func validateIP(ip net.IP) (bool, error) {
if ip.IsLoopback() {
return false, IPisLoopbackError
}
if ip.IsUnspecified() {
return false, IPisUnspecifiedError
}
if isInAddressRange(ip, ipv4Nonpublic, ipv6Nonpublic) {
return false, IPisNotPublicError
}
return true, nil
}
func (icmp *icmpPlugin) isLocalIP(ip net.IP) bool {
if ip.IsLoopback() {
return true
}
for _, localIP := range icmp.localIps {
if ip.Equal(localIP) {
return true
}
}
return false
}
func (icmp *Icmp) isLocalIp(ip net.IP) bool {
if ip.IsLoopback() {
return true
}
for _, localIp := range icmp.localIps {
if ip.Equal(localIp) {
return true
}
}
return false
}
func IpV4Map() (map[string]string, error) {
// fmt.Println("-----------------------------------------------------")
ipmap := map[string]string{}
ifaces, err := net.Interfaces()
// fmt.Printf("err: %v, ifaces %v\n", err, ifaces)
// pretty.Println(ifaces)
if err != nil {
return nil, err
}
for _, iface := range ifaces {
// go 1.4.2 on windows 2012, iface.Flags always return 0x0
// if iface.Flags&net.FlagUp == 0 {
// continue // interface down
// }
// if iface.Flags&net.FlagLoopback != 0 {
// continue // loopback interface
// }
addrs, err := iface.Addrs()
// fmt.Printf("err: %v, address: %s\n", err, addrs)
if err != nil {
return nil, err
}
for idx, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
ip = ip.To4()
if ip == nil {
continue // not an ipv4 address
}
key := fmt.Sprintf("%s(%d)", iface.HardwareAddr.String(), idx)
ipmap[key] = ip.String()
}
}
if len(ipmap) > 0 {
return ipmap, nil
} else {
return nil, errors.New("are you connected to the network?")
}
}
func (proc *ProcessesWatcher) IsLocalIp(ip net.IP) bool {
if ip.IsLoopback() {
return true
}
for _, addr := range proc.LocalAddrs {
if ip.Equal(addr) {
return true
}
}
return false
}