Expose socket ReadBuffer & WriteBuffer functions (#223)

Author: nickgarlis

conn.go

@@ -434,17 +434,20 @@ func (c *Conn) SetOption(option ConnOption, enable bool) error {
 	return newOpError("set-option", conn.SetOption(option, enable))
 }
 
-// A bufferSetter is a Socket that supports setting connection buffer sizes.
-type bufferSetter interface {
+// A bufferedSocket is a Socket that supports getting & setting connection
+// buffer sizes.
+type bufferedSocket interface {
 	Socket
 	SetReadBuffer(bytes int) error
 	SetWriteBuffer(bytes int) error
+	ReadBuffer() (int, error)
+	WriteBuffer() (int, error)
 }
 
 // SetReadBuffer sets the size of the operating system's receive buffer
 // associated with the Conn.
 func (c *Conn) SetReadBuffer(bytes int) error {
-	conn, ok := c.sock.(bufferSetter)
+	conn, ok := c.sock.(bufferedSocket)
 	if !ok {
 		return notSupported("set-read-buffer")
 	}
@@ -455,14 +458,45 @@ func (c *Conn) SetReadBuffer(bytes int) error {
 // SetWriteBuffer sets the size of the operating system's transmit buffer
 // associated with the Conn.
 func (c *Conn) SetWriteBuffer(bytes int) error {
-	conn, ok := c.sock.(bufferSetter)
+	conn, ok := c.sock.(bufferedSocket)
 	if !ok {
 		return notSupported("set-write-buffer")
 	}
 
 	return newOpError("set-write-buffer", conn.SetWriteBuffer(bytes))
 }
 
+// ReadBuffer reads the size of the operating system's receive buffer
+// associated with the Conn.
+func (c *Conn) ReadBuffer() (int, error) {
+	conn, ok := c.sock.(bufferedSocket)
+	if !ok {
+		return 0, notSupported("get-read-buffer")
+	}
+
+	buff, err := conn.ReadBuffer()
+	if err != nil {
+		return 0, newOpError("get-read-buffer", err)
+	}
+	return buff, nil
+}
+
+// WriteBuffer reads the size of the operating system's transmit buffer
+// associated with the Conn.
+func (c *Conn) WriteBuffer() (int, error) {
+	conn, ok := c.sock.(bufferedSocket)
+	if !ok {
+		return 0, notSupported("get-write-buffer")
+	}
+
+	buff, err := conn.WriteBuffer()
+	if err != nil {
+		return 0, newOpError("get-write-buffer", err)
+	}
+
+	return buff, nil
+}
+
 // A syscallConner is a Socket that supports syscall.Conn.
 type syscallConner interface {
 	Socket

conn_linux.go

@@ -212,6 +212,14 @@ func (c *conn) SetReadBuffer(bytes int) error { return c.s.SetReadBuffer(bytes)
 // associated with the Conn.
 func (c *conn) SetWriteBuffer(bytes int) error { return c.s.SetWriteBuffer(bytes) }
 
+// ReadBuffer reads the size of the operating system's receive buffer
+// associated with the Conn.
+func (c *conn) ReadBuffer() (int, error) { return c.s.ReadBuffer() }
+
+// WriteBuffer reads the size of the operating system's transmit buffer
+// associated with the Conn.
+func (c *conn) WriteBuffer() (int, error) { return c.s.WriteBuffer() }
+
 // SyscallConn returns a raw network connection.
 func (c *conn) SyscallConn() (syscall.RawConn, error) { return c.s.SyscallConn() }
 

conn_linux_integration_test.go

@@ -425,6 +425,58 @@ func TestIntegrationConnSetBuffersSyscallConn(t *testing.T) {
 	}
 }
 
+func TestIntegrationConnBuffersSyscallConn(t *testing.T) {
+	c, err := netlink.Dial(unix.NETLINK_GENERIC, nil)
+	if err != nil {
+		t.Fatalf("failed to dial netlink: %v", err)
+	}
+	defer c.Close()
+
+	rcvBuff, err := c.ReadBuffer()
+	if err != nil {
+		t.Fatalf("failed to get read buffer size: %v", err)
+	}
+
+	sndBuff, err := c.WriteBuffer()
+	if err != nil {
+		t.Fatalf("failed to get write buffer size: %v", err)
+	}
+
+	// Now that we've read the buffers, we can check the size by asking the
+	// kernel using SyscallConn and getsockopt.
+
+	rc, err := c.SyscallConn()
+	if err != nil {
+		t.Fatalf("failed to get syscall conn: %v", err)
+	}
+
+	mustSize := func(opt int) int {
+		var (
+			value int
+			serr  error
+		)
+
+		err := rc.Control(func(fd uintptr) {
+			value, serr = unix.GetsockoptInt(int(fd), unix.SOL_SOCKET, opt)
+		})
+		if err != nil {
+			t.Fatalf("failed to call control: %v", err)
+		}
+		if serr != nil {
+			t.Fatalf("failed to call getsockopt: %v", serr)
+		}
+
+		return value
+	}
+
+	if diff := cmp.Diff(rcvBuff, mustSize(unix.SO_RCVBUF)); diff != "" {
+		t.Fatalf("unexpected read buffer size (-want +got):\n%s", diff)
+	}
+	if diff := cmp.Diff(sndBuff, mustSize(unix.SO_SNDBUF)); diff != "" {
+		t.Fatalf("unexpected write buffer size (-want +got):\n%s", diff)
+	}
+}
+
 func TestIntegrationConnSetBPFEmpty(t *testing.T) {
 	c, err := netlink.Dial(unix.NETLINK_GENERIC, nil)
 	if err != nil {

conn_test.go

@@ -261,6 +261,23 @@ func TestConnSetBuffersUnsupported(t *testing.T) {
 	}
 }
 
+func TestConnBuffersUnsupported(t *testing.T) {
+	c := nltest.Dial(nil)
+	defer c.Close()
+
+	ops := []func() (int, error){
+		c.ReadBuffer,
+		c.WriteBuffer,
+	}
+
+	for _, op := range ops {
+		_, err := op()
+		if !strings.Contains(err.Error(), "not supported") {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	}
+}
+
 func TestConnSyscallConnUnsupported(t *testing.T) {
 	c := nltest.Dial(nil)
 	defer c.Close()