mirror
/
gost-mirror
mirror of https://github.com/ginuerzh/gost
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

tuntap: code refactor

pull/507/head
ginuerzh 7 years ago
parent
47d5b72b92
commit
7eea9b3ad7
3 changed files with 170 additions and 258 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 45
      cmd/gost/route.go
  2. 16
      handler.go
  3. 367
      tuntap.go

45
cmd/gost/route.go
View File

@ -395,17 +395,23 @@ func (r *route) GenRouters() ([]router, error) {
case "ohttp":
ln, err = gost.ObfsHTTPListener(node.Addr)
case "tun":
ln, err = gost.TunListener(node.Addr,
gost.TunListenConfig{
TCP: node.GetBool("tcp"),
RemoteAddr: node.Remote,
})
cfg := gost.TunConfig{
Name: node.Get("name"),
Addr: node.Get("net"),
MTU: node.GetInt("mtu"),
Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
ln, err = gost.TunListener(cfg)
case "tap":
ln, err = gost.TapListener(node.Addr,
gost.TapListenConfig{
TCP: node.GetBool("tcp"),
RemoteAddr: node.Remote,
})
cfg := gost.TapConfig{
Name: node.Get("name"),
Addr: node.Get("net"),
MTU: node.GetInt("mtu"),
Routes: strings.Split(node.Get("route"), ","),
Gateway: node.Get("gw"),
}
ln, err = gost.TapListener(cfg)
default:
ln, err = gost.TCPListener(node.Addr)
}
@ -444,23 +450,9 @@ func (r *route) GenRouters() ([]router, error) {
case "sni":
handler = gost.SNIHandler()
case "tun":
cfg := gost.TunConfig{
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))
handler = gost.TunHandler()
case "tap":
cfg := gost.TapConfig{
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))
handler = gost.TapHandler()
default:
// start from 2.5, if remote is not empty, then we assume that it is a forward tunnel.
if node.Remote != "" {
@ -507,6 +499,7 @@ func (r *route) GenRouters() ([]router, error) {
gost.KnockingHandlerOption(node.Get("knock")),
gost.NodeHandlerOption(node),
gost.IPsHandlerOption(ips),
gost.TCPModeHandlerOption(node.GetBool("tcp")),
)
rt := router{

16
handler.go
View File

@ -40,8 +40,7 @@ type HandlerOptions struct {
Node Node
Host string
IPs []string
TunConfig TunConfig
TapConfig TapConfig
TCPMode bool
}
// HandlerOption allows a common way to set handler options.
@ -197,17 +196,10 @@ func IPsHandlerOption(ips []string) HandlerOption {
}
}
// TunConfigHandlerOption sets the config for tun device.
func TunConfigHandlerOption(cfg TunConfig) HandlerOption {
// TCPModeHandlerOption sets the tcp mode for tun/tap device.
func TCPModeHandlerOption(b bool) HandlerOption {
return func(opts *HandlerOptions) {
opts.TunConfig = cfg
}
}
// TapConfigHandlerOption sets the config for tap device.
func TapConfigHandlerOption(cfg TapConfig) HandlerOption {
return func(opts *HandlerOptions) {
opts.TapConfig = cfg
opts.TCPMode = b
}
}

367
tuntap.go
View File

@ -1,7 +1,6 @@
package gost
import (
"bytes"
"errors"
"fmt"
"io"
@ -55,17 +54,71 @@ func ipToTunRouteKey(ip net.IP) (key tunRouteKey) {
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 {
raddr string
options *HandlerOptions
ifce *net.Interface
routes sync.Map
}
// TunHandler creates a handler for tun tunnel.
func TunHandler(raddr string, opts ...HandlerOption) Handler {
func TunHandler(opts ...HandlerOption) Handler {
h := &tunHandler{
raddr: raddr,
options: &HandlerOptions{},
}
for _, opt := range opts {
@ -88,48 +141,44 @@ func (h *tunHandler) Handle(conn net.Conn) {
defer os.Exit(0)
defer conn.Close()
uc, ok := conn.(net.PacketConn)
if !ok {
log.Log("[tun] wrong connection type, must be PacketConn")
return
laddr, raddr := h.options.Node.Addr, h.options.Node.Remote
var pc net.PacketConn
var err error
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 {
log.Logf("[tun] %s create tun: %v", conn.LocalAddr(), err)
log.Logf("[tun] %s: %v", conn.LocalAddr(), err)
return
}
defer tc.Close()
addrs, _ := h.ifce.Addrs()
log.Logf("[tun] %s - %s: name: %s, mtu: %d, addrs: %s",
tc.LocalAddr(), conn.LocalAddr(), h.ifce.Name, h.ifce.MTU, addrs)
var raddr net.Addr
if h.raddr != "" {
raddr, err = net.ResolveUDPAddr("udp", h.raddr)
if len(h.options.Users) > 0 && h.options.Users[0] != nil {
passwd, _ := h.options.Users[0].Password()
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
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
}
pc = cipher.PacketConn(pc)
}
if len(h.options.Users) > 0 && h.options.Users[0] != nil {
passwd, _ := h.options.Users[0].Password()
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
var ra net.Addr
if raddr != "" {
ra, err = net.ResolveUDPAddr("udp", raddr)
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
}
uc = cipher.PacketConn(uc)
}
h.transportTun(tc, uc, raddr)
}
func (h *tunHandler) createTun() (conn net.Conn, err error) {
conn, h.ifce, err = createTun(h.options.TunConfig)
return
h.transportTun(conn, pc, ra)
}
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
return err
}
type TunListenConfig struct {
TCP bool
RemoteAddr string
var mEtherTypes = map[waterutil.Ethertype]string{
waterutil.IPv4: "ip",
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
conns chan net.Conn
closed chan struct{}
config TunListenConfig
config TapConfig
}
// TunListener creates a listener for tun tunnel.
func TunListener(addr string, cfg TunListenConfig) (Listener, error) {
laddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
// TapListener creates a listener for tap tunnel.
func TapListener(cfg TapConfig) (Listener, error) {
threads := 1
ln := &tunListener{
addr: laddr,
ln := &tapListener{
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)
}
conn, ifce, err := createTap(cfg)
if err != nil {
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
}
return ln, nil
}
func (l *tunListener) Accept() (net.Conn, error) {
func (l *tapListener) Accept() (net.Conn, error) {
select {
case conn := <-l.conns:
return conn, nil
@ -353,11 +414,11 @@ func (l *tunListener) Accept() (net.Conn, error) {
return nil, errors.New("accept on closed listener")
}
func (l *tunListener) Addr() net.Addr {
func (l *tapListener) Addr() net.Addr {
return l.addr
}
func (l *tunListener) Close() error {
func (l *tapListener) Close() error {
select {
case <-l.closed:
return errors.New("listener has been closed")
@ -367,46 +428,14 @@ func (l *tunListener) Close() error {
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 {
raddr string
options *HandlerOptions
ifce *net.Interface
routes sync.Map
}
// TapHandler creates a handler for tap tunnel.
func TapHandler(raddr string, opts ...HandlerOption) Handler {
func TapHandler(opts ...HandlerOption) Handler {
h := &tapHandler{
raddr: raddr,
options: &HandlerOptions{},
}
for _, opt := range opts {
@ -429,49 +458,44 @@ func (h *tapHandler) Handle(conn net.Conn) {
defer os.Exit(0)
defer conn.Close()
uc, ok := conn.(net.PacketConn)
if !ok {
log.Log("[tap] wrong connection type, must be PacketConn")
return
laddr, raddr := h.options.Node.Addr, h.options.Node.Remote
var pc net.PacketConn
var err error
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 {
log.Logf("[tap] %s create tap: %v", conn.LocalAddr(), err)
log.Logf("[tap] %s: %v", conn.LocalAddr(), err)
return
}
defer tc.Close()
addrs, _ := h.ifce.Addrs()
log.Logf("[tap] %s - %s: name: %s, mac: %s, mtu: %d, addrs: %s",
tc.LocalAddr(), conn.LocalAddr(),
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 len(h.options.Users) > 0 && h.options.Users[0] != nil {
passwd, _ := h.options.Users[0].Password()
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
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
}
pc = cipher.PacketConn(pc)
}
if len(h.options.Users) > 0 && h.options.Users[0] != nil {
passwd, _ := h.options.Users[0].Password()
cipher, err := core.PickCipher(h.options.Users[0].Username(), nil, passwd)
var ra net.Addr
if raddr != "" {
ra, err = net.ResolveUDPAddr("udp", raddr)
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
}
uc = cipher.PacketConn(uc)
}
h.transportTap(tc, uc, raddr)
}
func (h *tapHandler) createTap() (conn net.Conn, err error) {
conn, h.ifce, err = createTap(h.options.TapConfig)
return
h.transportTap(conn, pc, ra)
}
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
dst := waterutil.MACDestination(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 {
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
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 {
ifce *water.Interface
addr net.Addr
@ -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")}
}
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 {
return addr[0] == 0x33 && addr[1] == 0x33
}

Write Preview
Loading…
Cancel
Save