bughz/glider
1
0
Fork 0
mirror of https://github.com/nadoo/glider.git synced 2025-02-23 01:15:41 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

log: show proxy info in log, via PROXY

Browse Source
This commit is contained in:
nadoo 2019-09-18 22:08:48 +08:00
parent edcb21236a
commit d6d706b5ee
17 changed files with 124 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
dns/client.go
View File

@ -73,14 +73,14 @@ func (c *Client) Exchange(reqBytes []byte, clientAddr string, preferTCP bool) ([
}
}
dnsServer, network, respBytes, err := c.exchange(req.Question.QNAME, reqBytes, preferTCP)
dnsServer, network, dialerAddr, respBytes, err := c.exchange(req.Question.QNAME, reqBytes, preferTCP)
if err != nil {
return nil, err
}
if req.Question.QTYPE != QTypeA && req.Question.QTYPE != QTypeAAAA {
log.F("[dns] %s <-> %s(%s), type: %d, %s",
clientAddr, dnsServer, network, req.Question.QTYPE, req.Question.QNAME)
log.F("[dns] %s <-> %s(%s) via %s, type: %d, %s",
clientAddr, dnsServer, network, dialerAddr, req.Question.QTYPE, req.Question.QNAME)
return respBytes, nil
}
@ -116,14 +116,14 @@ func (c *Client) Exchange(reqBytes []byte, clientAddr string, preferTCP bool) ([
c.cache.Put(getKey(resp.Question), respBytes, ttl)
}
log.F("[dns] %s <-> %s(%s), type: %d, %s: %s",
clientAddr, dnsServer, network, resp.Question.QTYPE, resp.Question.QNAME, strings.Join(ips, ","))
log.F("[dns] %s <-> %s(%s) via %s, type: %d, %s: %s",
clientAddr, dnsServer, network, dialerAddr, resp.Question.QTYPE, resp.Question.QNAME, strings.Join(ips, ","))
return respBytes, nil
}
// exchange choose a upstream dns server based on qname, communicate with it on the network.
func (c *Client) exchange(qname string, reqBytes []byte, preferTCP bool) (server, network string, respBytes []byte, err error) {
func (c *Client) exchange(qname string, reqBytes []byte, preferTCP bool) (server, network, dialerAddr string, respBytes []byte, err error) {
// use tcp to connect upstream server default
network = "tcp"
dialer := c.proxy.NextDialer(qname + ":53")
@ -167,7 +167,7 @@ func (c *Client) exchange(qname string, reqBytes []byte, preferTCP bool) (server
log.F("[dns] failed to exchange with server %v: %v", server, err)
}
return server, network, respBytes, err
return server, network, dialer.Addr(), respBytes, err
}
// exchangeTCP exchange with server over tcp.

4
dns/server.go
View File

@ -22,8 +22,8 @@ type Server struct {
}
// NewServer returns a new dns server.
func NewServer(addr string, proxy proxy.Proxy, config *Config) (*Server, error) {
c, err := NewClient(proxy, config)
func NewServer(addr string, p proxy.Proxy, config *Config) (*Server, error) {
c, err := NewClient(p, config)
s := &Server{
addr: addr,
Client: c,

34
proxy/http/http.go
View File

@ -21,7 +21,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// HTTP struct
// HTTP struct.
type HTTP struct {
dialer proxy.Dialer
proxy proxy.Proxy
@ -36,7 +36,7 @@ func init() {
proxy.RegisterServer("http", NewHTTPServer)
}
// NewHTTP returns a http proxy
// NewHTTP returns a http proxy.
func NewHTTP(s string, d proxy.Dialer, p proxy.Proxy) (*HTTP, error) {
u, err := url.Parse(s)
if err != nil {
@ -65,17 +65,17 @@ func NewHTTP(s string, d proxy.Dialer, p proxy.Proxy) (*HTTP, error) {
return h, nil
}
// NewHTTPDialer returns a http proxy dialer
// NewHTTPDialer returns a http proxy dialer.
func NewHTTPDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
return NewHTTP(s, d, nil)
}
// NewHTTPServer returns a http proxy server
// NewHTTPServer returns a http proxy server.
func NewHTTPServer(s string, p proxy.Proxy) (proxy.Server, error) {
return NewHTTP(s, nil, p)
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *HTTP) ListenAndServe() {
l, err := net.Listen("tcp", s.addr)
if err != nil {
@ -97,7 +97,7 @@ func (s *HTTP) ListenAndServe() {
}
}
// Serve .
// Serve serves a connection.
func (s *HTTP) Serve(c net.Conn) {
defer c.Close()
@ -147,7 +147,7 @@ func (s *HTTP) Serve(c net.Conn) {
rc, p, err := s.proxy.Dial("tcp", tgt)
if err != nil {
fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto)
log.F("[http] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
log.F("[http] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), tgt, p, err)
return
}
defer rc.Close()
@ -165,7 +165,7 @@ func (s *HTTP) Serve(c net.Conn) {
// send request to remote server
rc.Write(reqBuf.Bytes())
// copy the left request bytes to remote server. eg. length specificed or chunked body.
// copy the left request bytes to remote server. eg. length specificed or chunked body
go func() {
if _, err := reqR.Peek(1); err == nil {
io.Copy(rc, reqR)
@ -183,7 +183,7 @@ func (s *HTTP) Serve(c net.Conn) {
respHeader, err := respTP.ReadMIMEHeader()
if err != nil {
log.F("[http] read header error:%s", err)
log.F("[http] %s <-> %s via %s, read header error: %v", c.RemoteAddr(), tgt, p, err)
return
}
@ -194,7 +194,7 @@ func (s *HTTP) Serve(c net.Conn) {
writeFirstLine(&respBuf, proto, code, status)
writeHeaders(&respBuf, respHeader)
log.F("[http] %s <-> %s, %s", c.RemoteAddr(), tgt, p)
log.F("[http] %s <-> %s via %s", c.RemoteAddr(), tgt, p)
c.Write(respBuf.Bytes())
io.Copy(c, respR)
@ -206,24 +206,24 @@ func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
if err != nil {
c.Write([]byte(proto))
c.Write([]byte(" 502 ERROR\r\n\r\n"))
log.F("[http] %s <-> %s [c], error in dial: %v", c.RemoteAddr(), requestURI, err)
log.F("[http] %s <-> %s [c] via %s, error in dial: %v", c.RemoteAddr(), requestURI, p, err)
return
}
c.Write([]byte("HTTP/1.1 200 Connection established\r\n\r\n"))
log.F("[http] %s <-> %s [c], %s", c.RemoteAddr(), requestURI, p)
log.F("[http] %s <-> %s [c] via %s", c.RemoteAddr(), requestURI, p)
_, _, err = conn.Relay(c, rc)
if err != nil {
if err, ok := err.(net.Error); ok && err.Timeout() {
return // ignore i/o timeout
}
log.F("relay error: %v", err)
log.F("[http] relay error: %v", err)
}
}
// Addr returns forwarder's address
// Addr returns forwarder's address.
func (s *HTTP) Addr() string {
if s.addr == "" {
return s.dialer.Addr()
@ -231,7 +231,7 @@ func (s *HTTP) Addr() string {
return s.addr
}
// Dial connects to the address addr on the network net via the proxy
// Dial connects to the address addr on the network net via the proxy.
func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
rc, err := s.dialer.Dial(network, s.addr)
if err != nil {
@ -273,12 +273,12 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
return nil, errors.New("[http] can not connect remote address: " + addr + ". error code: " + code)
}
// DialUDP connects to the given address via the proxy
// DialUDP connects to the given address via the proxy.
func (s *HTTP) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
return nil, nil, errors.New("http client does not support udp")
}
// parseFirstLine parses "GET /foo HTTP/1.1" OR "HTTP/1.1 200 OK" into its three parts
// parseFirstLine parses "GET /foo HTTP/1.1" OR "HTTP/1.1 200 OK" into its three parts.
func parseFirstLine(tp *textproto.Reader) (r1, r2, r3 string, ok bool) {
line, err := tp.ReadLine()
if err != nil {

25
proxy/kcp/kcp.go
View File

@ -15,7 +15,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// KCP struct
// KCP struct.
type KCP struct {
dialer proxy.Dialer
proxy proxy.Proxy
@ -36,7 +36,7 @@ func init() {
proxy.RegisterServer("kcp", NewKCPServer)
}
// NewKCP returns a kcp proxy struct
// NewKCP returns a kcp proxy struct.
func NewKCP(s string, d proxy.Dialer, p proxy.Proxy) (*KCP, error) {
u, err := url.Parse(s)
if err != nil {
@ -124,12 +124,12 @@ func NewKCP(s string, d proxy.Dialer, p proxy.Proxy) (*KCP, error) {
return k, nil
}
// NewKCPDialer returns a kcp proxy dialer
// NewKCPDialer returns a kcp proxy dialer.
func NewKCPDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
return NewKCP(s, d, nil)
}
// NewKCPServer returns a kcp proxy server
// NewKCPServer returns a kcp proxy server.
func NewKCPServer(s string, p proxy.Proxy) (proxy.Server, error) {
transport := strings.Split(s, ",")
@ -152,7 +152,7 @@ func NewKCPServer(s string, p proxy.Proxy) (proxy.Server, error) {
return k, nil
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *KCP) ListenAndServe() {
l, err := kcp.ListenWithOptions(s.addr, s.block, s.dataShards, s.parityShards)
if err != nil {
@ -182,7 +182,7 @@ func (s *KCP) ListenAndServe() {
}
}
// Serve serves requests
// Serve serves connections.
func (s *KCP) Serve(c net.Conn) {
// we know the internal server will close the connection after serve
// defer c.Close()
@ -192,10 +192,15 @@ func (s *KCP) Serve(c net.Conn) {
}
}
// Addr returns forwarder's address
func (s *KCP) Addr() string { return s.addr }
// Addr returns forwarder's address.
func (s *KCP) 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
// Dial connects to the address addr on the network net via the proxy.
func (s *KCP) Dial(network, addr string) (net.Conn, error) {
// NOTE: kcp uses udp, we should dial remote server directly here
c, err := kcp.DialWithOptions(s.addr, s.block, s.dataShards, s.parityShards)
@ -219,7 +224,7 @@ func (s *KCP) Dial(network, addr string) (net.Conn, error) {
return c, err
}
// DialUDP connects to the given address via the proxy
// DialUDP connects to the given address via the proxy.
func (s *KCP) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
return nil, nil, errors.New("kcp client does not support udp now")
}

44
proxy/mixed/mixed.go
View File

@ -25,8 +25,8 @@ var httpMethods = [...][]byte{
[]byte("PATCH"),
}
// MixedProxy struct
type MixedProxy struct {
// Mixed struct.
type Mixed struct {
proxy proxy.Proxy
addr string
@ -35,18 +35,18 @@ type MixedProxy struct {
}
func init() {
proxy.RegisterServer("mixed", NewMixedProxyServer)
proxy.RegisterServer("mixed", NewMixedServer)
}
// NewMixedProxy returns a mixed proxy
func NewMixedProxy(s string, p proxy.Proxy) (*MixedProxy, error) {
// NewMixed returns a mixed proxy.
func NewMixed(s string, p proxy.Proxy) (*Mixed, error) {
u, err := url.Parse(s)
if err != nil {
log.F("parse err: %s", err)
return nil, err
}
m := &MixedProxy{
m := &Mixed{
proxy: p,
addr: u.Host,
}
@ -57,22 +57,22 @@ func NewMixedProxy(s string, p proxy.Proxy) (*MixedProxy, error) {
return m, nil
}
// NewMixedProxyServer returns a mixed proxy server
func NewMixedProxyServer(s string, p proxy.Proxy) (proxy.Server, error) {
return NewMixedProxy(s, p)
// NewMixedServer returns a mixed server.
func NewMixedServer(s string, p proxy.Proxy) (proxy.Server, error) {
return NewMixed(s, p)
}
// ListenAndServe .
func (p *MixedProxy) ListenAndServe() {
go p.socks5.ListenAndServeUDP()
// ListenAndServe listens on server's addr and serves connections.
func (m *Mixed) ListenAndServe() {
go m.socks5.ListenAndServeUDP()
l, err := net.Listen("tcp", p.addr)
l, err := net.Listen("tcp", m.addr)
if err != nil {
log.F("[mixed] failed to listen on %s: %v", p.addr, err)
log.F("[mixed] failed to listen on %s: %v", m.addr, err)
return
}
log.F("[mixed] listening TCP on %s", p.addr)
log.F("[mixed] listening TCP on %s", m.addr)
for {
c, err := l.Accept()
@ -81,12 +81,12 @@ func (p *MixedProxy) ListenAndServe() {
continue
}
go p.Serve(c)
go m.Serve(c)
}
}
// Serve .
func (p *MixedProxy) Serve(c net.Conn) {
// Serve serves connections.
func (m *Mixed) Serve(c net.Conn) {
defer c.Close()
if c, ok := c.(*net.TCPConn); ok {
@ -95,7 +95,7 @@ func (p *MixedProxy) Serve(c net.Conn) {
cc := conn.NewConn(c)
if p.socks5 != nil {
if m.socks5 != nil {
head, err := cc.Peek(1)
if err != nil {
// log.F("[mixed] socks5 peek error: %s", err)
@ -104,12 +104,12 @@ func (p *MixedProxy) Serve(c net.Conn) {
// check socks5, client send socksversion: 5 as the first byte
if head[0] == socks5.Version {
p.socks5.Serve(cc)
m.socks5.Serve(cc)
return
}
}
if p.http != nil {
if m.http != nil {
head, err := cc.Peek(8)
if err != nil {
log.F("[mixed] http peek error: %s", err)
@ -118,7 +118,7 @@ func (p *MixedProxy) Serve(c net.Conn) {
for _, method := range httpMethods {
if bytes.HasPrefix(head, method) {
p.http.Serve(cc)
m.http.Serve(cc)
return
}
}

22
proxy/obfs/obfs.go
View File

@ -10,7 +10,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// Obfs struct
// Obfs struct.
type Obfs struct {
dialer proxy.Dialer
addr string
@ -27,7 +27,7 @@ func init() {
proxy.RegisterDialer("simple-obfs", NewObfsDialer)
}
// NewObfs returns a proxy struct
// NewObfs returns a proxy struct.
func NewObfs(s string, d proxy.Dialer) (*Obfs, error) {
u, err := url.Parse(s)
if err != nil {
@ -81,15 +81,20 @@ func NewObfs(s string, d proxy.Dialer) (*Obfs, error) {
return p, nil
}
// NewObfsDialer returns a proxy dialer
// NewObfsDialer returns a proxy dialer.
func NewObfsDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
return NewObfs(s, dialer)
}
// Addr returns forwarder's address
func (s *Obfs) Addr() string { return s.addr }
// Addr returns forwarder's address.
func (s *Obfs) 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
// Dial connects to the address addr on the network net via the proxy.
func (s *Obfs) Dial(network, addr string) (net.Conn, error) {
c, err := s.dialer.Dial("tcp", s.addr)
if err != nil {
@ -97,11 +102,10 @@ func (s *Obfs) Dial(network, addr string) (net.Conn, error) {
return nil, err
}
cc, e := s.obfsConn(c)
return cc, e
return s.obfsConn(c)
}
// DialUDP connects to the given address via the proxy
// DialUDP connects to the given address via the proxy.
func (s *Obfs) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
return nil, nil, errors.New("obfs client does not support udp now")
}

10
proxy/redir/redir_linux.go
View File

@ -23,7 +23,7 @@ const (
IP6T_SO_ORIGINAL_DST = 80
)
// RedirProxy struct
// RedirProxy struct.
type RedirProxy struct {
proxy proxy.Proxy
addr string
@ -63,7 +63,7 @@ func NewRedir6Server(s string, p proxy.Proxy) (proxy.Server, error) {
return NewRedirProxy(s, p, true)
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *RedirProxy) ListenAndServe() {
l, err := net.Listen("tcp", s.addr)
if err != nil {
@ -84,7 +84,7 @@ func (s *RedirProxy) ListenAndServe() {
}
}
// Serve .
// Serve serves connections.
func (s *RedirProxy) Serve(c net.Conn) {
defer c.Close()
@ -106,12 +106,12 @@ func (s *RedirProxy) Serve(c net.Conn) {
rc, p, err := s.proxy.Dial("tcp", tgt.String())
if err != nil {
log.F("[redir] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
log.F("[redir] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), tgt, p, err)
return
}
defer rc.Close()
log.F("[redir] %s <-> %s, %s", c.RemoteAddr(), tgt, p)
log.F("[redir] %s <-> %s via %s", c.RemoteAddr(), tgt, p)
_, _, err = conn.Relay(c, rc)
if err != nil {

2
proxy/reject/reject.go
View File

@ -15,7 +15,7 @@ func init() {
proxy.RegisterDialer("reject", NewRejectDialer)
}
// NewReject returns a reject proxy, reject://
// NewReject returns a reject proxy, reject://.
func NewReject(s string, d proxy.Dialer) (*Reject, error) {
return &Reject{}, nil
}

4
proxy/socks5/socks5.go
View File

@ -135,12 +135,12 @@ func (s *Socks5) Serve(c net.Conn) {
rc, p, err := s.proxy.Dial("tcp", tgt.String())
if err != nil {
log.F("[socks5] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
log.F("[socks5] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), tgt, p, err)
return
}
defer rc.Close()
log.F("[socks5] %s <-> %s, %s", c.RemoteAddr(), tgt, p)
log.F("[socks5] %s <-> %s via %s", c.RemoteAddr(), tgt, p)
_, _, err = conn.Relay(c, rc)
if err != nil {

4
proxy/ss/ss.go
View File

@ -151,12 +151,12 @@ func (s *SS) Serve(c net.Conn) {
rc, err := dialer.Dial(network, tgt.String())
if err != nil {
log.F("[ss] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, dialer.Addr())
log.F("[ss] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), tgt, dialer.Addr(), err)
return
}
defer rc.Close()
log.F("[ss] %s <-> %s, %s", c.RemoteAddr(), tgt, dialer.Addr())
log.F("[ss] %s <-> %s via %s", c.RemoteAddr(), tgt, dialer.Addr())
_, _, err = conn.Relay(c, rc)
if err != nil {

2
proxy/ssr/ssr.go
View File

@ -17,7 +17,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// SSR .
// SSR struct.
type SSR struct {
dialer proxy.Dialer
addr string

14
proxy/tcptun/tcptun.go
View File

@ -10,7 +10,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// TCPTun struct
// TCPTun struct.
type TCPTun struct {
proxy proxy.Proxy
addr string
@ -22,7 +22,7 @@ func init() {
proxy.RegisterServer("tcptun", NewTCPTunServer)
}
// NewTCPTun returns a tcptun proxy
// NewTCPTun returns a tcptun proxy.
func NewTCPTun(s string, p proxy.Proxy) (*TCPTun, error) {
u, err := url.Parse(s)
if err != nil {
@ -42,12 +42,12 @@ func NewTCPTun(s string, p proxy.Proxy) (*TCPTun, error) {
return t, nil
}
// NewTCPTunServer returns a udp tunnel server
// NewTCPTunServer returns a udp tunnel server.
func NewTCPTunServer(s string, p proxy.Proxy) (proxy.Server, error) {
return NewTCPTun(s, p)
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *TCPTun) ListenAndServe() {
l, err := net.Listen("tcp", s.addr)
if err != nil {
@ -68,7 +68,7 @@ func (s *TCPTun) ListenAndServe() {
}
}
// Serve .
// Serve serves a connection.
func (s *TCPTun) Serve(c net.Conn) {
defer c.Close()
@ -78,12 +78,12 @@ func (s *TCPTun) Serve(c net.Conn) {
rc, p, err := s.proxy.Dial("tcp", s.raddr)
if err != nil {
log.F("[tcptun] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), s.addr, err, p)
log.F("[tcptun] %s <-> %s via %s, error in dial: %v", c.RemoteAddr(), s.addr, p, err)
return
}
defer rc.Close()
log.F("[tcptun] %s <-> %s, %s", c.RemoteAddr(), s.raddr, p)
log.F("[tcptun] %s <-> %s via %s", c.RemoteAddr(), s.raddr, p)
_, _, err = conn.Relay(c, rc)
if err != nil {

25
proxy/tls/tls.go
View File

@ -11,7 +11,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// TLS struct
// TLS struct.
type TLS struct {
dialer proxy.Dialer
proxy proxy.Proxy
@ -34,7 +34,7 @@ func init() {
proxy.RegisterServer("tls", NewTLSServer)
}
// NewTLS returns a tls proxy struct
// NewTLS returns a tls proxy struct.
func NewTLS(s string, d proxy.Dialer, p proxy.Proxy) (*TLS, error) {
u, err := url.Parse(s)
if err != nil {
@ -70,7 +70,7 @@ func NewTLS(s string, d proxy.Dialer, p proxy.Proxy) (*TLS, error) {
return t, nil
}
// NewTLSDialer returns a tls proxy dialer
// NewTLSDialer returns a tls proxy dialer.
func NewTLSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
p, err := NewTLS(s, d, nil)
if err != nil {
@ -87,7 +87,7 @@ func NewTLSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
return p, err
}
// NewTLSServer returns a tls transport layer before the real server
// NewTLSServer returns a tls transport layer before the real server.
func NewTLSServer(s string, p proxy.Proxy) (proxy.Server, error) {
transport := strings.Split(s, ",")
@ -121,7 +121,7 @@ func NewTLSServer(s string, p proxy.Proxy) (proxy.Server, error) {
return t, nil
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *TLS) ListenAndServe() {
l, err := net.Listen("tcp", s.addr)
if err != nil {
@ -143,7 +143,7 @@ func (s *TLS) ListenAndServe() {
}
}
// Serve serves requests
// Serve serves a connection.
func (s *TLS) Serve(c net.Conn) {
// we know the internal server will close the connection after serve
// defer c.Close()
@ -154,10 +154,15 @@ func (s *TLS) Serve(c net.Conn) {
}
}
// Addr returns forwarder's address
func (s *TLS) Addr() string { return s.addr }
// Addr returns forwarder's address.
func (s *TLS) 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
// Dial connects to the address addr on the network net via the proxy.
func (s *TLS) Dial(network, addr string) (net.Conn, error) {
cc, err := s.dialer.Dial("tcp", s.addr)
if err != nil {
@ -170,7 +175,7 @@ func (s *TLS) Dial(network, addr string) (net.Conn, error) {
return c, err
}
// DialUDP connects to the given address via the proxy
// DialUDP connects to the given address via the proxy.
func (s *TLS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
return nil, nil, errors.New("tls client does not support udp now")
}

4
proxy/tproxy/tproxy_linux.go
View File

@ -17,7 +17,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// TProxy struct
// TProxy struct.
type TProxy struct {
proxy proxy.Proxy
addr string
@ -50,7 +50,7 @@ func NewTProxyServer(s string, p proxy.Proxy) (proxy.Server, error) {
return NewTProxy(s, p)
}
// ListenAndServe .
// ListenAndServe listens on server's addr and serves connections.
func (s *TProxy) ListenAndServe() {
// go s.ListenAndServeTCP()
s.ListenAndServeUDP()

20
proxy/unix/unix.go
View File

@ -11,7 +11,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// Unix domain socket struct
// Unix domain socket struct.
type Unix struct {
dialer proxy.Dialer
proxy proxy.Proxy
@ -25,7 +25,7 @@ func init() {
proxy.RegisterDialer("unix", NewUnixDialer)
}
// NewUnix returns unix fomain socket proxy
// NewUnix returns unix fomain socket proxy.
func NewUnix(s string, d proxy.Dialer, p proxy.Proxy) (*Unix, error) {
u, err := url.Parse(s)
if err != nil {
@ -42,12 +42,12 @@ func NewUnix(s string, d proxy.Dialer, p proxy.Proxy) (*Unix, error) {
return unix, nil
}
// NewUnixDialer returns a unix domain socket dialer
// 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
// NewUnixServer returns a unix domain socket server.
func NewUnixServer(s string, p proxy.Proxy) (proxy.Server, error) {
transport := strings.Split(s, ",")
@ -70,7 +70,7 @@ func NewUnixServer(s string, p proxy.Proxy) (proxy.Server, error) {
return unix, nil
}
// ListenAndServe serves requests
// ListenAndServe serves requests.
func (s *Unix) ListenAndServe() {
os.Remove(s.addr)
l, err := net.Listen("unix", s.addr)
@ -80,12 +80,12 @@ func (s *Unix) ListenAndServe() {
}
defer l.Close()
log.F("[uinx] listening on %s", s.addr)
log.F("[unix] listening on %s", s.addr)
for {
c, err := l.Accept()
if err != nil {
log.F("[uinx] failed to accept: %v", err)
log.F("[unix] failed to accept: %v", err)
continue
}
@ -93,7 +93,7 @@ func (s *Unix) ListenAndServe() {
}
}
// Serve serves requests
// Serve serves requests.
func (s *Unix) Serve(c net.Conn) {
// we know the internal server will close the connection after serve
// defer c.Close()
@ -103,7 +103,7 @@ func (s *Unix) Serve(c net.Conn) {
}
}
// Addr returns forwarder's address
// Addr returns forwarder's address.
func (s *Unix) Addr() string {
if s.addr == "" {
return s.dialer.Addr()
@ -117,7 +117,7 @@ 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
// 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")
}

2
proxy/uottun/uottun.go
View File

@ -99,7 +99,7 @@ func (s *UoTTun) ListenAndServe() {
continue
}
log.F("[uottun] %s <-> %s, %s", clientAddr, s.raddr, p)
log.F("[uottun] %s <-> %s via %s", clientAddr, s.raddr, p)
}
}

4
proxy/vmess/vmess.go
View File

@ -10,7 +10,7 @@ import (
"github.com/nadoo/glider/proxy"
)
// VMess .
// VMess struct.
type VMess struct {
dialer proxy.Dialer
addr string
@ -78,7 +78,7 @@ func NewVMessDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
return NewVMess(s, dialer)
}
// Addr returns forwarder's address
// Addr returns forwarder's address.
func (s *VMess) Addr() string {
if s.addr == "" {
return s.dialer.Addr()