vendor: bump all direct dependencies

Just good hygiene.

Signed-off-by: Casey Callendrello <cdc@redhat.com>

vendor/github.com/j-keck/arping/arp_datagram.go

@@ -73,7 +73,8 @@ func (datagram arpDatagram) SenderMac() net.HardwareAddr {
 }
 
 func (datagram arpDatagram) IsResponseOf(request arpDatagram) bool {
-	return datagram.oper == responseOper && bytes.Compare(request.spa, datagram.tpa) == 0
+	return datagram.oper == responseOper && bytes.Equal(request.spa, datagram.tpa) &&
+		bytes.Equal(request.tpa, datagram.spa)
 }
 
 func parseArpDatagram(buffer []byte) arpDatagram {

vendor/github.com/j-keck/arping/arping.go

@@ -60,12 +60,12 @@ package arping
 
 import (
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"log"
 	"net"
 	"os"
 	"time"
-	"fmt"
 )
 
 var (
@@ -117,10 +117,11 @@ func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Du
 	broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 	request := newArpRequest(srcMac, srcIP, broadcastMac, dstIP)
 
-	if err := initialize(iface); err != nil {
+	sock, err := initialize(iface)
+	if err != nil {
 		return nil, 0, err
 	}
-	defer deinitialize()
+	defer sock.deinitialize()
 
 	type PingResult struct {
 		mac      net.HardwareAddr
@@ -132,12 +133,12 @@ func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Du
 	go func() {
 		// send arp request
 		verboseLog.Printf("arping '%s' over interface: '%s' with address: '%s'\n", dstIP, iface.Name, srcIP)
-		if sendTime, err := send(request); err != nil {
+		if sendTime, err := sock.send(request); err != nil {
 			pingResultChan <- PingResult{nil, 0, err}
 		} else {
 			for {
 				// receive arp response
-				response, receiveTime, err := receive()
+				response, receiveTime, err := sock.receive()
 
 				if err != nil {
 					pingResultChan <- PingResult{nil, 0, err}
@@ -162,7 +163,7 @@ func PingOverIface(dstIP net.IP, iface net.Interface) (net.HardwareAddr, time.Du
 	case pingResult := <-pingResultChan:
 		return pingResult.mac, pingResult.duration, pingResult.err
 	case <-time.After(timeout):
-		deinitialize()
+		sock.deinitialize()
 		return nil, 0, ErrTimeout
 	}
 }
@@ -203,12 +204,13 @@ func GratuitousArpOverIface(srcIP net.IP, iface net.Interface) error {
 	broadcastMac := []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
 	request := newArpRequest(srcMac, srcIP, broadcastMac, srcIP)
 
-	if err := initialize(iface); err != nil {
+	sock, err := initialize(iface)
+	if err != nil {
 		return err
 	}
-	defer deinitialize()
+	defer sock.deinitialize()
 	verboseLog.Printf("gratuitous arp over interface: '%s' with address: '%s'\n", iface.Name, srcIP)
-	_, err := send(request)
+	_, err = sock.send(request)
 	return err
 }
 

vendor/github.com/j-keck/arping/arping_bsd.go

@@ -12,9 +12,11 @@ import (
 	"time"
 )
 
-var bpf *os.File
-var bpfFd int
-var buflen int
+type BsdSocket struct {
+	bpf    *os.File
+	bpfFd  int
+	buflen int
+}
 
 var bpfArpFilter = []syscall.BpfInsn{
 	// make sure this is an arp packet
@@ -26,11 +28,12 @@ var bpfArpFilter = []syscall.BpfInsn{
 	*syscall.BpfStmt(syscall.BPF_RET+syscall.BPF_K, 0),
 }
 
-func initialize(iface net.Interface) (err error) {
+func initialize(iface net.Interface) (s *BsdSocket, err error) {
+	s = &BsdSocket{}
 	verboseLog.Println("search available /dev/bpfX")
 	for i := 0; i <= 10; i++ {
 		bpfPath := fmt.Sprintf("/dev/bpf%d", i)
-		bpf, err = os.OpenFile(bpfPath, os.O_RDWR, 0666)
+		s.bpf, err = os.OpenFile(bpfPath, os.O_RDWR, 0666)
 		if err != nil {
 			verboseLog.Printf("  open failed: %s - %s\n", bpfPath, err.Error())
 		} else {
@@ -38,43 +41,43 @@ func initialize(iface net.Interface) (err error) {
 			break
 		}
 	}
-	bpfFd = int(bpf.Fd())
-	if bpfFd == -1 {
-		return errors.New("unable to open /dev/bpfX")
+	s.bpfFd = int(s.bpf.Fd())
+	if s.bpfFd == -1 {
+		return s, errors.New("unable to open /dev/bpfX")
 	}
 
-	if err := syscall.SetBpfInterface(bpfFd, iface.Name); err != nil {
-		return err
+	if err := syscall.SetBpfInterface(s.bpfFd, iface.Name); err != nil {
+		return s, err
 	}
 
-	if err := syscall.SetBpfImmediate(bpfFd, 1); err != nil {
-		return err
+	if err := syscall.SetBpfImmediate(s.bpfFd, 1); err != nil {
+		return s, err
 	}
 
-	buflen, err = syscall.BpfBuflen(bpfFd)
+	s.buflen, err = syscall.BpfBuflen(s.bpfFd)
 	if err != nil {
-		return err
+		return s, err
 	}
 
-	if err := syscall.SetBpf(bpfFd, bpfArpFilter); err != nil {
-		return err
+	if err := syscall.SetBpf(s.bpfFd, bpfArpFilter); err != nil {
+		return s, err
 	}
 
-	if err := syscall.FlushBpf(bpfFd); err != nil {
-		return err
+	if err := syscall.FlushBpf(s.bpfFd); err != nil {
+		return s, err
 	}
 
-	return nil
+	return s, nil
 }
 
-func send(request arpDatagram) (time.Time, error) {
-	_, err := syscall.Write(bpfFd, request.MarshalWithEthernetHeader())
+func (s *BsdSocket) send(request arpDatagram) (time.Time, error) {
+	_, err := syscall.Write(s.bpfFd, request.MarshalWithEthernetHeader())
 	return time.Now(), err
 }
 
-func receive() (arpDatagram, time.Time, error) {
-	buffer := make([]byte, buflen)
-	n, err := syscall.Read(bpfFd, buffer)
+func (s *BsdSocket) receive() (arpDatagram, time.Time, error) {
+	buffer := make([]byte, s.buflen)
+	n, err := syscall.Read(s.bpfFd, buffer)
 	if err != nil {
 		return arpDatagram{}, time.Now(), err
 	}
@@ -96,6 +99,6 @@ func receive() (arpDatagram, time.Time, error) {
 	return parseArpDatagram(buffer[hdrLength:n]), time.Now(), nil
 }
 
-func deinitialize() error {
-	return bpf.Close()
+func (s *BsdSocket) deinitialize() error {
+	return s.bpf.Close()
 }

vendor/github.com/j-keck/arping/arping_linux.go

@@ -6,26 +6,31 @@ import (
 	"time"
 )
 
-var sock int
-var toSockaddr syscall.SockaddrLinklayer
+type LinuxSocket struct {
+	sock       int
+	toSockaddr syscall.SockaddrLinklayer
+}
 
-func initialize(iface net.Interface) error {
-	toSockaddr = syscall.SockaddrLinklayer{Ifindex: iface.Index}
+func initialize(iface net.Interface) (s *LinuxSocket, err error) {
+	s = &LinuxSocket{}
+	s.toSockaddr = syscall.SockaddrLinklayer{Ifindex: iface.Index}
 
 	// 1544 = htons(ETH_P_ARP)
 	const proto = 1544
-	var err error
-	sock, err = syscall.Socket(syscall.AF_PACKET, syscall.SOCK_RAW, proto)
-	return err
+	s.sock, err = syscall.Socket(syscall.AF_PACKET, syscall.SOCK_RAW, proto)
+	return s, err
 }
 
-func send(request arpDatagram) (time.Time, error) {
-	return time.Now(), syscall.Sendto(sock, request.MarshalWithEthernetHeader(), 0, &toSockaddr)
+func (s *LinuxSocket) send(request arpDatagram) (time.Time, error) {
+	return time.Now(), syscall.Sendto(s.sock, request.MarshalWithEthernetHeader(), 0, &s.toSockaddr)
 }
 
-func receive() (arpDatagram, time.Time, error) {
+func (s *LinuxSocket) receive() (arpDatagram, time.Time, error) {
 	buffer := make([]byte, 128)
-	n, _, err := syscall.Recvfrom(sock, buffer, 0)
+	socketTimeout := timeout.Nanoseconds() * 2
+	t := syscall.NsecToTimeval(socketTimeout)
+	syscall.SetsockoptTimeval(s.sock, syscall.SOL_SOCKET, syscall.SO_RCVTIMEO, &t)
+	n, _, err := syscall.Recvfrom(s.sock, buffer, 0)
 	if err != nil {
 		return arpDatagram{}, time.Now(), err
 	}
@@ -33,6 +38,6 @@ func receive() (arpDatagram, time.Time, error) {
 	return parseArpDatagram(buffer[14:n]), time.Now(), nil
 }
 
-func deinitialize() error {
-	return syscall.Close(sock)
+func (s *LinuxSocket) deinitialize() error {
+	return syscall.Close(s.sock)
 }