User settings for trusted user

common/net/timed_io.go

@@ -1,6 +1,7 @@
 package net
 
 import (
+  "io"
 	"net"
 	"time"
 )
@@ -10,27 +11,21 @@ var (
 )
 
 type TimeOutReader struct {
-	timeout    int
+  timeout int
 	connection net.Conn
+  worker io.Reader
 }
 
 func NewTimeOutReader(timeout int, connection net.Conn) *TimeOutReader {
-	return &TimeOutReader{
-		timeout:    timeout,
+	reader := &TimeOutReader{
 		connection: connection,
 	}
+  reader.SetTimeOut(timeout)
+  return reader
 }
 
-func (reader *TimeOutReader) Read(p []byte) (n int, err error) {
-	if reader.timeout > 0 {
-		deadline := time.Duration(reader.timeout) * time.Second
-		reader.connection.SetReadDeadline(time.Now().Add(deadline))
-	}
-	n, err = reader.connection.Read(p)
-	if reader.timeout > 0 {
-		reader.connection.SetReadDeadline(emptyTime)
-	}
-	return
+func (reader *TimeOutReader) Read(p []byte) (int, error) {
+	return reader.worker.Read(p)
 }
 
 func (reader *TimeOutReader) GetTimeOut() int {
@@ -38,5 +33,36 @@ func (reader *TimeOutReader) GetTimeOut() int {
 }
 
 func (reader *TimeOutReader) SetTimeOut(value int) {
-	reader.timeout = value
+  reader.timeout = value
+  if value > 0 {
+    reader.worker = &timedReaderWorker{
+      timeout: value,
+      connection: reader.connection,
+    }
+  } else {
+    reader.worker = &noOpReaderWorker{
+      connection: reader.connection,
+    }
+  }
+}
+
+type timedReaderWorker struct {
+  timeout int
+  connection net.Conn
+}
+
+func (this *timedReaderWorker) Read(p []byte) (int, error) {
+  deadline := time.Duration(this.timeout) * time.Second
+	this.connection.SetReadDeadline(time.Now().Add(deadline))
+  nBytes, err := this.connection.Read(p)
+  this.connection.SetReadDeadline(emptyTime)
+  return nBytes, err
+}
+
+type noOpReaderWorker struct {
+  connection net.Conn
+}
+
+func (this *noOpReaderWorker) Read(p []byte) (int, error) {
+  return this.connection.Read(p)
 }

proxy/vmess/protocol/vmess.go

@@ -37,7 +37,7 @@ const (
 // streaming.
 type VMessRequest struct {
 	Version        byte
-	UserId         config.ID
+	User         config.User
 	RequestIV      []byte
 	RequestKey     []byte
 	ResponseHeader []byte
@@ -98,7 +98,7 @@ func (r *VMessRequestReader) Read(reader io.Reader) (*VMessRequest, error) {
 	bufferLen := nBytes
 
 	request := &VMessRequest{
-		UserId:  *userObj.ID(),
+		User:  userObj,
 		Version: buffer.Value[0],
 	}
 
@@ -167,7 +167,7 @@ func (request *VMessRequest) ToBytes(idHash user.CounterHash, randomRangeInt64 u
 	}
 
 	counter := randomRangeInt64(time.Now().Unix(), 30)
-	hash := idHash.Hash(request.UserId.Bytes[:], counter)
+	hash := idHash.Hash(request.User.ID().Bytes[:], counter)
 
 	buffer.Append(hash)
 
@@ -201,7 +201,7 @@ func (request *VMessRequest) ToBytes(idHash user.CounterHash, randomRangeInt64 u
 	buffer.AppendBytes(byte(fnvHash>>24), byte(fnvHash>>16), byte(fnvHash>>8), byte(fnvHash))
 	encryptionEnd += 4
 
-	aesCipher, err := aes.NewCipher(request.UserId.CmdKey())
+	aesCipher, err := aes.NewCipher(request.User.ID().CmdKey())
 	if err != nil {
 		return nil, err
 	}

proxy/vmess/protocol/vmess_test.go

@@ -32,15 +32,17 @@ func TestVMessSerialization(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+  
+  testUser := &TestUser {
+    id: userId,
+  }
 
 	userSet := mocks.MockUserSet{[]config.User{}, make(map[string]int), make(map[string]int64)}
-	userSet.AddUser(&TestUser{
-    id: userId,
-  })
+	userSet.AddUser(testUser)
 
 	request := new(VMessRequest)
 	request.Version = byte(0x01)
-	request.UserId = *userId
+	request.User = testUser
 
 	randBytes := make([]byte, 36)
 	_, err = rand.Read(randBytes)
@@ -69,7 +71,7 @@ func TestVMessSerialization(t *testing.T) {
 	}
 
 	assert.Byte(actualRequest.Version).Named("Version").Equals(byte(0x01))
-	assert.String(actualRequest.UserId.String).Named("UserId").Equals(request.UserId.String)
+	assert.String(actualRequest.User.ID().String).Named("UserId").Equals(request.User.ID().String)
 	assert.Bytes(actualRequest.RequestIV).Named("RequestIV").Equals(request.RequestIV[:])
 	assert.Bytes(actualRequest.RequestKey).Named("RequestKey").Equals(request.RequestKey[:])
 	assert.Bytes(actualRequest.ResponseHeader).Named("ResponseHeader").Equals(request.ResponseHeader[:])
@@ -80,13 +82,15 @@ func TestVMessSerialization(t *testing.T) {
 func BenchmarkVMessRequestWriting(b *testing.B) {
 	userId, _ := config.NewID("2b2966ac-16aa-4fbf-8d81-c5f172a3da51")
 	userSet := mocks.MockUserSet{[]config.User{}, make(map[string]int), make(map[string]int64)}
-	userSet.AddUser(&TestUser{
+  
+  testUser := &TestUser{
     id: userId,
-  })
+  }
+	userSet.AddUser(testUser)
 
 	request := new(VMessRequest)
 	request.Version = byte(0x01)
-	request.UserId = *userId
+	request.User = testUser
 
 	randBytes := make([]byte, 36)
 	rand.Read(randBytes)

proxy/vmess/vmessin.go

@@ -91,7 +91,8 @@ func (handler *VMessInboundHandler) HandleConnection(connection *net.TCPConn) er
 	readFinish.Lock()
 	writeFinish.Lock()
 
-	connReader.SetTimeOut(120)
+  userSettings := config.GetUserSettings(request.User.Level())
+	connReader.SetTimeOut(userSettings.PayloadReadTimeout)
 	go handleInput(request, connReader, input, &readFinish)
 
 	responseKey := md5.Sum(request.RequestKey)

proxy/vmess/vmessout.go

@@ -67,7 +67,7 @@ func (handler *VMessOutboundHandler) Dispatch(firstPacket v2net.Packet, ray ray.
 	}
 	request := &protocol.VMessRequest{
 		Version: protocol.Version,
-		UserId:  *vNextUser.ID(),
+		User:  vNextUser,
 		Command: command,
 		Address: firstPacket.Destination().Address(),
 	}