Deprecate stack buffer

Author: nekohasekai

common/buf/buffer.go

@@ -54,41 +54,19 @@ func NewSize(size int) *Buffer {
 	}
 }
 
+// Deprecated: use New instead.
 func StackNew() *Buffer {
-	if common.UnsafeBuffer {
-		return &Buffer{
-			data:  make([]byte, BufferSize),
-			start: ReversedHeader,
-			end:   ReversedHeader,
-		}
-	} else {
-		return New()
-	}
+	return New()
 }
 
+// Deprecated: use NewPacket instead.
 func StackNewPacket() *Buffer {
-	if common.UnsafeBuffer {
-		return &Buffer{
-			data:  make([]byte, UDPBufferSize),
-			start: ReversedHeader,
-			end:   ReversedHeader,
-		}
-	} else {
-		return NewPacket()
-	}
+	return NewPacket()
 }
 
+// Deprecated: use NewSize instead.
 func StackNewSize(size int) *Buffer {
-	if size == 0 {
-		return &Buffer{}
-	}
-	if common.UnsafeBuffer {
-		return &Buffer{
-			data: Make(size),
-		}
-	} else {
-		return NewSize(size)
-	}
+	return NewSize(size)
 }
 
 func As(data []byte) *Buffer {

common/buf/hex.go

@@ -11,46 +11,7 @@ func Put(buf []byte) error {
 	return DefaultAllocator.Put(buf)
 }
 
+// Deprecated: use array instead.
 func Make(size int) []byte {
-	if size == 0 {
-		return nil
-	}
-	var buffer []byte
-	switch {
-	case size <= 2:
-		buffer = make([]byte, 2)
-	case size <= 4:
-		buffer = make([]byte, 4)
-	case size <= 8:
-		buffer = make([]byte, 8)
-	case size <= 16:
-		buffer = make([]byte, 16)
-	case size <= 32:
-		buffer = make([]byte, 32)
-	case size <= 64:
-		buffer = make([]byte, 64)
-	case size <= 128:
-		buffer = make([]byte, 128)
-	case size <= 256:
-		buffer = make([]byte, 256)
-	case size <= 512:
-		buffer = make([]byte, 512)
-	case size <= 1024:
-		buffer = make([]byte, 1024)
-	case size <= 2048:
-		buffer = make([]byte, 2048)
-	case size <= 4096:
-		buffer = make([]byte, 4096)
-	case size <= 8192:
-		buffer = make([]byte, 8192)
-	case size <= 16384:
-		buffer = make([]byte, 16384)
-	case size <= 32768:
-		buffer = make([]byte, 32768)
-	case size <= 65535:
-		buffer = make([]byte, 65535)
-	default:
-		return make([]byte, size)
-	}
-	return buffer[:size]
+	return make([]byte, size)
 }

common/buf/pool.go

@@ -71,20 +71,7 @@ func CopyExtended(originDestination io.Writer, destination N.ExtendedWriter, sou
 			return
 		}
 	}
-	if !common.UnsafeBuffer || N.IsUnsafeWriter(destination) {
-		return CopyExtendedWithPool(originDestination, destination, source, readCounters, writeCounters)
-	}
-	bufferSize := N.CalculateMTU(source, destination)
-	if bufferSize > 0 {
-		bufferSize += headroom
-	} else {
-		bufferSize = buf.BufferSize
-	}
-	_buffer := buf.StackNewSize(bufferSize)
-	defer common.KeepAlive(_buffer)
-	buffer := common.Dup(_buffer)
-	defer buffer.Release()
-	return CopyExtendedBuffer(originDestination, destination, source, buffer, readCounters, writeCounters)
+	return CopyExtendedWithPool(originDestination, destination, source, readCounters, writeCounters)
 }
 
 func CopyExtendedBuffer(originDestination io.Writer, destination N.ExtendedWriter, source N.ExtendedReader, buffer *buf.Buffer, readCounters []N.CountFunc, writeCounters []N.CountFunc) (n int64, err error) {
@@ -291,49 +278,7 @@ func CopyPacket(destinationConn N.PacketWriter, source N.PacketReader) (n int64,
 			return
 		}
 	}
-	if N.IsUnsafeWriter(destinationConn) {
-		return CopyPacketWithPool(destinationConn, source, readCounters, writeCounters)
-	}
-	bufferSize := N.CalculateMTU(source, destinationConn)
-	if bufferSize > 0 {
-		bufferSize += headroom
-	} else {
-		bufferSize = buf.UDPBufferSize
-	}
-	_buffer := buf.StackNewSize(bufferSize)
-	defer common.KeepAlive(_buffer)
-	buffer := common.Dup(_buffer)
-	defer buffer.Release()
-	buffer.IncRef()
-	defer buffer.DecRef()
-	var destination M.Socksaddr
-	var notFirstTime bool
-	readBufferRaw := buffer.Slice()
-	readBuffer := buf.With(readBufferRaw[:len(readBufferRaw)-rearHeadroom])
-	for {
-		readBuffer.Resize(frontHeadroom, 0)
-		destination, err = source.ReadPacket(readBuffer)
-		if err != nil {
-			if !notFirstTime {
-				err = N.HandshakeFailure(destinationConn, err)
-			}
-			return
-		}
-		dataLen := readBuffer.Len()
-		buffer.Resize(readBuffer.Start(), dataLen)
-		err = destinationConn.WritePacket(buffer, destination)
-		if err != nil {
-			return
-		}
-		n += int64(dataLen)
-		for _, counter := range readCounters {
-			counter(int64(dataLen))
-		}
-		for _, counter := range writeCounters {
-			counter(int64(dataLen))
-		}
-		notFirstTime = true
-	}
+	return CopyPacketWithPool(destinationConn, source, readCounters, writeCounters)
 }
 
 func CopyPacketWithSrcBuffer(destinationConn N.PacketWriter, source N.ThreadSafePacketReader, readCounters []N.CountFunc, writeCounters []N.CountFunc) (n int64, err error) {

common/buf/ptr.go

@@ -74,9 +74,7 @@ func (w *BufferedVectorisedWriter) WriteVectorised(buffers []*buf.Buffer) error
 	if bufferLen > 65535 {
 		bufferBytes = make([]byte, bufferLen)
 	} else {
-		_buffer := buf.StackNewSize(bufferLen)
-		defer common.KeepAlive(_buffer)
-		buffer := common.Dup(_buffer)
+		buffer := buf.NewSize(bufferLen)
 		defer buffer.Release()
 		bufferBytes = buffer.FreeBytes()
 	}