1 files changed, 177 insertions, 0 deletions
diff --git a/weed/wdclient/net2/ip.go b/weed/wdclient/net2/ip.go
new file mode 100644
index 000000000..60e46342f
--- /dev/null
+++ b/weed/wdclient/net2/ip.go
@@ -0,0 +1,177 @@
+package net2
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"strings"
+	"sync"
+)
+
+var myHostname string
+var myHostnameOnce sync.Once
+
+// Like os.Hostname but caches first successful result, making it cheap to call it
+// over and over.
+// It will also crash whole process if fetching Hostname fails!
+func MyHostname() string {
+	myHostnameOnce.Do(func() {
+		var err error
+		myHostname, err = os.Hostname()
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
+	return myHostname
+}
+
+var myIp4 *net.IPAddr
+var myIp4Once sync.Once
+
+// Resolves `MyHostname()` to an Ip4 address. Caches first successful result, making it
+// cheap to call it over and over.
+// It will also crash whole process if resolving the IP fails!
+func MyIp4() *net.IPAddr {
+	myIp4Once.Do(func() {
+		var err error
+		myIp4, err = net.ResolveIPAddr("ip4", MyHostname())
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
+	return myIp4
+}
+
+var myIp6 *net.IPAddr
+var myIp6Once sync.Once
+
+// Resolves `MyHostname()` to an Ip6 address. Caches first successful result, making it
+// cheap to call it over and over.
+// It will also crash whole process if resolving the IP fails!
+func MyIp6() *net.IPAddr {
+	myIp6Once.Do(func() {
+		var err error
+		myIp6, err = net.ResolveIPAddr("ip6", MyHostname())
+		if err != nil {
+			log.Fatal(err)
+		}
+	})
+	return myIp6
+}
+
+// This returns the list of local ip addresses which other hosts can connect
+// to (NOTE: Loopback ip is ignored).
+// Also resolves Hostname to an address and adds it to the list too, so
+// IPs from /etc/hosts can work too.
+func GetLocalIPs() ([]*net.IP, error) {
+	hostname, err := os.Hostname()
+	if err != nil {
+		return nil, fmt.Errorf("Failed to lookup hostname: %v", err)
+	}
+	// Resolves IP Address from Hostname, this way overrides in /etc/hosts
+	// can work too for IP resolution.
+	ipInfo, err := net.ResolveIPAddr("ip4", hostname)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to resolve ip: %v", err)
+	}
+	ips := []*net.IP{&ipInfo.IP}
+
+	// TODO(zviad): Is rest of the code really necessary?
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return nil, fmt.Errorf( "Failed to get interface addresses: %v", err)
+	}
+	for _, addr := range addrs {
+		ipnet, ok := addr.(*net.IPNet)
+		if !ok {
+			continue
+		}
+
+		if ipnet.IP.IsLoopback() {
+			continue
+		}
+
+		ips = append(ips, &ipnet.IP)
+	}
+	return ips, nil
+}
+
+var localhostIPNets []*net.IPNet
+
+func init() {
+	for _, mask := range []string{"127.0.0.1/8", "::1/128"} {
+		_, ipnet, err := net.ParseCIDR(mask)
+		if err != nil {
+			panic(err)
+		}
+		localhostIPNets = append(localhostIPNets, ipnet)
+	}
+}
+
+func IsLocalhostIp(ipStr string) bool {
+	ip := net.ParseIP(ipStr)
+	if ip == nil {
+		return false
+	}
+	for _, ipnet := range localhostIPNets {
+		if ipnet.Contains(ip) {
+			return true
+		}
+	}
+	return false
+}
+
+// Given a host string, return true if the host is an ip (v4/v6) localhost.
+func IsLocalhost(host string) bool {
+	return IsLocalhostIp(host) ||
+		host == "localhost" ||
+		host == "ip6-localhost" ||
+		host == "ipv6-localhost"
+}
+
+// Resolves hostnames in addresses to actual IP4 addresses. Skips all invalid addresses
+// and all addresses that can't be resolved.
+// `addrs` are assumed to be of form: ["<hostname>:<port>", ...]
+// Returns an error in addition to resolved addresses if not all resolutions succeed.
+func ResolveIP4s(addrs []string) ([]string, error) {
+	resolvedAddrs := make([]string, 0, len(addrs))
+	var lastErr error
+
+	for _, server := range addrs {
+		hostPort := strings.Split(server, ":")
+		if len(hostPort) != 2 {
+			lastErr = fmt.Errorf("Skipping invalid address: %s", server)
+			continue
+		}
+
+		ip, err := net.ResolveIPAddr("ip4", hostPort[0])
+		if err != nil {
+			lastErr = err
+			continue
+		}
+		resolvedAddrs = append(resolvedAddrs, ip.IP.String()+":"+hostPort[1])
+	}
+	return resolvedAddrs, lastErr
+}
+
+func LookupValidAddrs() (map[string]bool, error) {
+	hostName, err := os.Hostname()
+	if err != nil {
+		return nil, err
+	}
+	addrs, err := net.LookupHost(hostName)
+	if err != nil {
+		return nil, err
+	}
+	validAddrs := make(map[string]bool)
+	validAddrs[hostName] = true
+	for _, addr := range addrs {
+		validAddrs[addr] = true
+	}
+	// Special case localhost/127.0.0.1 so that this works on devVMs. It should
+	// have no affect in production.
+	validAddrs["127.0.0.1"] = true
+	validAddrs["localhost"] = true
+	return validAddrs, nil
+}