unix: support udp forwarding (#194)

This commit is contained in:
nadoo committed 2020-12-01 20:04:47 +08:00
1 parent 63112a1509
commit 142865535e
10 files changed
+259 -111

No files matched your search

+3 -2
View File
@@ -24,8 +24,8 @@ type KCP struct {
key string
crypt string
mode string
block kcp.BlockCrypt
mode string
dataShards int
parityShards int
@@ -258,7 +258,8 @@ func (s *KCP) setParams(c *kcp.UDPSession) {
c.SetNoDelay(1, 20, 2, 1)
case "fast3":
c.SetNoDelay(1, 10, 2, 1)
default: // default use fast
default:
log.F("[kcp] unkonw mode: %s, use fast mode instead", s.mode)
c.SetNoDelay(0, 30, 2, 1)
}
+3 -1
View File
@@ -77,7 +77,9 @@ func (s *UDP) ListenAndServe() {
v, ok := nm.Load(lraddr.String())
if !ok && v == nil {
pc, dialer, raddr, err = s.proxy.DialUDP("udp", "")
// we know we are creating an udp tunnel, so the dial addr is meaningless,
// we use lraddr here to help the unix client to identify the source socket.
pc, dialer, raddr, err = s.proxy.DialUDP("udp", lraddr.String())
if err != nil {
log.F("[udp] remote dial error: %v", err)
continue
+76
View File
@@ -0,0 +1,76 @@
package unix
import (
"net"
"os"
"github.com/nadoo/glider/proxy"
)
func init() {
proxy.RegisterDialer("unix", NewUnixDialer)
}
// NewUnixDialer returns a unix domain socket dialer.
func NewUnixDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
return NewUnix(s, d, nil)
}
// Addr returns forwarder's address.
func (s *Unix) Addr() string {
if s.addr == "" {
return s.dialer.Addr()
}
return s.addr
}
// Dial connects to the address addr on the network net via the proxy.
// NOTE: must be the first dialer in a chain
func (s *Unix) Dial(network, addr string) (net.Conn, error) {
return net.Dial("unix", s.addr)
}
// DialUDP connects to the given address via the proxy.
// NOTE: must be the first dialer in a chain
func (s *Unix) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
laddru := s.addru + "_" + addr
os.Remove(laddru)
luaddru, err := net.ResolveUnixAddr("unixgram", laddru)
if err != nil {
return nil, nil, err
}
pc, err := net.ListenUnixgram("unixgram", luaddru)
if err != nil {
return nil, nil, err
}
return &PktConn{pc, laddru, luaddru, s.uaddru}, s.uaddru, nil
}
// PktConn .
type PktConn struct {
*net.UnixConn
addr string
uaddr *net.UnixAddr
writeAddr *net.UnixAddr
}
// ReadFrom overrides the original function from net.PacketConn.
func (pc *PktConn) ReadFrom(b []byte) (int, net.Addr, error) {
n, _, err := pc.UnixConn.ReadFrom(b)
return n, pc.uaddr, err
}
// WriteTo overrides the original function from net.PacketConn.
func (pc *PktConn) WriteTo(b []byte, addr net.Addr) (int, error) {
return pc.UnixConn.WriteTo(b, pc.writeAddr)
}
// Close overrides the original function from net.PacketConn.
func (pc *PktConn) Close() error {
pc.UnixConn.Close()
os.Remove(pc.addr)
return nil
}
+149
View File
@@ -0,0 +1,149 @@
package unix
import (
"net"
"os"
"strings"
"sync"
"time"
"github.com/nadoo/glider/log"
"github.com/nadoo/glider/proxy"
)
func init() {
proxy.RegisterServer("unix", NewUnixServer)
}
// NewUnixServer returns a unix domain socket server.
func NewUnixServer(s string, p proxy.Proxy) (proxy.Server, error) {
transport := strings.Split(s, ",")
unix, err := NewUnix(transport[0], nil, p)
if err != nil {
return nil, err
}
if len(transport) > 1 {
unix.server, err = proxy.ServerFromURL(transport[1], p)
if err != nil {
return nil, err
}
}
return unix, nil
}
// ListenAndServe serves requests.
func (s *Unix) ListenAndServe() {
go s.ListenAndServeUDP()
s.ListenAndServeTCP()
}
// ListenAndServe serves tcp requests.
func (s *Unix) ListenAndServeTCP() {
os.Remove(s.addr)
l, err := net.Listen("unix", s.addr)
if err != nil {
log.F("[unix] failed to listen on %s: %v", s.addr, err)
return
}
defer l.Close()
log.F("[unix] listening on %s", s.addr)
for {
c, err := l.Accept()
if err != nil {
log.F("[unix] failed to accept: %v", err)
continue
}
go s.Serve(c)
}
}
// Serve serves requests.
func (s *Unix) Serve(c net.Conn) {
if s.server != nil {
s.server.Serve(c)
return
}
defer c.Close()
rc, dialer, err := s.proxy.Dial("unix", "")
if err != nil {
log.F("[unix] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, dialer.Addr(), err)
s.proxy.Record(dialer, false)
return
}
defer rc.Close()
log.F("[unix] %s <-> %s", c.RemoteAddr(), dialer.Addr())
if err = proxy.Relay(c, rc); err != nil {
log.F("[unix] %s <-> %s, relay error: %v", c.RemoteAddr(), dialer.Addr(), err)
// record remote conn failure only
if !strings.Contains(err.Error(), s.addr) {
s.proxy.Record(dialer, false)
}
}
}
// ListenAndServe serves udp requests.
func (s *Unix) ListenAndServeUDP() {
os.Remove(s.addru)
c, err := net.ListenPacket("unixgram", s.addru)
if err != nil {
log.F("[unix] failed to ListenPacket on %s: %v", s.addru, err)
return
}
defer c.Close()
log.F("[unix] ListenPacket on %s", s.addru)
var nm sync.Map
buf := make([]byte, proxy.UDPBufSize)
for {
n, lraddr, err := c.ReadFrom(buf)
if err != nil {
log.F("[unix] read error: %v", err)
continue
}
var raddr net.Addr
var pc net.PacketConn
var dialer proxy.UDPDialer
v, ok := nm.Load(lraddr.String())
if !ok && v == nil {
pc, dialer, raddr, err = s.proxy.DialUDP("udp", "")
if err != nil {
log.F("[unix] remote dial error: %v", err)
continue
}
nm.Store(lraddr.String(), pc)
go func(c, pc net.PacketConn, lraddr net.Addr) {
proxy.RelayUDP(c, lraddr, pc, 2*time.Minute)
pc.Close()
nm.Delete(lraddr.String())
}(c, pc, lraddr)
} else {
pc = v.(net.PacketConn)
}
_, err = pc.WriteTo(buf[:n], raddr)
if err != nil {
log.F("[unix] remote write error: %v", err)
continue
}
log.F("[unix] %s <-> %s", s.addru, dialer.Addr())
}
}
+13 -100
View File
@@ -1,11 +1,8 @@
package unix
import (
"errors"
"net"
"net/url"
"os"
"strings"
"github.com/nadoo/glider/log"
"github.com/nadoo/glider/proxy"
@@ -15,21 +12,20 @@ import (
type Unix struct {
dialer proxy.Dialer
proxy proxy.Proxy
addr string
server proxy.Server
addr string // addr for tcp
uaddr *net.UnixAddr
addru string // addr for udp (datagram)
uaddru *net.UnixAddr
}
func init() {
proxy.RegisterServer("unix", NewUnixServer)
proxy.RegisterDialer("unix", NewUnixDialer)
}
// NewUnix returns unix fomain socket proxy.
// NewUnix returns unix domain socket proxy.
func NewUnix(s string, d proxy.Dialer, p proxy.Proxy) (*Unix, error) {
u, err := url.Parse(s)
if err != nil {
log.F("parse url err: %s", err)
log.F("[unix] parse url err: %s", err)
return nil, err
}
@@ -37,101 +33,18 @@ func NewUnix(s string, d proxy.Dialer, p proxy.Proxy) (*Unix, error) {
dialer: d,
proxy: p,
addr: u.Path,
addru: u.Path + "u",
}
return unix, nil
}
// NewUnixDialer returns a unix domain socket dialer.
func NewUnixDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
return NewUnix(s, d, nil)
}
// NewUnixServer returns a unix domain socket server.
func NewUnixServer(s string, p proxy.Proxy) (proxy.Server, error) {
transport := strings.Split(s, ",")
unix, err := NewUnix(transport[0], nil, p)
unix.uaddr, err = net.ResolveUnixAddr("unixgram", unix.addr)
if err != nil {
return nil, err
}
if len(transport) > 1 {
unix.server, err = proxy.ServerFromURL(transport[1], p)
if err != nil {
return nil, err
}
unix.uaddru, err = net.ResolveUnixAddr("unixgram", unix.addru)
if err != nil {
return nil, err
}
return unix, nil
}
// ListenAndServe serves requests.
func (s *Unix) ListenAndServe() {
os.Remove(s.addr)
l, err := net.Listen("unix", s.addr)
if err != nil {
log.F("[unix] failed to listen on %s: %v", s.addr, err)
return
}
defer l.Close()
log.F("[unix] listening on %s", s.addr)
for {
c, err := l.Accept()
if err != nil {
log.F("[unix] failed to accept: %v", err)
continue
}
go s.Serve(c)
}
}
// Serve serves requests.
func (s *Unix) Serve(c net.Conn) {
if s.server != nil {
s.server.Serve(c)
return
}
defer c.Close()
rc, dialer, err := s.proxy.Dial("unix", "")
if err != nil {
log.F("[unix] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, dialer.Addr(), err)
s.proxy.Record(dialer, false)
return
}
defer rc.Close()
log.F("[unix] %s <-> %s", c.RemoteAddr(), dialer.Addr())
if err = proxy.Relay(c, rc); err != nil {
log.F("[unix] %s <-> %s, relay error: %v", c.RemoteAddr(), dialer.Addr(), err)
// record remote conn failure only
if !strings.Contains(err.Error(), s.addr) {
s.proxy.Record(dialer, false)
}
}
}
// Addr returns forwarder's address.
func (s *Unix) Addr() string {
if s.addr == "" {
return s.dialer.Addr()
}
return s.addr
}
// Dial connects to the address addr on the network net via the proxy.
func (s *Unix) Dial(network, addr string) (net.Conn, error) {
// NOTE: must be the first dialer in a chain
return net.Dial("unix", s.addr)
}
// DialUDP connects to the given address via the proxy.
func (s *Unix) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
return nil, nil, errors.New("unix domain socket client does not support udp now")
}