Feature/get interface ip nonforwardable network adapters handling

ifaddr.go

@@ -141,9 +141,9 @@ func GetPublicIPs() (string, error) {
 	return strings.Join(ips, " "), nil
 }
 
-// GetInterfaceIP returns a string with a single IP address sorted by the size
-// of the network (i.e. IP addresses with a smaller netmask, larger network
-// size, are sorted first).  This function is the `eval` equivalent of:
+// GetInterfaceIP returns a string with a single forwardable IP address sorted
+// by the size of the network (i.e. IP addresses with a smaller netmask, larger
+// network size, are sorted first).  This function is the `eval` equivalent of:
 //
 // ```
 // $ sockaddr eval -r '{{GetAllInterfaces | include "name" <<ARG>> | sort "type,size" | include "flag" "forwardable" | attr "address" }}'
@@ -153,17 +153,54 @@ func GetInterfaceIP(namedIfRE string) (string, error) {
 	if err != nil {
 		return "", err
 	}
+	flags := []string{
+		"forwardable",
+	}
+	return getInterfaceIP(namedIfRE, flags, ifAddrs)
+}
 
-	ifAddrs, _, err = IfByName(namedIfRE, ifAddrs)
+// GetInterfaceIPWithoutInterfaceFlags returns a string with a single IP address sorted
+// by the size of the network (i.e. IP addresses with a smaller netmask, larger
+// network size, are sorted first).  This function is the `eval` equivalent of:
+//
+// ```
+// $ sockaddr eval -r '{{GetAllInterfaces | include "name" <<ARG>> | sort "type,size" | attr "address" }}'
+/// ```
+func GetInterfaceIPWithoutInterfaceFlags(namedIfRE string) (string, error) {
+	ifAddrs, err := GetAllInterfaces()
 	if err != nil {
 		return "", err
 	}
+	return getInterfaceIP(namedIfRE, nil, ifAddrs)
+}
 
