func TestBufferedReader(t *testing.T) {
assert := assert.On(t)
content := buf.New()
content.AppendSupplier(buf.ReadFrom(rand.Reader))
len := content.Len()
reader := NewReader(content)
assert.Bool(reader.Cached()).IsTrue()
payload := make([]byte, 16)
nBytes, err := reader.Read(payload)
assert.Int(nBytes).Equals(16)
assert.Error(err).IsNil()
len2 := content.Len()
assert.Int(len - len2).GreaterThan(16)
nBytes, err = reader.Read(payload)
assert.Int(nBytes).Equals(16)
assert.Error(err).IsNil()
assert.Int(content.Len()).Equals(len2)
}
// Read implements io.Reader.Read().
func (v *BufferedReader) Read(b []byte) (int, error) {
v.Lock()
defer v.Unlock()
if v.reader == nil {
return 0, io.EOF
}
if !v.cached {
if !v.buffer.IsEmpty() {
return v.buffer.Read(b)
}
return v.reader.Read(b)
}
if v.buffer.IsEmpty() {
err := v.buffer.AppendSupplier(buf.ReadFrom(v.reader))
if err != nil {
return 0, err
}
}
if v.buffer.IsEmpty() {
return 0, nil
}
return v.buffer.Read(b)
}
func (*HeaderReader) Read(reader io.Reader) (*buf.Buffer, error) {
buffer := buf.NewSmall()
totalBytes := 0
endingDetected := false
for totalBytes < maxHeaderLength {
err := buffer.AppendSupplier(buf.ReadFrom(reader))
if err != nil {
return nil, err
}
if n := bytes.Index(buffer.Bytes(), []byte(ENDING)); n != -1 {
buffer.SliceFrom(n + len(ENDING))
endingDetected = true
break
}
if buffer.Len() >= len(ENDING) {
totalBytes += buffer.Len() - len(ENDING)
leftover := buffer.BytesFrom(-len(ENDING))
buffer.Reset(func(b []byte) (int, error) {
return copy(b, leftover), nil
})
}
}
if buffer.IsEmpty() {
buffer.Release()
return nil, nil
}
if !endingDetected {
buffer.Release()
return nil, ErrHeaderToLong
}
return buffer, nil
}
func TestShadowsocksTCP(t *testing.T) {
assert := assert.On(t)
tcpServer := &tcp.Server{
Port: v2net.Port(50052),
MsgProcessor: func(data []byte) []byte {
buffer := make([]byte, 0, 2048)
buffer = append(buffer, []byte("Processed: ")...)
buffer = append(buffer, data...)
return buffer
},
}
_, err := tcpServer.Start()
assert.Error(err).IsNil()
defer tcpServer.Close()
assert.Error(InitializeServerSetOnce("test_6")).IsNil()
for i := 0; i < 1; i++ {
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: []byte{127, 0, 0, 1},
Port: 50050,
})
assert.Error(err).IsNil()
payload := "dokodemo request."
nBytes, err := conn.Write([]byte(payload))
assert.Error(err).IsNil()
assert.Int(nBytes).Equals(len(payload))
//conn.CloseWrite()
response := buf.New()
finished := false
expectedResponse := "Processed: " + payload
for {
err := response.AppendSupplier(buf.ReadFrom(conn))
assert.Error(err).IsNil()
if err != nil {
break
}
if response.String() == expectedResponse {
finished = true
break
}
if response.Len() > len(expectedResponse) {
fmt.Printf("Unexpected response: %v\n", response.Bytes())
break
}
}
assert.Bool(finished).IsTrue()
conn.Close()
}
CloseAllServers()
}
func (r *UDPReader) Read() (*buf.Buffer, error) {
b := buf.NewSmall()
if err := b.AppendSupplier(buf.ReadFrom(r.reader)); err != nil {
return nil, err
}
_, data, err := DecodeUDPPacket(b.Bytes())
if err != nil {
return nil, err
}
b.Clear()
b.Append(data)
return b, nil
}
func (v *UDPReader) Read() (*buf.Buffer, error) {
buffer := buf.NewSmall()
err := buffer.AppendSupplier(buf.ReadFrom(v.Reader))
if err != nil {
buffer.Release()
return nil, err
}
_, payload, err := DecodeUDPPacket(v.User, buffer)
if err != nil {
buffer.Release()
return nil, err
}
return payload, nil
}
// ReadFrom implements io.ReaderFrom.ReadFrom().
func (v *BufferedWriter) ReadFrom(reader io.Reader) (int64, error) {
totalBytes := int64(0)
for {
oriSize := v.buffer.Len()
err := v.buffer.AppendSupplier(buf.ReadFrom(reader))
totalBytes += int64(v.buffer.Len() - oriSize)
if err != nil {
if errors.Cause(err) == io.EOF {
return totalBytes, nil
}
return totalBytes, err
}
if err := v.Flush(); err != nil {
return totalBytes, err
}
}
}
func (o *ClientConnection) Run() {
payload := buf.NewSmall()
defer payload.Release()
for {
err := payload.Reset(buf.ReadFrom(o.Conn))
if err != nil {
payload.Release()
return
}
o.RLock()
if o.input != nil {
segments := o.reader.Read(payload.Bytes())
if len(segments) > 0 {
o.input(segments)
}
}
o.RUnlock()
}
}
// Read implements io.Reader.Read().
func (v *BufferedReader) Read(b []byte) (int, error) {
if !v.buffered || v.buffer == nil {
if !v.buffer.IsEmpty() {
return v.buffer.Read(b)
}
return v.reader.Read(b)
}
if v.buffer.IsEmpty() {
err := v.buffer.AppendSupplier(buf.ReadFrom(v.reader))
if err != nil {
return 0, err
}
}
if v.buffer.IsEmpty() {
return 0, nil
}
return v.buffer.Read(b)
}
func (v *BufferedWriter) ReadFrom(reader io.Reader) (int64, error) {
v.Lock()
defer v.Unlock()
if v.writer == nil {
return 0, io.ErrClosedPipe
}
totalBytes := int64(0)
for {
oriSize := v.buffer.Len()
err := v.buffer.AppendSupplier(buf.ReadFrom(reader))
totalBytes += int64(v.buffer.Len() - oriSize)
if err != nil {
if errors.Cause(err) == io.EOF {
return totalBytes, nil
}
return totalBytes, err
}
v.FlushWithoutLock()
}
}
func (v *AuthenticationReader) EnsureChunk() error {
for {
err := v.NextChunk()
if err == nil {
return nil
}
if err == errInsufficientBuffer {
if v.buffer.IsEmpty() {
v.buffer.Clear()
} else {
leftover := v.buffer.Bytes()
common.Must(v.buffer.Reset(func(b []byte) (int, error) {
return copy(b, leftover), nil
}))
}
err = v.buffer.AppendSupplier(buf.ReadFrom(v.reader))
if err == nil {
continue
}
}
return err
}
}