Skip to content

G
gost
Commit 7eea9b3a authored by ginuerzh's avatar ginuerzh
Browse files
Options

tuntap: code refactor

parent 47d5b72b
Hide whitespace changes
Inline Side-by-side
Showing with 170 additions and 258 deletions
cmd/gost/route.go
View file @ 7eea9b3a
...@@ -395,17 +395,23 @@ func (r *route) GenRouters() ([]router, error) { ...@@ -395,17 +395,23 @@ func (r *route) GenRouters() ([]router, error) {
case "ohttp": case "ohttp":
ln, err = gost.ObfsHTTPListener(node.Addr) ln, err = gost.ObfsHTTPListener(node.Addr)
case "tun": case "tun":
ln, err = gost.TunListener(node.Addr, cfg := gost.TunConfig{
gost.TunListenConfig{ Name: node.Get("name"),
TCP: node.GetBool("tcp"), Addr: node.Get("net"),
RemoteAddr: node.Remote, MTU: node.GetInt("mtu"),
}) Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
ln, err = gost.TunListener(cfg)
case "tap": case "tap":
ln, err = gost.TapListener(node.Addr, cfg := gost.TapConfig{
gost.TapListenConfig{ Name: node.Get("name"),
TCP: node.GetBool("tcp"), Addr: node.Get("net"),
RemoteAddr: node.Remote, MTU: node.GetInt("mtu"),
}) Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
ln, err = gost.TapListener(cfg)
default: default:
ln, err = gost.TCPListener(node.Addr) ln, err = gost.TCPListener(node.Addr)
} }
...@@ -444,23 +450,9 @@ func (r *route) GenRouters() ([]router, error) { ...@@ -444,23 +450,9 @@ func (r *route) GenRouters() ([]router, error) {
case "sni": case "sni":
handler = gost.SNIHandler() handler = gost.SNIHandler()
case "tun": case "tun":
cfg := gost.TunConfig{ handler = gost.TunHandler()
Name: node.Get("name"),
Addr: node.Get("net"),
MTU: node.GetInt("mtu"),
Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
handler = gost.TunHandler(node.Remote, gost.TunConfigHandlerOption(cfg))
case "tap": case "tap":
cfg := gost.TapConfig{ handler = gost.TapHandler()
Name: node.Get("name"),
Addr: node.Get("net"),
MTU: node.GetInt("mtu"),
Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
handler = gost.TapHandler(node.Remote, gost.TapConfigHandlerOption(cfg))
default: default:
// start from 2.5, if remote is not empty, then we assume that it is a forward tunnel. // start from 2.5, if remote is not empty, then we assume that it is a forward tunnel.
if node.Remote != "" { if node.Remote != "" {
...@@ -507,6 +499,7 @@ func (r *route) GenRouters() ([]router, error) { ...@@ -507,6 +499,7 @@ func (r *route) GenRouters() ([]router, error) {
gost.KnockingHandlerOption(node.Get("knock")), gost.KnockingHandlerOption(node.Get("knock")),
gost.NodeHandlerOption(node), gost.NodeHandlerOption(node),
gost.IPsHandlerOption(ips), gost.IPsHandlerOption(ips),
gost.TCPModeHandlerOption(node.GetBool("tcp")),
) )
rt := router{ rt := router{
......
handler.go
View file @ 7eea9b3a
...@@ -40,8 +40,7 @@ type HandlerOptions struct { ...@@ -40,8 +40,7 @@ type HandlerOptions struct {
Node Node Node Node
Host string Host string
IPs []string IPs []string
TunConfig TunConfig TCPMode bool
TapConfig TapConfig
} }
// HandlerOption allows a common way to set handler options. // HandlerOption allows a common way to set handler options.
...@@ -197,17 +196,10 @@ func IPsHandlerOption(ips []string) HandlerOption { ...@@ -197,17 +196,10 @@ func IPsHandlerOption(ips []string) HandlerOption {
} }
} }
// TunConfigHandlerOption sets the config for tun device. // TCPModeHandlerOption sets the tcp mode for tun/tap device.
func TunConfigHandlerOption(cfg TunConfig) HandlerOption { func TCPModeHandlerOption(b bool) HandlerOption {
return func(opts *HandlerOptions) { return func(opts *HandlerOptions) {
opts.TunConfig = cfg opts.TCPMode = b
}
}
// TapConfigHandlerOption sets the config for tap device.
func TapConfigHandlerOption(cfg TapConfig) HandlerOption {
return func(opts *HandlerOptions) {
opts.TapConfig = cfg
} }
} }
......
tuntap.go
View file @ 7eea9b3a
package gost package gost
import ( import (
"bytes"
"errors" "errors"
"fmt" "fmt"
"io" "io"
...@@ -55,17 +54,71 @@ func ipToTunRouteKey(ip net.IP) (key tunRouteKey) { ...@@ -55,17 +54,71 @@ func ipToTunRouteKey(ip net.IP) (key tunRouteKey) {
return return
} }
type tunListener struct {
addr net.Addr
conns chan net.Conn
closed chan struct{}
config TunConfig
}
// TunListener creates a listener for tun tunnel.
func TunListener(cfg TunConfig) (Listener, error) {
threads := 1
ln := &tunListener{
conns: make(chan net.Conn, threads),
closed: make(chan struct{}),
config: cfg,
}
for i := 0; i < threads; i++ {
conn, ifce, err := createTun(cfg)
if err != nil {
return nil, err
}
ln.addr = conn.LocalAddr()
addrs, _ := ifce.Addrs()
log.Logf("[tun] %s: name: %s, mtu: %d, addrs: %s",
conn.LocalAddr(), ifce.Name, ifce.MTU, addrs)
ln.conns <- conn
}
return ln, nil
}
func (l *tunListener) Accept() (net.Conn, error) {
select {
case conn := <-l.conns:
return conn, nil
case <-l.closed:
}
return nil, errors.New("accept on closed listener")
}
func (l *tunListener) Addr() net.Addr {
return l.addr
}
func (l *tunListener) Close() error {
select {
case <-l.closed:
return errors.New("listener has been closed")
default:
close(l.closed)
}
return nil
}
type tunHandler struct { type tunHandler struct {
raddr string
options *HandlerOptions options *HandlerOptions
ifce *net.Interface
routes sync.Map routes sync.Map
} }
// TunHandler creates a handler for tun tunnel. // TunHandler creates a handler for tun tunnel.
func TunHandler(raddr string, opts ...HandlerOption) Handler { func TunHandler(opts ...HandlerOption) Handler {
h := &tunHandler{ h := &tunHandler{
raddr: raddr,
options: &HandlerOptions{}, options: &HandlerOptions{},
} }
for _, opt := range opts { for _, opt := range opts {
...@@ -88,48 +141,44 @@ func (h *tunHandler) Handle(conn net.Conn) { ...@@ -88,48 +141,44 @@ func (h *tunHandler) Handle(conn net.Conn) {
defer os.Exit(0) defer os.Exit(0)
defer conn.Close() defer conn.Close()
uc, ok := conn.(net.PacketConn) laddr, raddr := h.options.Node.Addr, h.options.Node.Remote
if !ok { var pc net.PacketConn
log.Log("[tun] wrong connection type, must be PacketConn") var err error
return if h.options.TCPMode {
if raddr != "" {
pc, err = tcpraw.Dial("tcp", raddr)
} else {
pc, err = tcpraw.Listen("tcp", laddr)
}
} else {
addr, _ := net.ResolveUDPAddr("udp", laddr)
pc, err = net.ListenUDP("udp", addr)
} }
tc, err := h.createTun()
if err != nil { if err != nil {
log.Logf("[tun] %s create tun: %v", conn.LocalAddr(), err) log.Logf("[tun] %s: %v", conn.LocalAddr(), err)
return return
} }
defer tc.Close()
addrs, _ := h.ifce.Addrs() if len(h.options.Users) > 0 && h.options.Users[0] != nil {
log.Logf("[tun] %s - %s: name: %s, mtu: %d, addrs: %s", passwd, _ := h.options.Users[0].Password()
tc.LocalAddr(), conn.LocalAddr(), h.ifce.Name, h.ifce.MTU, addrs) cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
var raddr net.Addr
if h.raddr != "" {
raddr, err = net.ResolveUDPAddr("udp", h.raddr)
if err != nil { if err != nil {
log.Logf("[tun] %s - %s remote addr: %v", tc.LocalAddr(), conn.LocalAddr(), err) log.Logf("[tun] %s - %s cipher: %v", conn.LocalAddr(), pc.LocalAddr(), err)
return return
} }
pc = cipher.PacketConn(pc)
} }
if len(h.options.Users) > 0 && h.options.Users[0] != nil { var ra net.Addr
passwd, _ := h.options.Users[0].Password() if raddr != "" {
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd) ra, err = net.ResolveUDPAddr("udp", raddr)
if err != nil { if err != nil {
log.Logf("[tun] %s - %s cipher: %v", tc.LocalAddr(), conn.LocalAddr(), err) log.Logf("[tun] %s - %s: remote addr: %v", conn.LocalAddr(), pc.LocalAddr(), err)
return return
} }
uc = cipher.PacketConn(uc)
} }
h.transportTun(tc, uc, raddr) h.transportTun(conn, pc, ra)
}
func (h *tunHandler) createTun() (conn net.Conn, err error) {
conn, h.ifce, err = createTun(h.options.TunConfig)
return
} }
func (h *tunHandler) transportTun(tun net.Conn, conn net.PacketConn, raddr net.Addr) error { func (h *tunHandler) transportTun(tun net.Conn, conn net.PacketConn, raddr net.Addr) error {
...@@ -294,56 +343,68 @@ func (h *tunHandler) transportTun(tun net.Conn, conn net.PacketConn, raddr net.A ...@@ -294,56 +343,68 @@ func (h *tunHandler) transportTun(tun net.Conn, conn net.PacketConn, raddr net.A
return err return err
} }
type TunListenConfig struct { var mEtherTypes = map[waterutil.Ethertype]string{
TCP bool waterutil.IPv4: "ip",
RemoteAddr string waterutil.ARP: "arp",
waterutil.RARP: "rarp",
waterutil.IPv6: "ip6",
} }
type tunListener struct { func etherType(et waterutil.Ethertype) string {
if s, ok := mEtherTypes[et]; ok {
return s
}
return fmt.Sprintf("unknown(%v)", et)
}
type TapConfig struct {
Name string
Addr string
MTU int
Routes []string
Gateway string
}
type tapRouteKey [6]byte
func hwAddrToTapRouteKey(addr net.HardwareAddr) (key tapRouteKey) {
copy(key[:], addr)
return
}
type tapListener struct {
addr net.Addr addr net.Addr
conns chan net.Conn conns chan net.Conn
closed chan struct{} closed chan struct{}
config TunListenConfig config TapConfig
} }
// TunListener creates a listener for tun tunnel. // TapListener creates a listener for tap tunnel.
func TunListener(addr string, cfg TunListenConfig) (Listener, error) { func TapListener(cfg TapConfig) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
threads := 1 threads := 1
ln := &tunListener{ ln := &tapListener{
addr: laddr,
conns: make(chan net.Conn, threads), conns: make(chan net.Conn, threads),
closed: make(chan struct{}), closed: make(chan struct{}),
config: cfg, config: cfg,
} }
for i := 0; i < threads; i++ { for i := 0; i < threads; i++ {
var conn net.Conn conn, ifce, err := createTap(cfg)
if cfg.TCP {
var c *tcpraw.TCPConn
if cfg.RemoteAddr != "" {
c, err = tcpraw.Dial("tcp", cfg.RemoteAddr)
} else {
c, err = tcpraw.Listen("tcp", addr)
}
conn = &rawTCPConn{c}
} else {
conn, err = net.ListenUDP("udp", laddr)
}
if err != nil { if err != nil {
return nil, err return nil, err
} }
ln.addr = conn.LocalAddr()
addrs, _ := ifce.Addrs()
log.Logf("[tap] %s: name: %s, mac: %s, mtu: %d, addrs: %s",
conn.LocalAddr(), ifce.Name, ifce.HardwareAddr, ifce.MTU, addrs)
ln.conns <- conn ln.conns <- conn
} }
return ln, nil return ln, nil
} }
func (l *tunListener) Accept() (net.Conn, error) { func (l *tapListener) Accept() (net.Conn, error) {
select { select {
case conn := <-l.conns: case conn := <-l.conns:
return conn, nil return conn, nil
...@@ -353,11 +414,11 @@ func (l *tunListener) Accept() (net.Conn, error) { ...@@ -353,11 +414,11 @@ func (l *tunListener) Accept() (net.Conn, error) {
return nil, errors.New("accept on closed listener") return nil, errors.New("accept on closed listener")
} }
func (l *tunListener) Addr() net.Addr { func (l *tapListener) Addr() net.Addr {
return l.addr return l.addr
} }
func (l *tunListener) Close() error { func (l *tapListener) Close() error {
select { select {
case <-l.closed: case <-l.closed:
return errors.New("listener has been closed") return errors.New("listener has been closed")
...@@ -367,46 +428,14 @@ func (l *tunListener) Close() error { ...@@ -367,46 +428,14 @@ func (l *tunListener) Close() error {
return nil return nil
} }
var mEtherTypes = map[waterutil.Ethertype]string{
waterutil.IPv4: "ip",
waterutil.ARP: "arp",
waterutil.RARP: "rarp",
waterutil.IPv6: "ip6",
}
func etherType(et waterutil.Ethertype) string {
if s, ok := mEtherTypes[et]; ok {
return s
}
return fmt.Sprintf("unknown(%v)", et)
}
type TapConfig struct {
Name string
Addr string
MTU int
Routes []string
Gateway string
}
type tapRouteKey [6]byte
func hwAddrToTapRouteKey(addr net.HardwareAddr) (key tapRouteKey) {
copy(key[:], addr)
return
}
type tapHandler struct { type tapHandler struct {
raddr string
options *HandlerOptions options *HandlerOptions
ifce *net.Interface
routes sync.Map routes sync.Map
} }
// TapHandler creates a handler for tap tunnel. // TapHandler creates a handler for tap tunnel.
func TapHandler(raddr string, opts ...HandlerOption) Handler { func TapHandler(opts ...HandlerOption) Handler {
h := &tapHandler{ h := &tapHandler{
raddr: raddr,
options: &HandlerOptions{}, options: &HandlerOptions{},
} }
for _, opt := range opts { for _, opt := range opts {
...@@ -429,49 +458,44 @@ func (h *tapHandler) Handle(conn net.Conn) { ...@@ -429,49 +458,44 @@ func (h *tapHandler) Handle(conn net.Conn) {
defer os.Exit(0) defer os.Exit(0)
defer conn.Close() defer conn.Close()
uc, ok := conn.(net.PacketConn) laddr, raddr := h.options.Node.Addr, h.options.Node.Remote
if !ok { var pc net.PacketConn
log.Log("[tap] wrong connection type, must be PacketConn") var err error
return if h.options.TCPMode {
if raddr != "" {
pc, err = tcpraw.Dial("tcp", raddr)
} else {
pc, err = tcpraw.Listen("tcp", laddr)
}
} else {
addr, _ := net.ResolveUDPAddr("udp", laddr)
pc, err = net.ListenUDP("udp", addr)
} }
tc, err := h.createTap()
if err != nil { if err != nil {
log.Logf("[tap] %s create tap: %v", conn.LocalAddr(), err) log.Logf("[tap] %s: %v", conn.LocalAddr(), err)
return return
} }
defer tc.Close()
addrs, _ := h.ifce.Addrs() if len(h.options.Users) > 0 && h.options.Users[0] != nil {
log.Logf("[tap] %s - %s: name: %s, mac: %s, mtu: %d, addrs: %s", passwd, _ := h.options.Users[0].Password()
tc.LocalAddr(), conn.LocalAddr(), cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
h.ifce.Name, h.ifce.HardwareAddr, h.ifce.MTU, addrs)
var raddr net.Addr
if h.raddr != "" {
raddr, err = net.ResolveUDPAddr("udp", h.raddr)
if err != nil { if err != nil {
log.Logf("[tap] %s - %s remote addr: %v", tc.LocalAddr(), conn.LocalAddr(), err) log.Logf("[tap] %s - %s cipher: %v", conn.LocalAddr(), pc.LocalAddr(), err)
return return
} }
pc = cipher.PacketConn(pc)
} }
if len(h.options.Users) > 0 && h.options.Users[0] != nil { var ra net.Addr
passwd, _ := h.options.Users[0].Password() if raddr != "" {
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd) ra, err = net.ResolveUDPAddr("udp", raddr)
if err != nil { if err != nil {
log.Logf("[tap] %s - %s cipher: %v", tc.LocalAddr(), conn.LocalAddr(), err) log.Logf("[tap] %s - %s: remote addr: %v", conn.LocalAddr(), pc.LocalAddr(), err)
return return
} }
uc = cipher.PacketConn(uc)
} }
h.transportTap(tc, uc, raddr) h.transportTap(conn, pc, ra)
}
func (h *tapHandler) createTap() (conn net.Conn, err error) {
conn, h.ifce, err = createTap(h.options.TapConfig)
return
} }
func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.Addr) error { func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.Addr) error {
...@@ -549,12 +573,6 @@ func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.A ...@@ -549,12 +573,6 @@ func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.A
dst := waterutil.MACDestination(b[:n]) dst := waterutil.MACDestination(b[:n])
eType := etherType(waterutil.MACEthertype(b[:n])) eType := etherType(waterutil.MACEthertype(b[:n]))
// ignore the frame send by myself
if bytes.Equal(src, h.ifce.HardwareAddr) {
log.Logf("[tap] %s -> %s %s %d ignored", src, dst, eType, n)
return nil
}
if Debug { if Debug {
log.Logf("[tap] %s -> %s %s %d", src, dst, eType, n) log.Logf("[tap] %s -> %s %s %d", src, dst, eType, n)
} }
...@@ -615,79 +633,6 @@ func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.A ...@@ -615,79 +633,6 @@ func (h *tapHandler) transportTap(tap net.Conn, conn net.PacketConn, raddr net.A
return err return err
} }
type TapListenConfig struct {
TCP bool
RemoteAddr string
}
type tapListener struct {
addr net.Addr
conns chan net.Conn
closed chan struct{}
config TapListenConfig
}
// TapListener creates a listener for tap tunnel.
func TapListener(addr string, cfg TapListenConfig) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
threads := 1
ln := &tapListener{
addr: laddr,
conns: make(chan net.Conn, threads),
closed: make(chan struct{}),
config: cfg,
}
for i := 0; i < threads; i++ {
var conn net.Conn
if cfg.TCP {
var c *tcpraw.TCPConn
if cfg.RemoteAddr != "" {
c, err = tcpraw.Dial("tcp", cfg.RemoteAddr)
} else {
c, err = tcpraw.Listen("tcp", addr)
}
conn = &rawTCPConn{c}
} else {
conn, err = net.ListenUDP("udp", laddr)
}
if err != nil {
return nil, err
}
ln.conns <- conn
}
return ln, nil
}
func (l *tapListener) Accept() (net.Conn, error) {
select {
case conn := <-l.conns:
return conn, nil
case <-l.closed:
}
return nil, errors.New("accept on closed listener")
}
func (l *tapListener) Addr() net.Addr {
return l.addr
}
func (l *tapListener) Close() error {
select {
case <-l.closed:
return errors.New("listener has been closed")
default:
close(l.closed)
}
return nil
}
type tunTapConn struct { type tunTapConn struct {
ifce *water.Interface ifce *water.Interface
addr net.Addr addr net.Addr
...@@ -725,24 +670,6 @@ func (c *tunTapConn) SetWriteDeadline(t time.Time) error { ...@@ -725,24 +670,6 @@ func (c *tunTapConn) SetWriteDeadline(t time.Time) error {
return &net.OpError{Op: "set", Net: "tuntap", Source: nil, Addr: nil, Err: errors.New("deadline not supported")} return &net.OpError{Op: "set", Net: "tuntap", Source: nil, Addr: nil, Err: errors.New("deadline not supported")}
} }
type rawTCPConn struct {
*tcpraw.TCPConn
}
func (c *rawTCPConn) Read(b []byte) (n int, err error) {
err = &net.OpError{Op: "read", Net: "rawtcp", Source: nil, Addr: nil, Err: errors.New("read not supported")}
return
}
func (c *rawTCPConn) Write(b []byte) (n int, err error) {
err = &net.OpError{Op: "write", Net: "rawtcp", Source: nil, Addr: nil, Err: errors.New("write not supported")}
return
}
func (c *rawTCPConn) RemoteAddr() net.Addr {
return &net.IPAddr{}
}
func IsIPv6Multicast(addr net.HardwareAddr) bool { func IsIPv6Multicast(addr net.HardwareAddr) bool {
return addr[0] == 0x33 && addr[1] == 0x33 return addr[0] == 0x33 && addr[1] == 0x33
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment