Cleaned up in response to reviewer comments

inetdiag/inetdiag_test.go

@@ -2,7 +2,11 @@ package inetdiag_test
 
 import (
 	"encoding/json"
+	"io/ioutil"
 	"log"
+	"net"
+	"os"
+	"sync"
 	"syscall"
 	"testing"
 	"unsafe"
@@ -213,20 +217,52 @@ func TestParseGarbage(t *testing.T) {
 }
 
 func TestOneType(t *testing.T) {
-	res4, err := inetdiag.OneType(syscall.AF_INET)
+	// Open an AF_LOCAL socket connection.
+	// Get a safe name for the AF_LOCAL socket
+	f, err := ioutil.TempFile("", "TestOneType")
 	if err != nil {
 		t.Error(err)
 	}
-	res6, err := inetdiag.OneType(syscall.AF_INET6)
+	name := f.Name()
+	os.Remove(name)
+
+	// Open a listening UNIX socket at that mostly-safe name.
+	l, err := net.Listen("unix", name)
 	if err != nil {
 		t.Error(err)
 	}
-	resUnix, err := inetdiag.OneType(syscall.AF_UNIX)
+	defer l.Close()
+
+	// Unblock all goroutines when the function exits.
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	defer wg.Done()
+
+	// Start a client connection in a goroutine.
+	go func() {
+		c, err := net.Dial("unix", name)
+		if err != nil {
+			t.Error(err)
+		}
+		c.Write([]byte("hi"))
+		wg.Wait()
+		c.Close()
+	}()
+
+	// Accept the client connection.
+	fd, err := l.Accept()
+	if err != nil {
+		t.Error(err)
+	}
+	defer fd.Close()
+
+	// Verify that OneType(AF_LOCAL) finds at least one connection.
+	res, err := inetdiag.OneType(syscall.AF_LOCAL)
 	if err != nil {
 		t.Error(err)
 	}
-	if len(res4) == 0 && len(res6) == 0 && len(resUnix) == 0 {
-		t.Error("There are never no active streams.")
+	if len(res) == 0 {
+		t.Error("We have at least one active stream open right now.")
 	}
 }
 

inetdiag/socket-monitor.go

@@ -25,8 +25,11 @@ import (
 const TCPF_ALL = 0xFFF
 
 var (
-	errBadPid      = errors.New("Bad PID. Can't listen to NL socket.")
-	errBadSequence = errors.New("Bad sequence number. Can't interpret NetLink response.")
+	// ErrBadPid is used when the PID is mismatched between the netlink socket and the calling process.
+	ErrBadPid = errors.New("bad PID, can't listen to NL socket")
+
+	// ErrBadSequence is used when the Netlink response has a bad sequence number.
+	ErrBadSequence = errors.New("bad sequence number, can't interpret NetLink response")
 )
 
 func makeReq(inetType uint8) *nl.NetlinkRequest {
@@ -56,12 +59,12 @@ func processSingleMessage(m *syscall.NetlinkMessage, seq uint32, pid uint32) (*s
 	if m.Header.Seq != seq {
 		log.Printf("Wrong Seq nr %d, expected %d", m.Header.Seq, seq)
 		metrics.ErrorCount.With(prometheus.Labels{"source": "wrong seq num"}).Inc()
-		return nil, false, errBadSequence
+		return nil, false, ErrBadSequence
 	}
 	if m.Header.Pid != pid {
 		log.Printf("Wrong pid %d, expected %d", m.Header.Pid, pid)
 		metrics.ErrorCount.With(prometheus.Labels{"source": "wrong pid"}).Inc()
-		return nil, false, errBadPid
+		return nil, false, ErrBadPid
 	}
 	if m.Header.Type == unix.NLMSG_DONE {
 		return nil, false, nil
@@ -131,12 +134,12 @@ func OneType(inetType uint8) ([]*syscall.NetlinkMessage, error) {
 		// TODO avoid the copy.
 		for i := range msgs {
 			m, shouldContinue, err := processSingleMessage(&msgs[i], req.Seq, pid)
-			if m != nil {
-				res = append(res, m)
-			}
 			if err != nil {
 				return res, err
 			}
+			if m != nil {
+				res = append(res, m)
+			}
 			if !shouldContinue {
 				return res, nil
 			}