123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241 |
- package encoding
- //go:generate go run github.com/xtls/xray-core/common/errors/errorgen
- import (
- "context"
- "fmt"
- "io"
- "runtime"
- "syscall"
- "github.com/xtls/xray-core/transport/internet/stat"
- "github.com/xtls/xray-core/common/buf"
- "github.com/xtls/xray-core/common/errors"
- "github.com/xtls/xray-core/common/net"
- "github.com/xtls/xray-core/common/protocol"
- "github.com/xtls/xray-core/common/session"
- "github.com/xtls/xray-core/common/signal"
- "github.com/xtls/xray-core/features/stats"
- "github.com/xtls/xray-core/proxy/vless"
- "github.com/xtls/xray-core/transport/internet/xtls"
- )
- const (
- Version = byte(0)
- )
- var addrParser = protocol.NewAddressParser(
- protocol.AddressFamilyByte(byte(protocol.AddressTypeIPv4), net.AddressFamilyIPv4),
- protocol.AddressFamilyByte(byte(protocol.AddressTypeDomain), net.AddressFamilyDomain),
- protocol.AddressFamilyByte(byte(protocol.AddressTypeIPv6), net.AddressFamilyIPv6),
- protocol.PortThenAddress(),
- )
- // EncodeRequestHeader writes encoded request header into the given writer.
- func EncodeRequestHeader(writer io.Writer, request *protocol.RequestHeader, requestAddons *Addons) error {
- buffer := buf.StackNew()
- defer buffer.Release()
- if err := buffer.WriteByte(request.Version); err != nil {
- return newError("failed to write request version").Base(err)
- }
- if _, err := buffer.Write(request.User.Account.(*vless.MemoryAccount).ID.Bytes()); err != nil {
- return newError("failed to write request user id").Base(err)
- }
- if err := EncodeHeaderAddons(&buffer, requestAddons); err != nil {
- return newError("failed to encode request header addons").Base(err)
- }
- if err := buffer.WriteByte(byte(request.Command)); err != nil {
- return newError("failed to write request command").Base(err)
- }
- if request.Command != protocol.RequestCommandMux {
- if err := addrParser.WriteAddressPort(&buffer, request.Address, request.Port); err != nil {
- return newError("failed to write request address and port").Base(err)
- }
- }
- if _, err := writer.Write(buffer.Bytes()); err != nil {
- return newError("failed to write request header").Base(err)
- }
- return nil
- }
- // DecodeRequestHeader decodes and returns (if successful) a RequestHeader from an input stream.
- func DecodeRequestHeader(isfb bool, first *buf.Buffer, reader io.Reader, validator *vless.Validator) (*protocol.RequestHeader, *Addons, bool, error) {
- buffer := buf.StackNew()
- defer buffer.Release()
- request := new(protocol.RequestHeader)
- if isfb {
- request.Version = first.Byte(0)
- } else {
- if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
- return nil, nil, false, newError("failed to read request version").Base(err)
- }
- request.Version = buffer.Byte(0)
- }
- switch request.Version {
- case 0:
- var id [16]byte
- if isfb {
- copy(id[:], first.BytesRange(1, 17))
- } else {
- buffer.Clear()
- if _, err := buffer.ReadFullFrom(reader, 16); err != nil {
- return nil, nil, false, newError("failed to read request user id").Base(err)
- }
- copy(id[:], buffer.Bytes())
- }
- if request.User = validator.Get(id); request.User == nil {
- return nil, nil, isfb, newError("invalid request user id")
- }
- if isfb {
- first.Advance(17)
- }
- requestAddons, err := DecodeHeaderAddons(&buffer, reader)
- if err != nil {
- return nil, nil, false, newError("failed to decode request header addons").Base(err)
- }
- buffer.Clear()
- if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
- return nil, nil, false, newError("failed to read request command").Base(err)
- }
- request.Command = protocol.RequestCommand(buffer.Byte(0))
- switch request.Command {
- case protocol.RequestCommandMux:
- request.Address = net.DomainAddress("v1.mux.cool")
- request.Port = 0
- case protocol.RequestCommandTCP, protocol.RequestCommandUDP:
- if addr, port, err := addrParser.ReadAddressPort(&buffer, reader); err == nil {
- request.Address = addr
- request.Port = port
- }
- }
- if request.Address == nil {
- return nil, nil, false, newError("invalid request address")
- }
- return request, requestAddons, false, nil
- default:
- return nil, nil, isfb, newError("invalid request version")
- }
- }
- // EncodeResponseHeader writes encoded response header into the given writer.
- func EncodeResponseHeader(writer io.Writer, request *protocol.RequestHeader, responseAddons *Addons) error {
- buffer := buf.StackNew()
- defer buffer.Release()
- if err := buffer.WriteByte(request.Version); err != nil {
- return newError("failed to write response version").Base(err)
- }
- if err := EncodeHeaderAddons(&buffer, responseAddons); err != nil {
- return newError("failed to encode response header addons").Base(err)
- }
- if _, err := writer.Write(buffer.Bytes()); err != nil {
- return newError("failed to write response header").Base(err)
- }
- return nil
- }
- // DecodeResponseHeader decodes and returns (if successful) a ResponseHeader from an input stream.
- func DecodeResponseHeader(reader io.Reader, request *protocol.RequestHeader) (*Addons, error) {
- buffer := buf.StackNew()
- defer buffer.Release()
- if _, err := buffer.ReadFullFrom(reader, 1); err != nil {
- return nil, newError("failed to read response version").Base(err)
- }
- if buffer.Byte(0) != request.Version {
- return nil, newError("unexpected response version. Expecting ", int(request.Version), " but actually ", int(buffer.Byte(0)))
- }
- responseAddons, err := DecodeHeaderAddons(&buffer, reader)
- if err != nil {
- return nil, newError("failed to decode response header addons").Base(err)
- }
- return responseAddons, nil
- }
- func ReadV(reader buf.Reader, writer buf.Writer, timer signal.ActivityUpdater, conn *xtls.Conn, rawConn syscall.RawConn, counter stats.Counter, sctx context.Context) error {
- err := func() error {
- var ct stats.Counter
- for {
- if conn.DirectIn {
- conn.DirectIn = false
- if sctx != nil {
- if inbound := session.InboundFromContext(sctx); inbound != nil && inbound.Conn != nil {
- iConn := inbound.Conn
- statConn, ok := iConn.(*stat.CounterConnection)
- if ok {
- iConn = statConn.Connection
- }
- if xc, ok := iConn.(*xtls.Conn); ok {
- iConn = xc.Connection
- }
- if tc, ok := iConn.(*net.TCPConn); ok {
- if conn.SHOW {
- fmt.Println(conn.MARK, "Splice")
- }
- runtime.Gosched() // necessary
- w, err := tc.ReadFrom(conn.Connection)
- if counter != nil {
- counter.Add(w)
- }
- if statConn != nil && statConn.WriteCounter != nil {
- statConn.WriteCounter.Add(w)
- }
- return err
- } else {
- panic("XTLS Splice: not TCP inbound")
- }
- } else {
- //panic("XTLS Splice: nil inbound or nil inbound.Conn")
- }
- }
- reader = buf.NewReadVReader(conn.Connection, rawConn, nil)
- ct = counter
- if conn.SHOW {
- fmt.Println(conn.MARK, "ReadV")
- }
- }
- buffer, err := reader.ReadMultiBuffer()
- if !buffer.IsEmpty() {
- if ct != nil {
- ct.Add(int64(buffer.Len()))
- }
- timer.Update()
- if werr := writer.WriteMultiBuffer(buffer); werr != nil {
- return werr
- }
- }
- if err != nil {
- return err
- }
- }
- }()
- if err != nil && errors.Cause(err) != io.EOF {
- return err
- }
- return nil
- }
|