package packetaddr
|
|
import (
|
"context"
|
gonet "net"
|
"sync"
|
"time"
|
|
"github.com/v2fly/v2ray-core/v5/common"
|
"github.com/v2fly/v2ray-core/v5/common/buf"
|
"github.com/v2fly/v2ray-core/v5/common/errors"
|
"github.com/v2fly/v2ray-core/v5/common/net"
|
"github.com/v2fly/v2ray-core/v5/features/routing"
|
"github.com/v2fly/v2ray-core/v5/transport"
|
)
|
|
var (
|
errNotPacketConn = errors.New("not a packet connection")
|
errUnsupported = errors.New("unsupported action")
|
)
|
|
func ToPacketAddrConn(link *transport.Link, dest net.Destination) (net.PacketConn, error) {
|
if !dest.Address.Family().IsDomain() {
|
return nil, errNotPacketConn
|
}
|
switch dest.Address.Domain() {
|
case seqPacketMagicAddress:
|
return &packetConnectionAdaptor{
|
readerAccess: &sync.Mutex{},
|
readerBuffer: nil,
|
link: link,
|
}, nil
|
default:
|
return nil, errNotPacketConn
|
}
|
}
|
|
func CreatePacketAddrConn(ctx context.Context, dispatcher routing.Dispatcher, isStream bool) (net.PacketConn, error) {
|
if isStream {
|
return nil, errUnsupported
|
}
|
packetDest := net.Destination{
|
Address: net.DomainAddress(seqPacketMagicAddress),
|
Port: 0,
|
Network: net.Network_UDP,
|
}
|
link, err := dispatcher.Dispatch(ctx, packetDest)
|
if err != nil {
|
return nil, err
|
}
|
return &packetConnectionAdaptor{
|
readerAccess: &sync.Mutex{},
|
readerBuffer: nil,
|
link: link,
|
}, nil
|
}
|
|
type packetConnectionAdaptor struct {
|
readerAccess *sync.Mutex
|
readerBuffer buf.MultiBuffer
|
link *transport.Link
|
}
|
|
func (c *packetConnectionAdaptor) ReadFrom(p []byte) (n int, addr gonet.Addr, err error) {
|
c.readerAccess.Lock()
|
defer c.readerAccess.Unlock()
|
if c.readerBuffer.IsEmpty() {
|
c.readerBuffer, err = c.link.Reader.ReadMultiBuffer()
|
if err != nil {
|
return 0, nil, err
|
}
|
}
|
c.readerBuffer, n = buf.SplitFirstBytes(c.readerBuffer, p)
|
var w *buf.Buffer
|
w, addr, err = ExtractAddressFromPacket(buf.FromBytes(p[:n]))
|
n = copy(p, w.Bytes())
|
w.Release()
|
return
|
}
|
|
func (c *packetConnectionAdaptor) WriteTo(p []byte, addr gonet.Addr) (n int, err error) {
|
payloadLen := len(p)
|
var buffer *buf.Buffer
|
buffer, err = AttachAddressToPacket(buf.FromBytes(p), addr)
|
if err != nil {
|
return 0, err
|
}
|
mb := buf.MultiBuffer{buffer}
|
err = c.link.Writer.WriteMultiBuffer(mb)
|
if err != nil {
|
return 0, err
|
}
|
return payloadLen, nil
|
}
|
|
func (c *packetConnectionAdaptor) Close() error {
|
c.readerAccess.Lock()
|
defer c.readerAccess.Unlock()
|
c.readerBuffer = buf.ReleaseMulti(c.readerBuffer)
|
return common.Interrupt(c.link)
|
}
|
|
func (c packetConnectionAdaptor) LocalAddr() gonet.Addr {
|
return &gonet.UnixAddr{Name: "unsupported"}
|
}
|
|
func (c packetConnectionAdaptor) SetDeadline(t time.Time) error {
|
return nil
|
}
|
|
func (c packetConnectionAdaptor) SetReadDeadline(t time.Time) error {
|
return nil
|
}
|
|
func (c packetConnectionAdaptor) SetWriteDeadline(t time.Time) error {
|
return nil
|
}
|
|
func ToPacketAddrConnWrapper(conn net.PacketConn, isStream bool) FusedConnection {
|
return &packetConnWrapper{conn}
|
}
|
|
type packetConnWrapper struct {
|
net.PacketConn
|
}
|
|
func (pc *packetConnWrapper) RemoteAddr() gonet.Addr {
|
return nil
|
}
|
|
type FusedConnection interface {
|
net.PacketConn
|
net.Conn
|
}
|
|
func (pc *packetConnWrapper) Read(p []byte) (n int, err error) {
|
recbuf := buf.StackNew()
|
recbuf.Extend(2048)
|
n, addr, err := pc.PacketConn.ReadFrom(recbuf.Bytes())
|
if err != nil {
|
return 0, err
|
}
|
recbuf.Resize(0, int32(n))
|
result, err := AttachAddressToPacket(&recbuf, addr)
|
if err != nil {
|
return 0, err
|
}
|
n = copy(p, result.Bytes())
|
result.Release()
|
return n, nil
|
}
|
|
func (pc *packetConnWrapper) Write(p []byte) (n int, err error) {
|
data, addr, err := ExtractAddressFromPacket(buf.FromBytes(p))
|
if err != nil {
|
return 0, err
|
}
|
_, err = pc.PacketConn.WriteTo(data.Bytes(), addr)
|
if err != nil {
|
return 0, err
|
}
|
data.Release()
|
return len(p), nil
|
}
|
|
func (pc *packetConnWrapper) Close() error {
|
return pc.PacketConn.Close()
|
}
|
|
func GetDestinationSubsetOf(dest net.Destination) (bool, error) {
|
if !dest.Address.Family().IsDomain() {
|
return false, errNotPacketConn
|
}
|
switch dest.Address.Domain() {
|
case seqPacketMagicAddress:
|
return false, nil
|
default:
|
return false, errNotPacketConn
|
}
|
}
|
