diff --git a/core/chain.go b/core/chain.go index 1b605db7..f1b758a0 100644 --- a/core/chain.go +++ b/core/chain.go @@ -4,13 +4,12 @@ import ( "context" "errors" "fmt" - "github.com/wencaiwulue/kubevpn/util" "net" ) var ( - // ErrEmptyChain is an error that implies the chain is empty. - ErrEmptyChain = errors.New("empty chain") + // ErrorEmptyChain is an error that implies the chain is empty. + ErrorEmptyChain = errors.New("empty chain") ) // Chain is a proxy chain that holds a list of proxy node groups. @@ -58,18 +57,7 @@ func (c *Chain) dial(ctx context.Context, network, address string) (net.Conn, er } if c.IsEmpty() { - switch network { - case "udp", "udp4", "udp6": - if address == "" { - return net.ListenUDP(network, nil) - } - default: - } - d := &net.Dialer{ - Timeout: util.DialTimeout, - // LocalAddr: laddr, // TODO: optional local address - } - return d.DialContext(ctx, network, ipAddr) + return nil, ErrorEmptyChain } conn, err := c.getConn(ctx) @@ -115,7 +103,7 @@ func (c *Chain) Conn() (conn net.Conn, err error) { // getConn obtains a connection to the last node of the chain. func (c *Chain) getConn(_ context.Context) (conn net.Conn, err error) { if c.IsEmpty() { - err = ErrEmptyChain + err = ErrorEmptyChain return } cc, err := c.Node().Client.Dial(c.Node().Addr) diff --git a/core/handler.go b/core/handler.go index 2d4615ec..2075baaf 100644 --- a/core/handler.go +++ b/core/handler.go @@ -14,7 +14,7 @@ type Handler interface { // HandlerOptions describes the options for Handler. type HandlerOptions struct { Chain *Chain - Node Node + Node *Node IPRoutes []tun.IPRoute } @@ -29,7 +29,7 @@ func ChainHandlerOption(chain *Chain) HandlerOption { } // NodeHandlerOption set the server node for server handler. -func NodeHandlerOption(node Node) HandlerOption { +func NodeHandlerOption(node *Node) HandlerOption { return func(opts *HandlerOptions) { opts.Node = node } diff --git a/core/node.go b/core/node.go index f30e3737..290bf7d9 100644 --- a/core/node.go +++ b/core/node.go @@ -2,15 +2,13 @@ package core import ( "errors" - "fmt" "net/url" "strconv" "strings" ) var ( - // ErrInvalidNode is an error that implies the node is invalid. - ErrInvalidNode = errors.New("invalid node") + ErrorInvalidNode = errors.New("invalid node") ) // Node is a proxy node, mainly used to construct a proxy chain. @@ -18,29 +16,27 @@ type Node struct { Addr string Protocol string Transport string - Remote string // remote address, used by tcp/udp port forwarding - url *url.URL // raw url + Remote string // remote address, used by tcp/udp port forwarding Values url.Values Client *Client } // ParseNode parses the node info. // The proxy node string pattern is [scheme://][user:pass@host]:port. -func ParseNode(s string) (node Node, err error) { +func ParseNode(s string) (node *Node, err error) { s = strings.TrimSpace(s) if s == "" { - return Node{}, ErrInvalidNode + return nil, ErrorInvalidNode } u, err := url.Parse(s) if err != nil { return } - node = Node{ + node = &Node{ Addr: u.Host, Remote: strings.Trim(u.EscapedPath(), "/"), Values: u.Query(), - url: u, } u.RawQuery = "" @@ -54,7 +50,7 @@ func ParseNode(s string) (node Node, err error) { node.Protocol = "tcp" node.Transport = "tcp" default: - return Node{}, ErrInvalidNode + return nil, ErrorInvalidNode } return } @@ -64,25 +60,8 @@ func (node *Node) Get(key string) string { return node.Values.Get(key) } -// GetBool converts node parameter value to bool. -func (node *Node) GetBool(key string) bool { - b, _ := strconv.ParseBool(node.Values.Get(key)) - return b -} - // GetInt converts node parameter value to int. func (node *Node) GetInt(key string) int { n, _ := strconv.Atoi(node.Get(key)) return n } - -func (node Node) String() string { - var scheme string - if node.url != nil { - scheme = node.url.Scheme - } - if scheme == "" { - scheme = fmt.Sprintf("%s+%s", node.Protocol, node.Transport) - } - return fmt.Sprintf("%s://%s", scheme, node.Addr) -} diff --git a/core/server.go b/core/server.go index ed66ace9..d35d8c87 100644 --- a/core/server.go +++ b/core/server.go @@ -2,7 +2,6 @@ package core import ( "context" - "github.com/wencaiwulue/kubevpn/tun" "k8s.io/client-go/util/retry" "net" "time" @@ -12,7 +11,7 @@ import ( // Server is a proxy server. type Server struct { - Listener tun.Listener + Listener net.Listener Handler Handler } diff --git a/core/tcp.go b/core/tcp.go index cecdc941..c1e72300 100644 --- a/core/tcp.go +++ b/core/tcp.go @@ -3,7 +3,6 @@ package core import ( "crypto/tls" "github.com/wencaiwulue/kubevpn/tlsconfig" - "github.com/wencaiwulue/kubevpn/tun" "github.com/wencaiwulue/kubevpn/util" "net" ) @@ -26,7 +25,7 @@ type tcpListener struct { } // TCPListener creates a Listener for TCP proxy server. -func TCPListener(addr string) (tun.Listener, error) { +func TCPListener(addr string) (net.Listener, error) { laddr, err := net.ResolveTCPAddr("tcp", addr) if err != nil { return nil, err diff --git a/dns/dns_linux.go b/dns/dns_linux.go index f51dbf33..b0024a61 100644 --- a/dns/dns_linux.go +++ b/dns/dns_linux.go @@ -18,7 +18,7 @@ func SetupDNS(config *miekgdns.ClientConfig) error { } cmd := exec.Command("systemd-resolve", []string{ "--set-dns", - config, + config.Servers[0], "--interface", tunName, "--set-domain=" + config.Search[0], diff --git a/main.go b/main.go index 85913eda..27aa2f52 100644 --- a/main.go +++ b/main.go @@ -1,14 +1,20 @@ package main import ( + log "github.com/sirupsen/logrus" "github.com/wencaiwulue/kubevpn/cmd" "github.com/wencaiwulue/kubevpn/util" + "net/http" + _ "net/http/pprof" ) func main() { if !util.IsAdmin() { util.RunWithElevated() } else { + go func() { + log.Println(http.ListenAndServe("localhost:6060", nil)) + }() _ = cmd.RootCmd.Execute() } } diff --git a/pkg/route.go b/pkg/route.go index e76190ab..10b04b63 100644 --- a/pkg/route.go +++ b/pkg/route.go @@ -36,15 +36,13 @@ func parseChainNode(ns string) (*core.Node, error) { Connector: core.UDPOverTCPTunnelConnector(), Transporter: core.TCPTransporter(), } - return &node, nil + return node, nil } func (r *Route) GenRouters() ([]router, error) { chain, err := r.parseChain() - if err != nil { - if !errors.Is(err, core.ErrInvalidNode) { - return nil, err - } + if err != nil && !errors.Is(err, core.ErrorInvalidNode) { + return nil, err } routers := make([]router, 0, len(r.ServeNodes)) @@ -62,23 +60,20 @@ func (r *Route) GenRouters() ([]router, error) { } } - var ln tun.Listener + var ln net.Listener switch node.Transport { case "tcp": tcpListener, _ := core.TCPListener(node.Addr) ln = tls.NewListener(tcpListener, tlsconfig.TlsconfigServer) case "tun": - cfg := tun.Config{ + config := tun.Config{ Name: node.Get("name"), Addr: node.Get("net"), MTU: node.GetInt("mtu"), Routes: tunRoutes, Gateway: node.Get("gw"), } - ln, err = tun.TunListener(cfg) - //default: - // innerLn, _ := core.TCPListener(node.Addr) - // ln = tls.NewListener(innerLn, tlsconfig.TlsconfigServer) + ln, err = tun.Listener(config) } if err != nil { return nil, err @@ -108,12 +103,12 @@ func (r *Route) GenRouters() ([]router, error) { } type router struct { - node core.Node + node *core.Node server *core.Server } func (r *router) Serve(ctx context.Context) error { - log.Debugf("%s on %s", r.node.String(), r.server.Addr()) + log.Debugf("%s on %s", r.node.Protocol, r.server.Addr()) return r.server.Serve(ctx, r.server.Handler) } diff --git a/tun/tun.go b/tun/tun.go index 253a6988..c9621f09 100644 --- a/tun/tun.go +++ b/tun/tun.go @@ -25,15 +25,15 @@ type tunListener struct { config Config } -// TunListener creates a listener for tun tunnel. -func TunListener(cfg Config) (Listener, error) { +// Listener TunListener creates a listener for tun tunnel. +func Listener(config Config) (net.Listener, error) { ln := &tunListener{ conns: make(chan net.Conn, 1), closed: make(chan struct{}), - config: cfg, + config: config, } - conn, ifce, err := createTun(cfg) + conn, ifce, err := createTun(config) if err != nil { return nil, err } @@ -48,11 +48,6 @@ func TunListener(cfg Config) (Listener, error) { return ln, nil } -// Listener is a proxy server listener, just like a net.Listener. -type Listener interface { - net.Listener -} - func (l *tunListener) Accept() (net.Conn, error) { select { case conn := <-l.conns: