Cleanup most of the remaining nits (#578)

overlay/tun_ios.go

@@ -15,36 +15,35 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-type Tun struct {
+type tun struct {
 	io.ReadWriteCloser
 	Device string
 	Cidr   *net.IPNet
 }
 
-func newTun(l *logrus.Logger, deviceName string, cidr *net.IPNet, defaultMTU int, routes []Route, unsafeRoutes []Route, txQueueLen int, multiqueue bool) (ifce *Tun, err error) {
+func newTun(_ *logrus.Logger, _ string, _ *net.IPNet, _ int, _ []Route, _ []Route, _ int, _ bool) (*tun, error) {
 	return nil, fmt.Errorf("newTun not supported in iOS")
 }
 
-func newTunFromFd(l *logrus.Logger, deviceFd int, cidr *net.IPNet, defaultMTU int, routes []Route, unsafeRoutes []Route, txQueueLen int) (ifce *Tun, err error) {
+func newTunFromFd(_ *logrus.Logger, deviceFd int, cidr *net.IPNet, _ int, routes []Route, _ []Route, _ int) (*tun, error) {
 	if len(routes) > 0 {
 		return nil, fmt.Errorf("route MTU not supported in Darwin")
 	}
 
 	file := os.NewFile(uintptr(deviceFd), "/dev/tun")
-	ifce = &Tun{
+	return &tun{
 		Cidr:            cidr,
 		Device:          "iOS",
 		ReadWriteCloser: &tunReadCloser{f: file},
-	}
-	return
+	}, nil
 }
 
-func (c *Tun) Activate() error {
+func (t *tun) Activate() error {
 	return nil
 }
 
-func (c *Tun) WriteRaw(b []byte) error {
-	_, err := c.Write(b)
+func (t *tun) WriteRaw(b []byte) error {
+	_, err := t.Write(b)
 	return err
 }
 
@@ -59,62 +58,62 @@ type tunReadCloser struct {
 	wBuf []byte
 }
 
-func (t *tunReadCloser) Read(to []byte) (int, error) {
-	t.rMu.Lock()
-	defer t.rMu.Unlock()
+func (tr *tunReadCloser) Read(to []byte) (int, error) {
+	tr.rMu.Lock()
+	defer tr.rMu.Unlock()
 
-	if cap(t.rBuf) < len(to)+4 {
-		t.rBuf = make([]byte, len(to)+4)
+	if cap(tr.rBuf) < len(to)+4 {
+		tr.rBuf = make([]byte, len(to)+4)
 	}
-	t.rBuf = t.rBuf[:len(to)+4]
+	tr.rBuf = tr.rBuf[:len(to)+4]
 
-	n, err := t.f.Read(t.rBuf)
-	copy(to, t.rBuf[4:])
+	n, err := tr.f.Read(tr.rBuf)
+	copy(to, tr.rBuf[4:])
 	return n - 4, err
 }
 
-func (t *tunReadCloser) Write(from []byte) (int, error) {
+func (tr *tunReadCloser) Write(from []byte) (int, error) {
 
 	if len(from) == 0 {
 		return 0, syscall.EIO
 	}
 
-	t.wMu.Lock()
-	defer t.wMu.Unlock()
+	tr.wMu.Lock()
+	defer tr.wMu.Unlock()
 
-	if cap(t.wBuf) < len(from)+4 {
-		t.wBuf = make([]byte, len(from)+4)
+	if cap(tr.wBuf) < len(from)+4 {
+		tr.wBuf = make([]byte, len(from)+4)
 	}
-	t.wBuf = t.wBuf[:len(from)+4]
+	tr.wBuf = tr.wBuf[:len(from)+4]
 
 	// Determine the IP Family for the NULL L2 Header
 	ipVer := from[0] >> 4
 	if ipVer == 4 {
-		t.wBuf[3] = syscall.AF_INET
+		tr.wBuf[3] = syscall.AF_INET
 	} else if ipVer == 6 {
-		t.wBuf[3] = syscall.AF_INET6
+		tr.wBuf[3] = syscall.AF_INET6
 	} else {
 		return 0, errors.New("unable to determine IP version from packet")
 	}
 
-	copy(t.wBuf[4:], from)
+	copy(tr.wBuf[4:], from)
 
-	n, err := t.f.Write(t.wBuf)
+	n, err := tr.f.Write(tr.wBuf)
 	return n - 4, err
 }
 
-func (t *tunReadCloser) Close() error {
-	return t.f.Close()
+func (tr *tunReadCloser) Close() error {
+	return tr.f.Close()
 }
 
-func (c *Tun) CidrNet() *net.IPNet {
-	return c.Cidr
+func (t *tun) CidrNet() *net.IPNet {
+	return t.Cidr
 }
 
-func (c *Tun) DeviceName() string {
-	return c.Device
+func (t *tun) DeviceName() string {
+	return t.Device
 }
 
-func (t *Tun) NewMultiQueueReader() (io.ReadWriteCloser, error) {
+func (t *tun) NewMultiQueueReader() (io.ReadWriteCloser, error) {
 	return nil, fmt.Errorf("TODO: multiqueue not implemented for ios")
 }