diff --git a/agent.go b/agent.go
index 5ce3802..5881021 100644
--- a/agent.go
+++ b/agent.go
@@ -100,7 +100,7 @@ type Agent struct {
 	urls         []*URL
 	networkTypes []NetworkType
 
-	buffer *packetio.Buffer
+	buf *packetio.Buffer
 
 	// LRU of outbound Binding request Transaction IDs
 	pendingBindingRequests []bindingRequest
@@ -205,7 +205,7 @@ func (a *Agent) taskLoop() {
 		a.deleteAllCandidates()
 		a.startedFn()
 
-		if err := a.buffer.Close(); err != nil {
+		if err := a.buf.Close(); err != nil {
 			a.log.Warnf("failed to close buffer: %v", err)
 		}
 
@@ -292,7 +292,7 @@ func NewAgent(config *AgentConfig) (*Agent, error) { //nolint:gocognit
 		urls:              config.Urls,
 		networkTypes:      config.NetworkTypes,
 		onConnected:       make(chan struct{}),
-		buffer:            packetio.NewBuffer(),
+		buf:               packetio.NewBuffer(),
 		done:              make(chan struct{}),
 		taskLoopDone:      make(chan struct{}),
 		startedCh:         startedCtx.Done(),
@@ -340,7 +340,7 @@ func NewAgent(config *AgentConfig) (*Agent, error) { //nolint:gocognit
 	// Make sure the buffer doesn't grow indefinitely.
 	// NOTE: We actually won't get anywhere close to this limit.
 	// SRTP will constantly read from the endpoint and drop packets if it's full.
-	a.buffer.SetLimitSize(maxBufferSize)
+	a.buf.SetLimitSize(maxBufferSize)
 
 	if a.lite && (len(a.candidateTypes) != 1 || a.candidateTypes[0] != CandidateTypeHost) {
 		closeMDNSConn()
diff --git a/agent_udpmux_test.go b/agent_udpmux_test.go
index 660984c..7572c8b 100644
--- a/agent_udpmux_test.go
+++ b/agent_udpmux_test.go
@@ -66,18 +66,18 @@ func TestMuxAgent(t *testing.T) {
 			_, err = conn.Write(data)
 			require.NoError(t, err)
 
-			buffer := make([]byte, 1024)
-			n, err := muxedConn.Read(buffer)
+			buf := make([]byte, 1024)
+			n, err := muxedConn.Read(buf)
 			require.NoError(t, err)
-			require.Equal(t, data, buffer[:n])
+			require.Equal(t, data, buf[:n])
 
 			// send a packet from Mux
 			_, err = muxedConn.Write(data)
 			require.NoError(t, err)
 
-			n, err = conn.Read(buffer)
+			n, err = conn.Read(buf)
 			require.NoError(t, err)
-			require.Equal(t, data, buffer[:n])
+			require.Equal(t, data, buf[:n])
 
 			// close it down
 			require.NoError(t, conn.Close())
diff --git a/candidate_base.go b/candidate_base.go
index 31b4cfd..286e836 100644
--- a/candidate_base.go
+++ b/candidate_base.go
@@ -258,7 +258,7 @@ func (c *candidateBase) handleInboundPacket(buf []byte, srcAddr net.Addr) {
 	}
 
 	// Note: This will return packetio.ErrFull if the buffer ever manages to fill up.
-	if _, err := a.buffer.Write(buf); err != nil {
+	if _, err := a.buf.Write(buf); err != nil {
 		a.log.Warnf("Failed to write packet: %s", err)
 		return
 	}
diff --git a/tcp_mux.go b/tcp_mux.go
index 100da53..779ee45 100644
--- a/tcp_mux.go
+++ b/tcp_mux.go
@@ -403,11 +403,11 @@ func readStreamingPacket(conn net.Conn, buf []byte) (int, error) {
 }
 
 func writeStreamingPacket(conn net.Conn, buf []byte) (int, error) {
-	bufferCopy := make([]byte, streamingPacketHeaderLen+len(buf))
-	binary.BigEndian.PutUint16(bufferCopy, uint16(len(buf)))
-	copy(bufferCopy[2:], buf)
+	bufCopy := make([]byte, streamingPacketHeaderLen+len(buf))
+	binary.BigEndian.PutUint16(bufCopy, uint16(len(buf)))
+	copy(bufCopy[2:], buf)
 
-	n, err := conn.Write(bufferCopy)
+	n, err := conn.Write(bufCopy)
 	if err != nil {
 		return 0, err
 	}
diff --git a/tcp_packet_conn.go b/tcp_packet_conn.go
index fe9fe2a..30aed5b 100644
--- a/tcp_packet_conn.go
+++ b/tcp_packet_conn.go
@@ -15,20 +15,20 @@ import (
 
 type bufferedConn struct {
 	net.Conn
-	buffer *packetio.Buffer
+	buf    *packetio.Buffer
 	logger logging.LeveledLogger
 	closed int32
 }
 
-func newBufferedConn(conn net.Conn, bufferSize int, logger logging.LeveledLogger) net.Conn {
-	buffer := packetio.NewBuffer()
-	if bufferSize > 0 {
-		buffer.SetLimitSize(bufferSize)
+func newBufferedConn(conn net.Conn, bufSize int, logger logging.LeveledLogger) net.Conn {
+	buf := packetio.NewBuffer()
+	if bufSize > 0 {
+		buf.SetLimitSize(bufSize)
 	}
 
 	bc := &bufferedConn{
 		Conn:   conn,
-		buffer: buffer,
+		buf:    buf,
 		logger: logger,
 	}
 
@@ -37,7 +37,7 @@ func newBufferedConn(conn net.Conn, bufferSize int, logger logging.LeveledLogger
 }
 
 func (bc *bufferedConn) Write(b []byte) (int, error) {
-	n, err := bc.buffer.Write(b)
+	n, err := bc.buf.Write(b)
 	if err != nil {
 		return n, err
 	}
@@ -47,7 +47,7 @@ func (bc *bufferedConn) Write(b []byte) (int, error) {
 func (bc *bufferedConn) writeProcess() {
 	pktBuf := make([]byte, receiveMTU)
 	for atomic.LoadInt32(&bc.closed) == 0 {
-		n, err := bc.buffer.Read(pktBuf)
+		n, err := bc.buf.Read(pktBuf)
 		if errors.Is(err, io.EOF) {
 			return
 		}
@@ -66,7 +66,7 @@ func (bc *bufferedConn) writeProcess() {
 
 func (bc *bufferedConn) Close() error {
 	atomic.StoreInt32(&bc.closed, 1)
-	_ = bc.buffer.Close()
+	_ = bc.buf.Close()
 	return bc.Conn.Close()
 }
 
diff --git a/transport.go b/transport.go
index 08b1b6f..2e52656 100644
--- a/transport.go
+++ b/transport.go
@@ -70,7 +70,7 @@ func (c *Conn) Read(p []byte) (int, error) {
 		return 0, err
 	}
 
-	n, err := c.agent.buffer.Read(p)
+	n, err := c.agent.buf.Read(p)
 	atomic.AddUint64(&c.bytesReceived, uint64(n))
 	return n, err
 }
diff --git a/udp_mux.go b/udp_mux.go
index 5ad80fc..9cbd285 100644
--- a/udp_mux.go
+++ b/udp_mux.go
@@ -338,11 +338,11 @@ func (m *UDPMuxDefault) getConn(ufrag string, isIPv6 bool) (val *udpMuxedConn, o
 }
 
 type bufferHolder struct {
-	buffer []byte
+	buf []byte
 }
 
 func newBufferHolder(size int) *bufferHolder {
 	return &bufferHolder{
-		buffer: make([]byte, size),
+		buf: make([]byte, size),
 	}
 }
diff --git a/udp_muxed_conn.go b/udp_muxed_conn.go
index 11f5d35..ac7b704 100644
--- a/udp_muxed_conn.go
+++ b/udp_muxed_conn.go
@@ -26,7 +26,7 @@ type udpMuxedConn struct {
 	addresses []string
 
 	// channel holding incoming packets
-	buffer     *packetio.Buffer
+	buf        *packetio.Buffer
 	closedChan chan struct{}
 	closeOnce  sync.Once
 	mu         sync.Mutex
@@ -35,7 +35,7 @@ type udpMuxedConn struct {
 func newUDPMuxedConn(params *udpMuxedConnParams) *udpMuxedConn {
 	p := &udpMuxedConn{
 		params:     params,
-		buffer:     packetio.NewBuffer(),
+		buf:        packetio.NewBuffer(),
 		closedChan: make(chan struct{}),
 	}
 
@@ -47,26 +47,26 @@ func (c *udpMuxedConn) ReadFrom(b []byte) (n int, rAddr net.Addr, err error) {
 	defer c.params.AddrPool.Put(buf)
 
 	// read address
-	total, err := c.buffer.Read(buf.buffer)
+	total, err := c.buf.Read(buf.buf)
 	if err != nil {
 		return 0, nil, err
 	}
 
-	dataLen := int(binary.LittleEndian.Uint16(buf.buffer[:2]))
+	dataLen := int(binary.LittleEndian.Uint16(buf.buf[:2]))
 	if dataLen > total || dataLen > len(b) {
 		return 0, nil, io.ErrShortBuffer
 	}
 
 	// read data and then address
 	offset := 2
-	copy(b, buf.buffer[offset:offset+dataLen])
+	copy(b, buf.buf[offset:offset+dataLen])
 	offset += dataLen
 
 	// read address len & decode address
-	addrLen := int(binary.LittleEndian.Uint16(buf.buffer[offset : offset+2]))
+	addrLen := int(binary.LittleEndian.Uint16(buf.buf[offset : offset+2]))
 	offset += 2
 
-	if rAddr, err = decodeUDPAddr(buf.buffer[offset : offset+addrLen]); err != nil {
+	if rAddr, err = decodeUDPAddr(buf.buf[offset : offset+addrLen]); err != nil {
 		return 0, nil, err
 	}
 
@@ -109,7 +109,7 @@ func (c *udpMuxedConn) CloseChannel() <-chan struct{} {
 func (c *udpMuxedConn) Close() error {
 	var err error
 	c.closeOnce.Do(func() {
-		err = c.buffer.Close()
+		err = c.buf.Close()
 		close(c.closedChan)
 	})
 	return err
@@ -172,28 +172,28 @@ func (c *udpMuxedConn) writePacket(data []byte, addr *net.UDPAddr) error {
 	defer c.params.AddrPool.Put(buf)
 
 	// format of buffer | data len | data bytes | addr len | addr bytes |
-	if len(buf.buffer) < len(data)+maxAddrSize {
+	if len(buf.buf) < len(data)+maxAddrSize {
 		return io.ErrShortBuffer
 	}
 	// data len
-	binary.LittleEndian.PutUint16(buf.buffer, uint16(len(data)))
+	binary.LittleEndian.PutUint16(buf.buf, uint16(len(data)))
 	offset := 2
 
 	// data
-	copy(buf.buffer[offset:], data)
+	copy(buf.buf[offset:], data)
 	offset += len(data)
 
 	// write address first, leaving room for its length
-	n, err := encodeUDPAddr(addr, buf.buffer[offset+2:])
+	n, err := encodeUDPAddr(addr, buf.buf[offset+2:])
 	if err != nil {
 		return err
 	}
 	total := offset + n + 2
 
 	// address len
-	binary.LittleEndian.PutUint16(buf.buffer[offset:], uint16(n))
+	binary.LittleEndian.PutUint16(buf.buf[offset:], uint16(n))
 
-	if _, err := c.buffer.Write(buf.buffer[:total]); err != nil {
+	if _, err := c.buf.Write(buf.buf[:total]); err != nil {
 		return err
 	}
 	return nil