specify the source IP address

Author: Zack Liu

arping.go

@@ -72,6 +72,9 @@ var (
 	// ErrTimeout error
 	ErrTimeout = errors.New("timeout")
 
+	// ErrNoUsableInterface no usable interface found
+	ErrNoUsableInterface = errors.New("no usable interface found")
+
 	verboseLog = log.New(ioutil.Discard, "", 0)
 	timeout    = time.Duration(500 * time.Millisecond)
 )
@@ -91,27 +94,45 @@ func Ping(dstIP net.IP) (net.HardwareAddr, time.Duration, error) {
 
 // PingOverIfaceByName sends an arp ping over interface name 'ifaceName' to 'dstIP'
 func PingOverIfaceByName(dstIP net.IP, ifaceName string) (net.HardwareAddr, time.Duration, error) {
-	if err := validateIP(dstIP); err != nil {
-		return nil, 0, err
-	}
-
-	iface, err := net.InterfaceByName(ifaceName)
-	if err != nil {
-		return nil, 0, err
-	}
-	return PingOverIface(dstIP, *iface)
+	return PingWithOptions(dstIP, WithIfaceByName(ifaceName))
 }
 
 // PingOverIface sends an arp ping over interface 'iface' to 'dstIP'
 func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Duration, error) {
+	return PingWithOptions(dstIP, WithIface(iface))
+}
+
+// PingWithOptions sends an arp ping to 'dstIP'
+func PingWithOptions(dstIP net.IP, options ...Option) (net.HardwareAddr, time.Duration, error) {
 	if err := validateIP(dstIP); err != nil {
 		return nil, 0, err
 	}
 
+	var op = new(Op)
+	for _, f := range options {
+		if err := f(op); err != nil {
+			return nil, 0, err
+		}
+	}
+
+	if op.timeout == 0 {
+		op.timeout = timeout
+	}
+
+	if op.iface == nil {
+		return nil, 0, ErrNoUsableInterface
+	}
+	iface := *op.iface
+	srcIP := op.srcIP
+
 	srcMac := iface.HardwareAddr
-	srcIP, err := findIPInNetworkFromIface(dstIP, iface)
-	if err != nil {
-		return nil, 0, err
+
+	if len(srcIP) == 0 {
+		ip, err := findIPInNetworkFromIface(dstIP, iface)
+		if err != nil {
+			return nil, 0, err
+		}
+		srcIP = ip
 	}
 
 	broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
@@ -162,44 +183,50 @@ func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Du
 	select {
 	case pingResult := <-pingResultChan:
 		return pingResult.mac, pingResult.duration, pingResult.err
-	case <-time.After(timeout):
+	case <-time.After(op.timeout):
 		sock.deinitialize()
 		return nil, 0, ErrTimeout
 	}
 }
 
 // GratuitousArp sends an gratuitous arp from 'srcIP'
 func GratuitousArp(srcIP net.IP) error {
-	if err := validateIP(srcIP); err != nil {
-		return err
-	}
-
-	iface, err := findUsableInterfaceForNetwork(srcIP)
-	if err != nil {
-		return err
-	}
-	return GratuitousArpOverIface(srcIP, *iface)
+	return GratuitousArpWithOptions(WithSourceIP(srcIP))
 }
 
 // GratuitousArpOverIfaceByName sends an gratuitous arp over interface name 'ifaceName' from 'srcIP'
 func GratuitousArpOverIfaceByName(srcIP net.IP, ifaceName string) error {
-	if err := validateIP(srcIP); err != nil {
-		return err
-	}
-
-	iface, err := net.InterfaceByName(ifaceName)
-	if err != nil {
-		return err
-	}
-	return GratuitousArpOverIface(srcIP, *iface)
+	return GratuitousArpWithOptions(WithSourceIP(srcIP), WithIfaceByName(ifaceName))
 }
 
 // GratuitousArpOverIface sends an gratuitous arp over interface 'iface' from 'srcIP'
 func GratuitousArpOverIface(srcIP net.IP, iface net.Interface) error {
+	return GratuitousArpWithOptions(WithSourceIP(srcIP), WithIface(iface))
+}
+
+// GratuitousArpWithOptions sends an gratuitous arp
+func GratuitousArpWithOptions(options ...Option) error {
+	var op = new(Op)
+	for _, f := range options {
+		if err := f(op); err != nil {
+			return err
+		}
+	}
+
+	srcIP := op.srcIP
 	if err := validateIP(srcIP); err != nil {
 		return err
 	}
 
+	if op.iface == nil {
+		iface, err := findUsableInterfaceForNetwork(srcIP)
+		if err != nil {
+			return err
+		}
+		op.iface = iface
+	}
+	iface := *op.iface
+
 	srcMac := iface.HardwareAddr
 	broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 	request := newArpRequest(srcMac, srcIP, broadcastMac, srcIP)

netutils.go

@@ -1,7 +1,6 @@
 package arping
 
 import (
-	"errors"
 	"fmt"
 	"net"
 )
@@ -60,5 +59,5 @@ func findUsableInterfaceForNetwork(dstIP net.IP) (*net.Interface, error) {
 		logIfaceResult("USABLE", iface)
 		return &iface, nil
 	}
-	return nil, errors.New("no usable interface found")
+	return nil, ErrNoUsableInterface
 }

option.go

@@ -0,0 +1,52 @@
+package arping
+
+import (
+	"net"
+	"time"
+)
+
+type Op struct {
+	iface   *net.Interface
+	timeout time.Duration
+	srcIP   net.IP
+}
+
+type Option func(op *Op) error
+
+// WithIfaceByName sends an arp ping over interface name 'ifaceName'
+func WithIfaceByName(ifaceName string) Option {
+	return func(op *Op) error {
+		iface, err := net.InterfaceByName(ifaceName)
+		if err != nil {
+			return err
+		}
+
+		op.iface = iface
+		return nil
+	}
+}
+
+// WithIface sends an arp ping over interface 'iface'
+func WithIface(iface net.Interface) Option {
+	return func(op *Op) error {
+		op.iface = &iface
+		return nil
+	}
+}
+
+// WithSourceIP sends an arp with source ip address
+func WithSourceIP(srcIP net.IP) Option {
+	return func(op *Op) error {
+		op.srcIP = srcIP
+		return nil
+	}
+}
+
+// WithTimeout sets ping timeout
+// not works with GratuitousArpWithOptions
+func WithTimeout(timeout time.Duration) Option {
+	return func(op *Op) error {
+		op.timeout = timeout
+		return nil
+	}
+}