1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-22 18:17:52 -05:00
v2fly/common/mux/frame.go

146 lines
3.3 KiB
Go
Raw Normal View History

2017-02-07 15:11:47 -05:00
package mux
import (
2018-11-02 10:01:33 -04:00
"encoding/binary"
2018-09-26 07:01:12 -04:00
"io"
2018-05-26 19:19:05 -04:00
"v2ray.com/core/common"
2017-10-21 14:40:31 -04:00
"v2ray.com/core/common/bitmask"
2017-02-07 15:11:47 -05:00
"v2ray.com/core/common/buf"
"v2ray.com/core/common/net"
2017-10-21 15:59:46 -04:00
"v2ray.com/core/common/protocol"
2018-11-03 08:03:02 -04:00
"v2ray.com/core/common/serial"
2017-02-07 15:11:47 -05:00
)
type SessionStatus byte
const (
2017-04-12 05:52:10 -04:00
SessionStatusNew SessionStatus = 0x01
SessionStatusKeep SessionStatus = 0x02
SessionStatusEnd SessionStatus = 0x03
SessionStatusKeepAlive SessionStatus = 0x04
2017-02-07 15:11:47 -05:00
)
2017-03-31 18:53:01 -04:00
const (
2018-04-04 15:33:33 -04:00
OptionData bitmask.Byte = 0x01
OptionError bitmask.Byte = 0x02
2017-03-31 18:53:01 -04:00
)
2017-02-07 15:11:47 -05:00
type TargetNetwork byte
const (
TargetNetworkTCP TargetNetwork = 0x01
2017-04-02 03:48:30 -04:00
TargetNetworkUDP TargetNetwork = 0x02
2017-02-07 15:11:47 -05:00
)
2018-02-23 18:57:54 -05:00
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(),
)
2017-03-26 19:47:01 -04:00
/*
Frame format
2 bytes - length
2 bytes - session id
1 bytes - status
2017-03-31 18:53:01 -04:00
1 bytes - option
2017-03-26 19:47:01 -04:00
1 byte - network
2 bytes - port
n bytes - address
*/
2017-02-07 15:11:47 -05:00
type FrameMetadata struct {
Target net.Destination
2017-10-21 13:29:27 -04:00
SessionID uint16
2017-10-21 14:40:31 -04:00
Option bitmask.Byte
SessionStatus SessionStatus
2017-02-07 15:11:47 -05:00
}
2018-02-23 18:57:54 -05:00
func (f FrameMetadata) WriteTo(b *buf.Buffer) error {
2018-11-14 16:11:05 -05:00
lenBytes := b.Extend(2)
2018-02-23 18:57:54 -05:00
len0 := b.Len()
2018-11-14 16:11:05 -05:00
sessionBytes := b.Extend(2)
binary.BigEndian.PutUint16(sessionBytes, f.SessionID)
2018-02-23 18:57:54 -05:00
2018-11-14 16:11:05 -05:00
common.Must(b.WriteByte(byte(f.SessionStatus)))
common.Must(b.WriteByte(byte(f.Option)))
2018-02-23 18:57:54 -05:00
if f.SessionStatus == SessionStatusNew {
switch f.Target.Network {
case net.Network_TCP:
2018-11-14 16:11:05 -05:00
common.Must(b.WriteByte(byte(TargetNetworkTCP)))
2018-02-23 18:57:54 -05:00
case net.Network_UDP:
2018-11-14 16:11:05 -05:00
common.Must(b.WriteByte(byte(TargetNetworkUDP)))
2017-02-07 15:11:47 -05:00
}
2017-04-03 06:55:46 -04:00
2018-02-23 18:57:54 -05:00
if err := addrParser.WriteAddressPort(b, f.Target.Address, f.Target.Port); err != nil {
return err
}
2017-02-07 15:11:47 -05:00
}
2018-02-23 18:57:54 -05:00
len1 := b.Len()
2018-11-02 10:01:33 -04:00
binary.BigEndian.PutUint16(lenBytes, uint16(len1-len0))
2018-02-23 18:57:54 -05:00
return nil
2017-02-07 15:11:47 -05:00
}
2018-10-14 02:05:23 -04:00
// Unmarshal reads FrameMetadata from the given reader.
func (f *FrameMetadata) Unmarshal(reader io.Reader) error {
2018-11-03 08:03:02 -04:00
metaLen, err := serial.ReadUint16(reader)
2018-09-26 07:01:12 -04:00
if err != nil {
return err
}
if metaLen > 512 {
return newError("invalid metalen ", metaLen).AtError()
}
b := buf.New()
defer b.Release()
2018-11-02 10:01:33 -04:00
if _, err := b.ReadFullFrom(reader, int32(metaLen)); err != nil {
2018-09-26 07:01:12 -04:00
return err
}
2018-10-14 02:05:23 -04:00
return f.UnmarshalFromBuffer(b)
2018-09-26 07:01:12 -04:00
}
2018-10-14 02:05:23 -04:00
// UnmarshalFromBuffer reads a FrameMetadata from the given buffer.
2018-05-26 19:19:05 -04:00
// Visible for testing only.
2018-10-14 02:05:23 -04:00
func (f *FrameMetadata) UnmarshalFromBuffer(b *buf.Buffer) error {
2018-02-23 18:57:54 -05:00
if b.Len() < 4 {
2018-09-26 07:01:12 -04:00
return newError("insufficient buffer: ", b.Len())
2017-02-07 15:11:47 -05:00
}
2018-11-02 10:47:58 -04:00
f.SessionID = binary.BigEndian.Uint16(b.BytesTo(2))
2018-09-26 07:01:12 -04:00
f.SessionStatus = SessionStatus(b.Byte(2))
f.Option = bitmask.Byte(b.Byte(3))
f.Target.Network = net.Network_Unknown
2017-02-07 15:11:47 -05:00
if f.SessionStatus == SessionStatusNew {
2018-11-14 16:55:33 -05:00
if b.Len() < 8 {
return newError("insufficient buffer: ", b.Len())
}
2018-02-23 18:57:54 -05:00
network := TargetNetwork(b.Byte(4))
b.Advance(5)
2018-02-23 18:57:54 -05:00
addr, port, err := addrParser.ReadAddressPort(nil, b)
if err != nil {
2018-09-26 07:01:12 -04:00
return newError("failed to parse address and port").Base(err)
2017-02-07 15:11:47 -05:00
}
2018-02-23 18:57:54 -05:00
2017-02-07 15:11:47 -05:00
switch network {
case TargetNetworkTCP:
f.Target = net.TCPDestination(addr, port)
2017-04-02 03:48:30 -04:00
case TargetNetworkUDP:
2017-02-07 15:11:47 -05:00
f.Target = net.UDPDestination(addr, port)
2017-04-03 07:07:12 -04:00
default:
2018-09-26 07:01:12 -04:00
return newError("unknown network type: ", network)
2017-02-07 15:11:47 -05:00
}
}
2018-09-26 07:01:12 -04:00
return nil
2017-02-07 15:11:47 -05:00
}