encoding.go 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241
  1. package encoding
  2. //go:generate go run github.com/xtls/xray-core/common/errors/errorgen
  3. import (
  4. "context"
  5. "fmt"
  6. "io"
  7. "runtime"
  8. "syscall"
  9. "github.com/xtls/xray-core/transport/internet/stat"
  10. "github.com/xtls/xray-core/common/buf"
  11. "github.com/xtls/xray-core/common/errors"
  12. "github.com/xtls/xray-core/common/net"
  13. "github.com/xtls/xray-core/common/protocol"
  14. "github.com/xtls/xray-core/common/session"
  15. "github.com/xtls/xray-core/common/signal"
  16. "github.com/xtls/xray-core/features/stats"
  17. "github.com/xtls/xray-core/proxy/vless"
  18. "github.com/xtls/xray-core/transport/internet/xtls"
  19. )
  20. const (
  21. Version = byte(0)
  22. )
  23. var addrParser = protocol.NewAddressParser(
  24. protocol.AddressFamilyByte(byte(protocol.AddressTypeIPv4), net.AddressFamilyIPv4),
  25. protocol.AddressFamilyByte(byte(protocol.AddressTypeDomain), net.AddressFamilyDomain),
  26. protocol.AddressFamilyByte(byte(protocol.AddressTypeIPv6), net.AddressFamilyIPv6),
  27. protocol.PortThenAddress(),
  28. )
  29. // EncodeRequestHeader writes encoded request header into the given writer.
  30. func EncodeRequestHeader(writer io.Writer, request *protocol.RequestHeader, requestAddons *Addons) error {
  31. buffer := buf.StackNew()
  32. defer buffer.Release()
  33. if err := buffer.WriteByte(request.Version); err != nil {
  34. return newError("failed to write request version").Base(err)
  35. }
  36. if _, err := buffer.Write(request.User.Account.(*vless.MemoryAccount).ID.Bytes()); err != nil {
  37. return newError("failed to write request user id").Base(err)
  38. }
  39. if err := EncodeHeaderAddons(&buffer, requestAddons); err != nil {
  40. return newError("failed to encode request header addons").Base(err)
  41. }
  42. if err := buffer.WriteByte(byte(request.Command)); err != nil {
  43. return newError("failed to write request command").Base(err)
  44. }
  45. if request.Command != protocol.RequestCommandMux {
  46. if err := addrParser.WriteAddressPort(&buffer, request.Address, request.Port); err != nil {
  47. return newError("failed to write request address and port").Base(err)
  48. }
  49. }
  50. if _, err := writer.Write(buffer.Bytes()); err != nil {
  51. return newError("failed to write request header").Base(err)
  52. }
  53. return nil
  54. }
  55. // DecodeRequestHeader decodes and returns (if successful) a RequestHeader from an input stream.
  56. func DecodeRequestHeader(isfb bool, first *buf.Buffer, reader io.Reader, validator *vless.Validator) (*protocol.RequestHeader, *Addons, bool, error) {
  57. buffer := buf.StackNew()
  58. defer buffer.Release()
  59. request := new(protocol.RequestHeader)
  60. if isfb {
  61. request.Version = first.Byte(0)
  62. } else {
  63. if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
  64. return nil, nil, false, newError("failed to read request version").Base(err)
  65. }
  66. request.Version = buffer.Byte(0)
  67. }
  68. switch request.Version {
  69. case 0:
  70. var id [16]byte
  71. if isfb {
  72. copy(id[:], first.BytesRange(1, 17))
  73. } else {
  74. buffer.Clear()
  75. if _, err := buffer.ReadFullFrom(reader, 16); err != nil {
  76. return nil, nil, false, newError("failed to read request user id").Base(err)
  77. }
  78. copy(id[:], buffer.Bytes())
  79. }
  80. if request.User = validator.Get(id); request.User == nil {
  81. return nil, nil, isfb, newError("invalid request user id")
  82. }
  83. if isfb {
  84. first.Advance(17)
  85. }
  86. requestAddons, err := DecodeHeaderAddons(&buffer, reader)
  87. if err != nil {
  88. return nil, nil, false, newError("failed to decode request header addons").Base(err)
  89. }
  90. buffer.Clear()
  91. if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
  92. return nil, nil, false, newError("failed to read request command").Base(err)
  93. }
  94. request.Command = protocol.RequestCommand(buffer.Byte(0))
  95. switch request.Command {
  96. case protocol.RequestCommandMux:
  97. request.Address = net.DomainAddress("v1.mux.cool")
  98. request.Port = 0
  99. case protocol.RequestCommandTCP, protocol.RequestCommandUDP:
  100. if addr, port, err := addrParser.ReadAddressPort(&buffer, reader); err == nil {
  101. request.Address = addr
  102. request.Port = port
  103. }
  104. }
  105. if request.Address == nil {
  106. return nil, nil, false, newError("invalid request address")
  107. }
  108. return request, requestAddons, false, nil
  109. default:
  110. return nil, nil, isfb, newError("invalid request version")
  111. }
  112. }
  113. // EncodeResponseHeader writes encoded response header into the given writer.
  114. func EncodeResponseHeader(writer io.Writer, request *protocol.RequestHeader, responseAddons *Addons) error {
  115. buffer := buf.StackNew()
  116. defer buffer.Release()
  117. if err := buffer.WriteByte(request.Version); err != nil {
  118. return newError("failed to write response version").Base(err)
  119. }
  120. if err := EncodeHeaderAddons(&buffer, responseAddons); err != nil {
  121. return newError("failed to encode response header addons").Base(err)
  122. }
  123. if _, err := writer.Write(buffer.Bytes()); err != nil {
  124. return newError("failed to write response header").Base(err)
  125. }
  126. return nil
  127. }
  128. // DecodeResponseHeader decodes and returns (if successful) a ResponseHeader from an input stream.
  129. func DecodeResponseHeader(reader io.Reader, request *protocol.RequestHeader) (*Addons, error) {
  130. buffer := buf.StackNew()
  131. defer buffer.Release()
  132. if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
  133. return nil, newError("failed to read response version").Base(err)
  134. }
  135. if buffer.Byte(0) != request.Version {
  136. return nil, newError("unexpected response version. Expecting ", int(request.Version), " but actually ", int(buffer.Byte(0)))
  137. }
  138. responseAddons, err := DecodeHeaderAddons(&buffer, reader)
  139. if err != nil {
  140. return nil, newError("failed to decode response header addons").Base(err)
  141. }
  142. return responseAddons, nil
  143. }
  144. func ReadV(reader buf.Reader, writer buf.Writer, timer signal.ActivityUpdater, conn *xtls.Conn, rawConn syscall.RawConn, counter stats.Counter, sctx context.Context) error {
  145. err := func() error {
  146. var ct stats.Counter
  147. for {
  148. if conn.DirectIn {
  149. conn.DirectIn = false
  150. if sctx != nil {
  151. if inbound := session.InboundFromContext(sctx); inbound != nil && inbound.Conn != nil {
  152. iConn := inbound.Conn
  153. statConn, ok := iConn.(*stat.CounterConnection)
  154. if ok {
  155. iConn = statConn.Connection
  156. }
  157. if xc, ok := iConn.(*xtls.Conn); ok {
  158. iConn = xc.Connection
  159. }
  160. if tc, ok := iConn.(*net.TCPConn); ok {
  161. if conn.SHOW {
  162. fmt.Println(conn.MARK, "Splice")
  163. }
  164. runtime.Gosched() // necessary
  165. w, err := tc.ReadFrom(conn.Connection)
  166. if counter != nil {
  167. counter.Add(w)
  168. }
  169. if statConn != nil && statConn.WriteCounter != nil {
  170. statConn.WriteCounter.Add(w)
  171. }
  172. return err
  173. } else {
  174. panic("XTLS Splice: not TCP inbound")
  175. }
  176. } else {
  177. //panic("XTLS Splice: nil inbound or nil inbound.Conn")
  178. }
  179. }
  180. reader = buf.NewReadVReader(conn.Connection, rawConn, nil)
  181. ct = counter
  182. if conn.SHOW {
  183. fmt.Println(conn.MARK, "ReadV")
  184. }
  185. }
  186. buffer, err := reader.ReadMultiBuffer()
  187. if !buffer.IsEmpty() {
  188. if ct != nil {
  189. ct.Add(int64(buffer.Len()))
  190. }
  191. timer.Update()
  192. if werr := writer.WriteMultiBuffer(buffer); werr != nil {
  193. return werr
  194. }
  195. }
  196. if err != nil {
  197. return err
  198. }
  199. }
  200. }()
  201. if err != nil && errors.Cause(err) != io.EOF {
  202. return err
  203. }
  204. return nil
  205. }