conn.go 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213
  1. package vless
  2. import (
  3. "encoding/binary"
  4. "errors"
  5. "io"
  6. "net"
  7. "sync"
  8. "github.com/metacubex/mihomo/common/buf"
  9. N "github.com/metacubex/mihomo/common/net"
  10. "github.com/metacubex/mihomo/transport/vless/vision"
  11. "github.com/gofrs/uuid/v5"
  12. "google.golang.org/protobuf/proto"
  13. )
  14. type Conn struct {
  15. N.ExtendedWriter
  16. N.ExtendedReader
  17. net.Conn
  18. dst *DstAddr
  19. id *uuid.UUID
  20. addons *Addons
  21. received bool
  22. handshakeMutex sync.Mutex
  23. needHandshake bool
  24. err error
  25. }
  26. func (vc *Conn) Read(b []byte) (int, error) {
  27. if vc.received {
  28. return vc.ExtendedReader.Read(b)
  29. }
  30. if err := vc.recvResponse(); err != nil {
  31. return 0, err
  32. }
  33. vc.received = true
  34. return vc.ExtendedReader.Read(b)
  35. }
  36. func (vc *Conn) ReadBuffer(buffer *buf.Buffer) error {
  37. if vc.received {
  38. return vc.ExtendedReader.ReadBuffer(buffer)
  39. }
  40. if err := vc.recvResponse(); err != nil {
  41. return err
  42. }
  43. vc.received = true
  44. return vc.ExtendedReader.ReadBuffer(buffer)
  45. }
  46. func (vc *Conn) Write(p []byte) (int, error) {
  47. if vc.needHandshake {
  48. vc.handshakeMutex.Lock()
  49. if vc.needHandshake {
  50. vc.needHandshake = false
  51. if vc.sendRequest(p) {
  52. vc.handshakeMutex.Unlock()
  53. if vc.err != nil {
  54. return 0, vc.err
  55. }
  56. return len(p), vc.err
  57. }
  58. if vc.err != nil {
  59. vc.handshakeMutex.Unlock()
  60. return 0, vc.err
  61. }
  62. }
  63. vc.handshakeMutex.Unlock()
  64. }
  65. return vc.ExtendedWriter.Write(p)
  66. }
  67. func (vc *Conn) WriteBuffer(buffer *buf.Buffer) error {
  68. if vc.needHandshake {
  69. vc.handshakeMutex.Lock()
  70. if vc.needHandshake {
  71. vc.needHandshake = false
  72. if vc.sendRequest(buffer.Bytes()) {
  73. vc.handshakeMutex.Unlock()
  74. return vc.err
  75. }
  76. if vc.err != nil {
  77. vc.handshakeMutex.Unlock()
  78. return vc.err
  79. }
  80. }
  81. vc.handshakeMutex.Unlock()
  82. }
  83. return vc.ExtendedWriter.WriteBuffer(buffer)
  84. }
  85. func (vc *Conn) sendRequest(p []byte) bool {
  86. var addonsBytes []byte
  87. if vc.addons != nil {
  88. addonsBytes, vc.err = proto.Marshal(vc.addons)
  89. if vc.err != nil {
  90. return true
  91. }
  92. }
  93. var buffer *buf.Buffer
  94. if vc.IsXTLSVisionEnabled() {
  95. buffer = buf.New()
  96. defer buffer.Release()
  97. } else {
  98. requestLen := 1 // protocol version
  99. requestLen += 16 // UUID
  100. requestLen += 1 // addons length
  101. requestLen += len(addonsBytes)
  102. requestLen += 1 // command
  103. if !vc.dst.Mux {
  104. requestLen += 2 // port
  105. requestLen += 1 // addr type
  106. requestLen += len(vc.dst.Addr)
  107. }
  108. requestLen += len(p)
  109. buffer = buf.NewSize(requestLen)
  110. defer buffer.Release()
  111. }
  112. buf.Must(
  113. buffer.WriteByte(Version), // protocol version
  114. buf.Error(buffer.Write(vc.id.Bytes())), // 16 bytes of uuid
  115. buffer.WriteByte(byte(len(addonsBytes))),
  116. buf.Error(buffer.Write(addonsBytes)),
  117. )
  118. if vc.dst.Mux {
  119. buf.Must(buffer.WriteByte(CommandMux))
  120. } else {
  121. if vc.dst.UDP {
  122. buf.Must(buffer.WriteByte(CommandUDP))
  123. } else {
  124. buf.Must(buffer.WriteByte(CommandTCP))
  125. }
  126. binary.BigEndian.PutUint16(buffer.Extend(2), vc.dst.Port)
  127. buf.Must(
  128. buffer.WriteByte(vc.dst.AddrType),
  129. buf.Error(buffer.Write(vc.dst.Addr)),
  130. )
  131. }
  132. buf.Must(buf.Error(buffer.Write(p)))
  133. _, vc.err = vc.ExtendedWriter.Write(buffer.Bytes())
  134. return true
  135. }
  136. func (vc *Conn) recvResponse() error {
  137. var buffer [2]byte
  138. _, vc.err = io.ReadFull(vc.ExtendedReader, buffer[:])
  139. if vc.err != nil {
  140. return vc.err
  141. }
  142. if buffer[0] != Version {
  143. return errors.New("unexpected response version")
  144. }
  145. length := int64(buffer[1])
  146. if length != 0 { // addon data length > 0
  147. io.CopyN(io.Discard, vc.ExtendedReader, length) // just discard
  148. }
  149. return nil
  150. }
  151. func (vc *Conn) Upstream() any {
  152. return vc.Conn
  153. }
  154. func (vc *Conn) NeedHandshake() bool {
  155. return vc.needHandshake
  156. }
  157. func (vc *Conn) IsXTLSVisionEnabled() bool {
  158. return vc.addons != nil && vc.addons.Flow == XRV
  159. }
  160. // newConn return a Conn instance
  161. func newConn(conn net.Conn, client *Client, dst *DstAddr) (net.Conn, error) {
  162. c := &Conn{
  163. ExtendedReader: N.NewExtendedReader(conn),
  164. ExtendedWriter: N.NewExtendedWriter(conn),
  165. Conn: conn,
  166. id: client.uuid,
  167. dst: dst,
  168. needHandshake: true,
  169. }
  170. if client.Addons != nil {
  171. switch client.Addons.Flow {
  172. case XRV:
  173. visionConn, err := vision.NewConn(c, c.id)
  174. if err != nil {
  175. return nil, err
  176. }
  177. c.addons = client.Addons
  178. return visionConn, nil
  179. }
  180. }
  181. return c, nil
  182. }