-	ifAddrs, _, err = IfByFlag("forwardable", ifAddrs)
+// getInterfaceIP returns a string with a single IP address sorted
+// by the size of the network (i.e. IP addresses with a smaller netmask, larger
+// network size, are sorted first).  This function is the `eval` equivalent of:
+//
+// ```
+// $ sockaddr eval -r '{{GetAllInterfaces | include "name" <<ARG>> | sort "type,size" | <<FLAGS>> | attr "address" }}'
+/// ```
+//
+// where <<FLAGS>> represents a logical AND between all the supplied flags.
+//
+// For example:
+//
+// with flags:=[]string{"forwardable", "broadcast"} => `include "flag" "forwardable" | include "flag" "broadcast"`
+///
+func getInterfaceIP(namedIfRE string, flags []string, ifAddrs IfAddrs) (string, error) {
+	ifAddrs, _, err := IfByName(namedIfRE, ifAddrs)
 	if err != nil {
 		return "", err
 	}
 
+	for _, flag := range flags {
+		ifAddrs, _, err = IfByFlag(flag, ifAddrs)
+		if err != nil {
+			return "", err
+		}
+	}
+
 	ifAddrs, err = SortIfBy("+type,+size", ifAddrs)
 	if err != nil {
 		return "", err

ifaddr_test.go

@@ -118,13 +118,114 @@ func TestGetPublicIPs(t *testing.T) {
 }
 
 func TestGetInterfaceIP(t *testing.T) {
-	ip, err := sockaddr.GetInterfaceIP(`^.*[\d]$`)
-	if err != nil {
-		t.Fatalf("regexp failed: %v", err)
+
+	// setting up a "fake environment" by temporarily controlling what's returned by
+	// `sockaddr.GetAllInterfaces`
+	teardown := overrideOsNetProvider(&fakeNetProvider{})
+	defer teardown()
+
+	type args struct {
+		namedIfRE string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name:    "loopback => empty string",
+			args:    args{namedIfRE: "lo"},
+			want:    "",
+			wantErr: false,
+		},
+		{
+			name:    "private (RFC1918) => 172.16.0.0",
+			args:    args{namedIfRE: "eth0"},
+			want:    "172.16.0.0",
+			wantErr: false,
+		},
+		{
+			name:    "dummy (RFC3927) => empty string",
+			args:    args{namedIfRE: "dummy"},
+			want:    "",
+			wantErr: false,
+		},
+		{
+			name:    "dummyv6 (RFC4291) IPv6 => empty string",
+			args:    args{namedIfRE: "dummyv6"},
+			want:    "",
+			wantErr: false,
+		},
 	}
 
-	if ip == "" {
-		t.Skip("it's hard to test this reliably")
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := sockaddr.GetInterfaceIP(tt.args.namedIfRE)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetInterfaceIP() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("GetInterfaceIP() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGetInterfaceIPWithoutInterfaceFlags(t *testing.T) {
+
+	// setting up a "fake environment" by temporarily controlling what's returned by
+	// `sockaddr.GetAllInterfaces`
+	teardown := overrideOsNetProvider(&fakeNetProvider{})
+	defer teardown()
+
+	type args struct {
+		namedIfRE string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name:    "loopback => 127.0.0.0",
+			args:    args{namedIfRE: "lo"},
+			want:    "127.0.0.0",
+			wantErr: false,
+		},
+		{
+			name:    "private (RFC1918) => 172.16.0.0",
+			args:    args{namedIfRE: "eth0"},
+			want:    "172.16.0.0",
+			wantErr: false,
+		},
+		{
+			name:    "dummy (RFC3927) => 169.254.0.0",
+			args:    args{namedIfRE: "dummy"},
+			want:    "169.254.0.0",
+			wantErr: false,
+		},
+		{
+			name:    "dummyv6 (RFC4291) IPv6 => fe80::",
+			args:    args{namedIfRE: "dummyv6"},
+			want:    "fe80::",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := sockaddr.GetInterfaceIPWithoutInterfaceFlags(tt.args.namedIfRE)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetInterfaceIPWithoutInterfaceFlags() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("GetInterfaceIPWithoutInterfaceFlags() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }
 
@@ -592,3 +693,61 @@ func TestIfAddrMath(t *testing.T) {
 		}
 	}
 }
+
+// overrideOsNetProvider allows overriding the sockaddr.NetProvider
+//
+// It returns a cleanup/teardown func that restores the default OSNetProvider after use
+//
+// Usage:
+// teardown := overrideOsNetProvider(fakeNetProvider{})
+// defer teardown()
+func overrideOsNetProvider(override sockaddr.NetworkInterfacesProvider) func() {
+	sockaddr.NetProvider = override
+	return func() {
+		sockaddr.NetProvider = &sockaddr.OSNetProvider{}
+	}
+}
+
+type fakeNetProvider struct{}
+
+func (n *fakeNetProvider) GetAllInterfaces() (sockaddr.IfAddrs, error) {
+	ifAddrs := sockaddr.IfAddrs{
+		{
+			SockAddr: sockaddr.MustIPv4Addr("127.0.0.0/8"),
+			Interface: net.Interface{
+				Index: 1,
+				MTU:   65536,
+				Name:  "lo",
+				Flags: net.FlagUp | net.FlagLoopback,
+			},
+		},
+		{
+			SockAddr: sockaddr.MustIPv4Addr("172.16.0.0/12"),
+			Interface: net.Interface{
+				Index: 2,
+				MTU:   1500,
+				Name:  "eth0",
+				Flags: net.FlagUp,
+			},
+		},
+		{
+			SockAddr: sockaddr.MustIPv4Addr("169.254.0.0/16"),
+			Interface: net.Interface{
+				Index: 3,
+				MTU:   1500,
+				Name:  "dummy",
+				Flags: net.FlagBroadcast,
+			},
+		},
+		{
+			SockAddr: sockaddr.MustIPv6Addr("fe80::/10"),
+			Interface: net.Interface{
+				Index: 3,
+				MTU:   1500,
+				Name:  "dummyv6",
+				Flags: net.FlagBroadcast,
+			},
+		},
+	}
+	return ifAddrs, nil
+}

ifaddrs.go

@@ -236,38 +236,18 @@ func IfAttrs(selectorName string, ifAddrs IfAddrs) (string, error) {
 	return attrVal, err
 }
 
-// GetAllInterfaces iterates over all available network interfaces and finds all
-// available IP addresses on each interface and converts them to
-// sockaddr.IPAddrs, and returning the result as an array of IfAddr.
-func GetAllInterfaces() (IfAddrs, error) {
-	ifs, err := net.Interfaces()
-	if err != nil {
-		return nil, err
-	}
-
-	ifAddrs := make(IfAddrs, 0, len(ifs))
-	for _, intf := range ifs {
-		addrs, err := intf.Addrs()
-		if err != nil {
-			return nil, err
-		}
-
-		for _, addr := range addrs {
-			var ipAddr IPAddr
-			ipAddr, err = NewIPAddr(addr.String())
-			if err != nil {
-				return IfAddrs{}, fmt.Errorf("unable to create an IP address from %q", addr.String())
-			}
+// NetworkInterfacesProvider abstracts the way we gather network interfaces in order
+// to improve testability
+type NetworkInterfacesProvider interface {
+	GetAllInterfaces() (IfAddrs, error)
+}
 
-			ifAddr := IfAddr{
-				SockAddr:  ipAddr,
-				Interface: intf,
-			}
-			ifAddrs = append(ifAddrs, ifAddr)
-		}
-	}
+// NetProvider implements NetworkInterfacesProvider and is defined here with its default
+var NetProvider NetworkInterfacesProvider = &OSNetProvider{}
 
-	return ifAddrs, nil
+// GetAllInterfaces proxies the call to the NetProvider
+func GetAllInterfaces() (IfAddrs, error) {
+	return NetProvider.GetAllInterfaces()
 }
 
 // GetDefaultInterfaces returns IfAddrs of the addresses attached to the default
@@ -1214,15 +1194,14 @@ func parseDefaultIfNameFromIPCmd(routeOut string) (string, error) {
 // Android.
 func parseDefaultIfNameFromIPCmdAndroid(routeOut string) (string, error) {
 	parsedLines := parseIfNameFromIPCmd(routeOut)
-	if (len(parsedLines) > 0) {
+	if len(parsedLines) > 0 {
 		ifName := strings.TrimSpace(parsedLines[0][4])
 		return ifName, nil
 	}
 
 	return "", errors.New("No default interface found")
 }
 
-
 // parseIfNameFromIPCmd parses interfaces from ip(8) for
 // Linux.
 func parseIfNameFromIPCmd(routeOut string) [][]string {

os_net_provider.go

@@ -0,0 +1,42 @@
+package sockaddr
+
+import (
+	"fmt"
+	"net"
+)
+
+type OSNetProvider struct{}
+
+// GetAllInterfaces iterates over all available network interfaces and finds all
+// available IP addresses on each interface and converts them to
+// sockaddr.IPAddrs, and returning the result as an array of IfAddr.
+func (n *OSNetProvider) GetAllInterfaces() (IfAddrs, error) {
+	ifs, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	ifAddrs := make(IfAddrs, 0, len(ifs))
+	for _, intf := range ifs {
+		addrs, err := intf.Addrs()
+		if err != nil {
+			return nil, err
+		}
+
+		for _, addr := range addrs {
+			var ipAddr IPAddr
+			ipAddr, err = NewIPAddr(addr.String())
+			if err != nil {
+				return IfAddrs{}, fmt.Errorf("unable to create an IP address from %q", addr.String())
+			}
+
+			ifAddr := IfAddr{
+				SockAddr:  ipAddr,
+				Interface: intf,
+			}
+			ifAddrs = append(ifAddrs, ifAddr)
+		}
+	}
+
+	return ifAddrs, nil
+}

template/template.go

@@ -95,6 +95,9 @@ func init() {
 		// the largest network size.
 		"GetInterfaceIP": sockaddr.GetInterfaceIP,
 
+		// Returns the first IP address of the named interfaces, regardless of any interface flag
+		"GetInterfaceIPWithoutInterfaceFlags": sockaddr.GetInterfaceIPWithoutInterfaceFlags,
+
 		// Return all IP addresses on the named interface, sorted by the largest
 		// network size.
 		"GetInterfaceIPs": sockaddr.GetInterfaceIPs,