From 4a72e7900290b9af9fc432ea2e22b0d5f44d1569 Mon Sep 17 00:00:00 2001 From: nadoo <287492+nadoo@users.noreply.github.com> Date: Thu, 28 Jun 2018 23:20:04 +0800 Subject: [PATCH] tls: allow InsecureSkipVerify --- dns/dns.go | 48 ++++++++++++++++++------------------ main.go | 2 +- proxy/http/http.go | 24 +++++++++--------- proxy/mixed/mixed.go | 10 ++++---- proxy/redir/redir_linux.go | 14 +++++------ proxy/socks5/packet.go | 2 +- proxy/socks5/socks5.go | 38 ++++++++++++++-------------- proxy/ss/ss.go | 43 ++++++++++++++++---------------- proxy/ssr/ssr.go | 12 ++++----- proxy/tcptun/tcptun.go | 2 +- proxy/tls/tls.go | 6 ++--- proxy/tproxy/tproxy_linux.go | 18 +++++++------- proxy/udptun/udptun.go | 12 ++++----- proxy/uottun/uottun.go | 12 ++++----- proxy/v2ray/v2ray.go | 2 +- rule.go | 2 +- strategy.go | 8 +++--- 17 files changed, 127 insertions(+), 128 deletions(-) diff --git a/dns/dns.go b/dns/dns.go index bb4f71e..86d919f 100644 --- a/dns/dns.go +++ b/dns/dns.go @@ -178,25 +178,25 @@ func (s *DNS) ListenAndServe() { func (s *DNS) ListenAndServeUDP() { c, err := net.ListenPacket("udp", s.addr) if err != nil { - log.F("proxy-dns failed to listen on %s, error: %v", s.addr, err) + log.F("[dns] failed to listen on %s, error: %v", s.addr, err) return } defer c.Close() - log.F("proxy-dns listening UDP on %s", s.addr) + log.F("[dns] listening UDP on %s", s.addr) for { b := make([]byte, UDPMaxLen) n, clientAddr, err := c.ReadFrom(b) if err != nil { - log.F("proxy-dns local read error: %v", err) + log.F("[dns] local read error: %v", err) continue } reqLen := uint16(n) // TODO: check here if reqLen <= HeaderLen+2 { - log.F("proxy-dns not enough data") + log.F("[dns] not enough data") continue } @@ -204,13 +204,13 @@ func (s *DNS) ListenAndServeUDP() { go func() { _, respMsg, err := s.Exchange(reqLen, reqMsg, clientAddr.String()) if err != nil { - log.F("proxy-dns error in exchange: %s", err) + log.F("[dns] error in exchange: %s", err) return } _, err = c.WriteTo(respMsg, clientAddr) if err != nil { - log.F("proxy-dns error in local write: %s", err) + log.F("[dns] error in local write: %s", err) return } @@ -222,16 +222,16 @@ func (s *DNS) ListenAndServeUDP() { func (s *DNS) ListenAndServeTCP() { l, err := net.Listen("tcp", s.addr) if err != nil { - log.F("proxy-dns-tcp error: %v", err) + log.F("[dns]-tcp error: %v", err) return } - log.F("proxy-dns-tcp listening TCP on %s", s.addr) + log.F("[dns]-tcp listening TCP on %s", s.addr) for { c, err := l.Accept() if err != nil { - log.F("proxy-dns-tcp error: failed to accept: %v", err) + log.F("[dns]-tcp error: failed to accept: %v", err) continue } go s.ServeTCP(c) @@ -248,35 +248,35 @@ func (s *DNS) ServeTCP(c net.Conn) { var reqLen uint16 if err := binary.Read(c, binary.BigEndian, &reqLen); err != nil { - log.F("proxy-dns-tcp failed to get request length: %v", err) + log.F("[dns]-tcp failed to get request length: %v", err) return } // TODO: check here if reqLen <= HeaderLen+2 { - log.F("proxy-dns-tcp not enough data") + log.F("[dns]-tcp not enough data") return } reqMsg := make([]byte, reqLen) _, err := io.ReadFull(c, reqMsg) if err != nil { - log.F("proxy-dns-tcp error in read reqMsg %s", err) + log.F("[dns]-tcp error in read reqMsg %s", err) return } respLen, respMsg, err := s.Exchange(reqLen, reqMsg, c.RemoteAddr().String()) if err != nil { - log.F("proxy-dns-tcp error in exchange: %s", err) + log.F("[dns]-tcp error in exchange: %s", err) return } if err := binary.Write(c, binary.BigEndian, respLen); err != nil { - log.F("proxy-dns-tcp error in local write respLen: %s", err) + log.F("[dns]-tcp error in local write respLen: %s", err) return } if err := binary.Write(c, binary.BigEndian, respMsg); err != nil { - log.F("proxy-dns-tcp error in local write respMsg: %s", err) + log.F("[dns]-tcp error in local write respMsg: %s", err) return } } @@ -287,7 +287,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1 // fmt.Printf("\ndns req len %d:\n%s\n", reqLen, hex.Dump(reqMsg[:])) query, err := parseQuestion(reqMsg) if err != nil { - log.F("proxy-dns error in parseQuestion reqMsg: %s", err) + log.F("[dns] error in parseQuestion reqMsg: %s", err) return } @@ -295,29 +295,29 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1 rc, err := s.dialer.NextDialer(query.QNAME+":53").Dial("tcp", dnsServer) if err != nil { - log.F("proxy-dns failed to connect to server %v: %v", dnsServer, err) + log.F("[dns] failed to connect to server %v: %v", dnsServer, err) return } defer rc.Close() if err = binary.Write(rc, binary.BigEndian, reqLen); err != nil { - log.F("proxy-dns failed to write req length: %v", err) + log.F("[dns] failed to write req length: %v", err) return } if err = binary.Write(rc, binary.BigEndian, reqMsg); err != nil { - log.F("proxy-dns failed to write req message: %v", err) + log.F("[dns] failed to write req message: %v", err) return } if err = binary.Read(rc, binary.BigEndian, &respLen); err != nil { - log.F("proxy-dns failed to read response length: %v", err) + log.F("[dns] failed to read response length: %v", err) return } respMsg = make([]byte, respLen) _, err = io.ReadFull(rc, respMsg) if err != nil { - log.F("proxy-dns error in read respMsg %s\n", err) + log.F("[dns] error in read respMsg %s\n", err) return } @@ -326,7 +326,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1 var ip string respReq, err := parseQuestion(respMsg) if err != nil { - log.F("proxy-dns error in parseQuestion respMsg: %s", err) + log.F("[dns] error in parseQuestion respMsg: %s", err) return } @@ -336,7 +336,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1 var answers []*RR answers, err = parseAnswers(respMsg[respReq.Offset:]) if err != nil { - log.F("proxy-dns error in parseAnswers: %s", err) + log.F("[dns] error in parseAnswers: %s", err) return } @@ -352,7 +352,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1 } - log.F("proxy-dns %s <-> %s, type: %d, %s: %s", addr, dnsServer, query.QTYPE, query.QNAME, ip) + log.F("[dns] %s <-> %s, type: %d, %s: %s", addr, dnsServer, query.QTYPE, query.QNAME, ip) return } diff --git a/main.go b/main.go index c9e6496..d315207 100644 --- a/main.go +++ b/main.go @@ -18,7 +18,7 @@ import ( _ "github.com/nadoo/glider/proxy/ss" _ "github.com/nadoo/glider/proxy/ssr" _ "github.com/nadoo/glider/proxy/tcptun" - // _ "github.com/nadoo/glider/proxy/tls" + _ "github.com/nadoo/glider/proxy/tls" _ "github.com/nadoo/glider/proxy/udptun" _ "github.com/nadoo/glider/proxy/uottun" // _ "github.com/nadoo/glider/proxy/v2ray" diff --git a/proxy/http/http.go b/proxy/http/http.go index edf5a5a..06e31ff 100644 --- a/proxy/http/http.go +++ b/proxy/http/http.go @@ -83,7 +83,7 @@ func (s *HTTP) ListenAndServe() { for { c, err := l.Accept() if err != nil { - log.F("proxy-http failed to accept: %v", err) + log.F("[http] failed to accept: %v", err) continue } @@ -123,7 +123,7 @@ func (s *HTTP) Serve(c net.Conn) { url, err := url.ParseRequestURI(requestURI) if err != nil { - log.F("proxy-http parse request url error: %s", err) + log.F("[http] parse request url error: %s", err) return } @@ -135,7 +135,7 @@ func (s *HTTP) Serve(c net.Conn) { rc, err := s.dialer.Dial("tcp", tgt) if err != nil { fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto) - log.F("proxy-http failed to dial: %v", err) + log.F("[http] failed to dial: %v", err) return } defer rc.Close() @@ -171,7 +171,7 @@ func (s *HTTP) Serve(c net.Conn) { respHeader, err := respTP.ReadMIMEHeader() if err != nil { - log.F("proxy-http read header error:%s", err) + log.F("[http] read header error:%s", err) return } @@ -182,7 +182,7 @@ func (s *HTTP) Serve(c net.Conn) { writeFirstLine(proto, code, status, &respBuf) writeHeaders(respHeader, &respBuf) - log.F("proxy-http %s <-> %s", c.RemoteAddr(), tgt) + log.F("[http] %s <-> %s", c.RemoteAddr(), tgt) c.Write(respBuf.Bytes()) io.Copy(c, respR) @@ -194,13 +194,13 @@ 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("proxy-http failed to dial: %v", err) + log.F("[http] failed to dial: %v", err) return } c.Write([]byte("HTTP/1.0 200 Connection established\r\n\r\n")) - log.F("proxy-http %s <-> %s [c]", c.RemoteAddr(), requestURI) + log.F("[http] %s <-> %s [c]", c.RemoteAddr(), requestURI) _, _, err = conn.Relay(c, rc) if err != nil { @@ -221,7 +221,7 @@ func (s *HTTP) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDia func (s *HTTP) Dial(network, addr string) (net.Conn, error) { rc, err := s.dialer.Dial(network, s.addr) if err != nil { - log.F("proxy-http dial to %s error: %s", s.addr, err) + log.F("[http] dial to %s error: %s", s.addr, err) return nil, err } @@ -246,12 +246,12 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, error) { if ok && code == "200" { return rc, err } else if code == "407" { - log.F("proxy-http authencation needed by proxy %s", s.addr) + log.F("[http] authencation needed by proxy %s", s.addr) } else if code == "405" { - log.F("proxy-http 'CONNECT' method not allowed by proxy %s", s.addr) + log.F("[http] 'CONNECT' method not allowed by proxy %s", s.addr) } - return nil, errors.New("proxy-http can not connect remote address: " + addr + ". error code: " + code) + return nil, errors.New("[http] can not connect remote address: " + addr + ". error code: " + code) } // DialUDP connects to the given address via the proxy. @@ -264,7 +264,7 @@ func parseFirstLine(tp *textproto.Reader) (r1, r2, r3 string, ok bool) { line, err := tp.ReadLine() // log.F("first line: %s", line) if err != nil { - log.F("proxy-http read first line error:%s", err) + log.F("[http] read first line error:%s", err) return } diff --git a/proxy/mixed/mixed.go b/proxy/mixed/mixed.go index f6f17d8..5780d8b 100644 --- a/proxy/mixed/mixed.go +++ b/proxy/mixed/mixed.go @@ -68,16 +68,16 @@ func (p *MixedProxy) ListenAndServe() { l, err := net.Listen("tcp", p.addr) if err != nil { - log.F("proxy-mixed failed to listen on %s: %v", p.addr, err) + log.F("[mixed] failed to listen on %s: %v", p.addr, err) return } - log.F("proxy-mixed listening TCP on %s", p.addr) + log.F("[mixed] listening TCP on %s", p.addr) for { c, err := l.Accept() if err != nil { - log.F("proxy-mixed failed to accept: %v", err) + log.F("[mixed] failed to accept: %v", err) continue } @@ -98,7 +98,7 @@ func (p *MixedProxy) Serve(c net.Conn) { if p.socks5 != nil { head, err := cc.Peek(1) if err != nil { - log.F("proxy-mixed peek error: %s", err) + log.F("[mixed] peek error: %s", err) return } @@ -112,7 +112,7 @@ func (p *MixedProxy) Serve(c net.Conn) { if p.http != nil { head, err := cc.Peek(8) if err != nil { - log.F("proxy-mixed peek error: %s", err) + log.F("[mixed] peek error: %s", err) return } diff --git a/proxy/redir/redir_linux.go b/proxy/redir/redir_linux.go index a0e971a..d1da12b 100644 --- a/proxy/redir/redir_linux.go +++ b/proxy/redir/redir_linux.go @@ -59,16 +59,16 @@ func NewRedirServer(s string, dialer proxy.Dialer) (proxy.Server, error) { func (s *RedirProxy) ListenAndServe() { l, err := net.Listen("tcp", s.addr) if err != nil { - log.F("proxy-redir failed to listen on %s: %v", s.addr, err) + log.F("[redir] failed to listen on %s: %v", s.addr, err) return } - log.F("proxy-redir listening TCP on %s", s.addr) + log.F("[redir] listening TCP on %s", s.addr) for { c, err := l.Accept() if err != nil { - log.F("proxy-redir failed to accept: %v", err) + log.F("[redir] failed to accept: %v", err) continue } @@ -81,25 +81,25 @@ func (s *RedirProxy) ListenAndServe() { tgt, err := getOrigDst(c, false) if err != nil { - log.F("proxy-redir failed to get target address: %v", err) + log.F("[redir] failed to get target address: %v", err) return } rc, err := s.dialer.Dial("tcp", tgt.String()) if err != nil { - log.F("proxy-redir failed to connect to target: %v", err) + log.F("[redir] failed to connect to target: %v", err) return } defer rc.Close() - log.F("proxy-redir %s <-> %s", c.RemoteAddr(), tgt) + log.F("[redir] %s <-> %s", c.RemoteAddr(), tgt) _, _, err = conn.Relay(c, rc) if err != nil { if err, ok := err.(net.Error); ok && err.Timeout() { return // ignore i/o timeout } - log.F("proxy-redir relay error: %v", err) + log.F("[redir] relay error: %v", err) } }() diff --git a/proxy/socks5/packet.go b/proxy/socks5/packet.go index 289323c..665a6c4 100644 --- a/proxy/socks5/packet.go +++ b/proxy/socks5/packet.go @@ -36,7 +36,7 @@ func NewPktConn(c net.PacketConn, writeAddr net.Addr, tgtAddr socks.Addr, tgtHea if err, ok := err.(net.Error); ok && err.Timeout() { continue } - log.F("proxy-socks5 dialudp udp associate end") + log.F("[socks5] dialudp udp associate end") return } }() diff --git a/proxy/socks5/socks5.go b/proxy/socks5/socks5.go index 2e9c784..95b0836 100644 --- a/proxy/socks5/socks5.go +++ b/proxy/socks5/socks5.go @@ -88,16 +88,16 @@ func (s *SOCKS5) ListenAndServe() { func (s *SOCKS5) ListenAndServeTCP() { l, err := net.Listen("tcp", s.addr) if err != nil { - log.F("proxy-socks5 failed to listen on %s: %v", s.addr, err) + log.F("[socks5] failed to listen on %s: %v", s.addr, err) return } - log.F("proxy-socks5 listening TCP on %s", s.addr) + log.F("[socks5] listening TCP on %s", s.addr) for { c, err := l.Accept() if err != nil { - log.F("proxy-socks5 failed to accept: %v", err) + log.F("[socks5] failed to accept: %v", err) continue } @@ -124,30 +124,30 @@ func (s *SOCKS5) ServeTCP(c net.Conn) { if err, ok := err.(net.Error); ok && err.Timeout() { continue } - // log.F("proxy-socks5 servetcp udp associate end") + // log.F("[socks5] servetcp udp associate end") return } } - log.F("proxy-socks5 failed to get target address: %v", err) + log.F("[socks5] failed to get target address: %v", err) return } rc, err := s.dialer.Dial("tcp", tgt.String()) if err != nil { - log.F("proxy-socks5 failed to connect to target: %v", err) + log.F("[socks5] failed to connect to target: %v", err) return } defer rc.Close() - log.F("proxy-socks5 %s <-> %s", c.RemoteAddr(), tgt) + log.F("[socks5] %s <-> %s", c.RemoteAddr(), tgt) _, _, err = conn.Relay(c, rc) if err != nil { if err, ok := err.(net.Error); ok && err.Timeout() { return // ignore i/o timeout } - log.F("proxy-socks5 relay error: %v", err) + log.F("[socks5] relay error: %v", err) } } @@ -155,12 +155,12 @@ func (s *SOCKS5) ServeTCP(c net.Conn) { func (s *SOCKS5) ListenAndServeUDP() { lc, err := net.ListenPacket("udp", s.addr) if err != nil { - log.F("proxy-socks5-udp failed to listen on %s: %v", s.addr, err) + log.F("[socks5-udp] failed to listen on %s: %v", s.addr, err) return } defer lc.Close() - log.F("proxy-socks5-udp listening UDP on %s", s.addr) + log.F("[socks5-udp] listening UDP on %s", s.addr) var nm sync.Map buf := make([]byte, conn.UDPBufSize) @@ -170,7 +170,7 @@ func (s *SOCKS5) ListenAndServeUDP() { n, raddr, err := c.ReadFrom(buf) if err != nil { - log.F("proxy-socks5-udp remote read error: %v", err) + log.F("[socks5-udp] remote read error: %v", err) continue } @@ -178,13 +178,13 @@ func (s *SOCKS5) ListenAndServeUDP() { v, ok := nm.Load(raddr.String()) if !ok && v == nil { if c.tgtAddr == nil { - log.F("proxy-socks5-udp can not get target address, not a valid request") + log.F("[socks5-udp] can not get target address, not a valid request") continue } lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String()) if err != nil { - log.F("proxy-socks5-udp remote dial error: %v", err) + log.F("[socks5-udp] remote dial error: %v", err) continue } @@ -203,11 +203,11 @@ func (s *SOCKS5) ListenAndServeUDP() { _, err = pc.WriteTo(buf[:n], pc.writeAddr) if err != nil { - log.F("proxy-socks5-udp remote write error: %v", err) + log.F("[socks5-udp] remote write error: %v", err) continue } - log.F("proxy-socks5-udp %s <-> %s", raddr, c.tgtAddr) + log.F("[socks5-udp] %s <-> %s", raddr, c.tgtAddr) } } @@ -223,7 +223,7 @@ func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) { switch network { case "tcp", "tcp6", "tcp4": default: - return nil, errors.New("proxy-socks5: no support for connection type " + network) + return nil, errors.New("[socks5]: no support for connection type " + network) } c, err := s.dialer.Dial(network, s.addr) @@ -248,7 +248,7 @@ func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) { func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) { c, err := s.dialer.Dial("tcp", s.addr) if err != nil { - log.F("proxy-socks5 dialudp dial tcp to %s error: %s", s.addr, err) + log.F("[socks5] dialudp dial tcp to %s error: %s", s.addr, err) return nil, nil, err } @@ -276,7 +276,7 @@ func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.A rep := buf[1] if rep != 0 { - log.F("proxy-socks5 server reply: %d, not succeeded", rep) + log.F("[socks5] server reply: %d, not succeeded", rep) return nil, nil, errors.New("server connect failed") } @@ -287,7 +287,7 @@ func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.A pc, nextHop, err := s.dialer.DialUDP(network, uAddr.String()) if err != nil { - log.F("proxy-socks5 dialudp to %s error: %s", uAddr.String(), err) + log.F("[socks5] dialudp to %s error: %s", uAddr.String(), err) return nil, nil, err } diff --git a/proxy/ss/ss.go b/proxy/ss/ss.go index 0df4f46..145baec 100644 --- a/proxy/ss/ss.go +++ b/proxy/ss/ss.go @@ -46,7 +46,7 @@ func NewSS(s string, dialer proxy.Dialer) (*SS, error) { ciph, err := core.PickCipher(method, nil, pass) if err != nil { - log.Fatalf("proxy-ss PickCipher for '%s', error: %s", method, err) + log.Fatalf("[ss] PickCipher for '%s', error: %s", method, err) } p := &SS{ @@ -78,16 +78,16 @@ func (s *SS) ListenAndServe() { func (s *SS) ListenAndServeTCP() { l, err := net.Listen("tcp", s.addr) if err != nil { - log.F("proxy-ss failed to listen on %s: %v", s.addr, err) + log.F("[ss] failed to listen on %s: %v", s.addr, err) return } - log.F("proxy-ss listening TCP on %s", s.addr) + log.F("[ss] listening TCP on %s", s.addr) for { c, err := l.Accept() if err != nil { - log.F("proxy-ss failed to accept: %v", err) + log.F("[ss] failed to accept: %v", err) continue } go s.ServeTCP(c) @@ -106,7 +106,7 @@ func (s *SS) ServeTCP(c net.Conn) { tgt, err := socks.ReadAddr(c) if err != nil { - log.F("proxy-ss failed to get target address: %v", err) + log.F("[ss] failed to get target address: %v", err) return } @@ -115,17 +115,16 @@ func (s *SS) ServeTCP(c net.Conn) { // udp over tcp? uot := socks.UoT(tgt[0]) if uot && dialer.Addr() == "DIRECT" { - rc, err := net.ListenPacket("udp", "") if err != nil { - log.F("proxy-ss UDP remote listen error: %v", err) + log.F("[ss-uottun] UDP remote listen error: %v", err) } defer rc.Close() req := make([]byte, conn.UDPBufSize) n, err := c.Read(req) if err != nil { - log.F("proxy-ss error in ioutil.ReadAll: %s\n", err) + log.F("[ss-uottun] error in ioutil.ReadAll: %s\n", err) return } @@ -135,12 +134,12 @@ func (s *SS) ServeTCP(c net.Conn) { buf := make([]byte, conn.UDPBufSize) n, _, err = rc.ReadFrom(buf) if err != nil { - log.F("proxy-uottun read error: %v", err) + log.F("[ss-uottun] read error: %v", err) } c.Write(buf[:n]) - log.F("proxy-ss %s <-tcp-> %s - %s <-udp-> %s ", c.RemoteAddr(), c.LocalAddr(), rc.LocalAddr(), tgt) + log.F("[ss] %s <-tcp-> %s - %s <-udp-> %s ", c.RemoteAddr(), c.LocalAddr(), rc.LocalAddr(), tgt) return } @@ -152,19 +151,19 @@ func (s *SS) ServeTCP(c net.Conn) { rc, err := dialer.Dial(network, tgt.String()) if err != nil { - log.F("proxy-ss failed to connect to target: %v", err) + log.F("[ss] failed to connect to target: %v", err) return } defer rc.Close() - log.F("proxy-ss %s <-> %s", c.RemoteAddr(), tgt) + log.F("[ss] %s <-> %s", c.RemoteAddr(), tgt) _, _, err = conn.Relay(c, rc) if err != nil { if err, ok := err.(net.Error); ok && err.Timeout() { return // ignore i/o timeout } - log.F("proxy-ss relay error: %v", err) + log.F("[ss] relay error: %v", err) } } @@ -173,14 +172,14 @@ func (s *SS) ServeTCP(c net.Conn) { func (s *SS) ListenAndServeUDP() { lc, err := net.ListenPacket("udp", s.addr) if err != nil { - log.F("proxy-ss-udp failed to listen on %s: %v", s.addr, err) + log.F("[ss-udp] failed to listen on %s: %v", s.addr, err) return } defer lc.Close() lc = s.PacketConn(lc) - log.F("proxy-ss-udp listening UDP on %s", s.addr) + log.F("[ss-udp] listening UDP on %s", s.addr) var nm sync.Map buf := make([]byte, conn.UDPBufSize) @@ -190,7 +189,7 @@ func (s *SS) ListenAndServeUDP() { n, raddr, err := c.ReadFrom(buf) if err != nil { - log.F("proxy-ss-udp remote read error: %v", err) + log.F("[ss-udp] remote read error: %v", err) continue } @@ -199,7 +198,7 @@ func (s *SS) ListenAndServeUDP() { if !ok && v == nil { lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String()) if err != nil { - log.F("proxy-ss-udp remote dial error: %v", err) + log.F("[ss-udp] remote dial error: %v", err) continue } @@ -218,11 +217,11 @@ func (s *SS) ListenAndServeUDP() { _, err = pc.WriteTo(buf[:n], pc.writeAddr) if err != nil { - log.F("proxy-ss-udp remote write error: %v", err) + log.F("[ss-udp] remote write error: %v", err) continue } - log.F("proxy-ss-udp %s <-> %s", raddr, c.tgtAddr) + log.F("[ss-udp] %s <-> %s", raddr, c.tgtAddr) } } @@ -241,7 +240,7 @@ func (s *SS) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDiale func (s *SS) Dial(network, addr string) (net.Conn, error) { target := socks.ParseAddr(addr) if target == nil { - return nil, errors.New("proxy-ss unable to parse address: " + addr) + return nil, errors.New("[ss] unable to parse address: " + addr) } if network == "uot" { @@ -250,7 +249,7 @@ func (s *SS) Dial(network, addr string) (net.Conn, error) { c, err := s.dialer.Dial("tcp", s.addr) if err != nil { - log.F("proxy-ss dial to %s error: %s", s.addr, err) + log.F("[ss] dial to %s error: %s", s.addr, err) return nil, err } @@ -272,7 +271,7 @@ func (s *SS) Dial(network, addr string) (net.Conn, error) { func (s *SS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) { pc, nextHop, err := s.dialer.DialUDP(network, s.addr) if err != nil { - log.F("proxy-ss dialudp to %s error: %s", s.addr, err) + log.F("[ss] dialudp to %s error: %s", s.addr, err) return nil, nil, err } diff --git a/proxy/ssr/ssr.go b/proxy/ssr/ssr.go index 6f9b7b7..887746c 100644 --- a/proxy/ssr/ssr.go +++ b/proxy/ssr/ssr.go @@ -90,7 +90,7 @@ func (s *SSR) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDial func (s *SSR) Dial(network, addr string) (net.Conn, error) { target := socks.ParseAddr(addr) if target == nil { - return nil, errors.New("proxy-ssr unable to parse address: " + addr) + return nil, errors.New("[ssr] unable to parse address: " + addr) } cipher, err := shadowsocksr.NewStreamCipher(s.EncryptMethod, s.EncryptPassword) @@ -100,7 +100,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) { c, err := s.dialer.Dial("tcp", s.addr) if err != nil { - log.F("proxy-ssr dial to %s error: %s", s.addr, err) + log.F("[ssr] dial to %s error: %s", s.addr, err) return nil, err } @@ -110,7 +110,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) { ssrconn := shadowsocksr.NewSSTCPConn(c, cipher) if ssrconn.Conn == nil || ssrconn.RemoteAddr() == nil { - return nil, errors.New("proxy-ssr nil connection") + return nil, errors.New("[ssr] nil connection") } // should initialize obfs/protocol now @@ -119,7 +119,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) { ssrconn.IObfs = obfs.NewObfs(s.Obfs) if ssrconn.IObfs == nil { - return nil, errors.New("proxy-ssr unsupported obfs type: " + s.Obfs) + return nil, errors.New("[ssr] unsupported obfs type: " + s.Obfs) } obfsServerInfo := &ssr.ServerInfoForObfs{ @@ -132,7 +132,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) { ssrconn.IProtocol = protocol.NewProtocol(s.Protocol) if ssrconn.IProtocol == nil { - return nil, errors.New("proxy-ssr unsupported protocol type: " + s.Protocol) + return nil, errors.New("[ssr] unsupported protocol type: " + s.Protocol) } protocolServerInfo := &ssr.ServerInfoForObfs{ @@ -163,5 +163,5 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) { // DialUDP connects to the given address via the proxy. func (s *SSR) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) { - return nil, nil, errors.New("proxy-ssr udp not supported now") + return nil, nil, errors.New("[ssr] udp not supported now") } diff --git a/proxy/tcptun/tcptun.go b/proxy/tcptun/tcptun.go index f212219..2f2a6c7 100644 --- a/proxy/tcptun/tcptun.go +++ b/proxy/tcptun/tcptun.go @@ -79,7 +79,7 @@ func (s *TCPTun) ListenAndServe() { } defer rc.Close() - log.F("proxy-tcptun %s <-> %s", c.RemoteAddr(), s.raddr) + log.F("[tcptun] %s <-> %s", c.RemoteAddr(), s.raddr) _, _, err = conn.Relay(c, rc) if err != nil { diff --git a/proxy/tls/tls.go b/proxy/tls/tls.go index f36e812..ae3c9ac 100644 --- a/proxy/tls/tls.go +++ b/proxy/tls/tls.go @@ -63,13 +63,13 @@ func (s *TLS) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDial func (s *TLS) Dial(network, addr string) (net.Conn, error) { cc, err := s.dialer.Dial("tcp", s.addr) if err != nil { - log.F("proxy-tls dial to %s error: %s", s.addr, err) + log.F("[tls] dial to %s error: %s", s.addr, err) return nil, err } conf := &stdtls.Config{ - ServerName: s.serverName, - //InsecureSkipVerify: true, + ServerName: s.serverName, + InsecureSkipVerify: true, } c := stdtls.Client(cc, conf) diff --git a/proxy/tproxy/tproxy_linux.go b/proxy/tproxy/tproxy_linux.go index d4a4595..6398eb4 100644 --- a/proxy/tproxy/tproxy_linux.go +++ b/proxy/tproxy/tproxy_linux.go @@ -58,26 +58,26 @@ func (s *TProxy) ListenAndServe() { // ListenAndServeTCP . func (s *TProxy) ListenAndServeTCP() { - log.F("proxy-tproxy tcp mode not supported now, please use 'redir' instead") + log.F("[tproxy] tcp mode not supported now, please use 'redir' instead") } // ListenAndServeUDP . func (s *TProxy) ListenAndServeUDP() { laddr, err := net.ResolveUDPAddr("udp", s.addr) if err != nil { - log.F("proxy-tproxy failed to resolve addr %s: %v", s.addr, err) + log.F("[tproxy] failed to resolve addr %s: %v", s.addr, err) return } lc, err := net.ListenUDP("udp", laddr) if err != nil { - log.F("proxy-tproxy failed to listen on %s: %v", s.addr, err) + log.F("[tproxy] failed to listen on %s: %v", s.addr, err) return } fd, err := lc.File() if err != nil { - log.F("proxy-tproxy failed to get file descriptor: %v", err) + log.F("[tproxy] failed to get file descriptor: %v", err) return } defer fd.Close() @@ -85,13 +85,13 @@ func (s *TProxy) ListenAndServeUDP() { fileDescriptor := int(fd.Fd()) if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil { syscall.Close(fileDescriptor) - log.F("proxy-tproxy failed to set socket option IP_TRANSPARENT: %v", err) + log.F("[tproxy] failed to set socket option IP_TRANSPARENT: %v", err) return } if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1); err != nil { syscall.Close(fileDescriptor) - log.F("proxy-tproxy failed to set socket option IP_RECVORIGDSTADDR: %v", err) + log.F("[tproxy] failed to set socket option IP_RECVORIGDSTADDR: %v", err) return } @@ -100,15 +100,15 @@ func (s *TProxy) ListenAndServeUDP() { _, srcAddr, dstAddr, err := ReadFromUDP(lc, buf) if err != nil { if netErr, ok := err.(net.Error); ok && netErr.Temporary() { - log.F("proxy-tproxy temporary reading data error: %s", netErr) + log.F("[tproxy] temporary reading data error: %s", netErr) continue } - log.F("proxy-tproxy Unrecoverable error while reading data: %s", err) + log.F("[tproxy] Unrecoverable error while reading data: %s", err) continue } - log.F("proxy-tproxy Accepting UDP connection from %s with destination of %s", srcAddr.String(), dstAddr.String()) + log.F("[tproxy] Accepting UDP connection from %s with destination of %s", srcAddr.String(), dstAddr.String()) } diff --git a/proxy/udptun/udptun.go b/proxy/udptun/udptun.go index 36c15de..8fb72ff 100644 --- a/proxy/udptun/udptun.go +++ b/proxy/udptun/udptun.go @@ -53,12 +53,12 @@ func NewUDPTunServer(s string, dialer proxy.Dialer) (proxy.Server, error) { func (s *UDPTun) ListenAndServe() { c, err := net.ListenPacket("udp", s.addr) if err != nil { - log.F("proxy-udptun failed to listen on %s: %v", s.addr, err) + log.F("[udptun] failed to listen on %s: %v", s.addr, err) return } defer c.Close() - log.F("proxy-udptun listening UDP on %s", s.addr) + log.F("[udptun] listening UDP on %s", s.addr) var nm sync.Map buf := make([]byte, conn.UDPBufSize) @@ -66,7 +66,7 @@ func (s *UDPTun) ListenAndServe() { for { n, raddr, err := c.ReadFrom(buf) if err != nil { - log.F("proxy-udptun read error: %v", err) + log.F("[udptun] read error: %v", err) continue } @@ -78,7 +78,7 @@ func (s *UDPTun) ListenAndServe() { pc, writeAddr, err = s.dialer.DialUDP("udp", s.raddr) if err != nil { - log.F("proxy-udptun remote dial error: %v", err) + log.F("[udptun] remote dial error: %v", err) continue } @@ -96,11 +96,11 @@ func (s *UDPTun) ListenAndServe() { _, err = pc.WriteTo(buf[:n], writeAddr) if err != nil { - log.F("proxy-udptun remote write error: %v", err) + log.F("[udptun] remote write error: %v", err) continue } - log.F("proxy-udptun %s <-> %s", raddr, s.raddr) + log.F("[udptun] %s <-> %s", raddr, s.raddr) } } diff --git a/proxy/uottun/uottun.go b/proxy/uottun/uottun.go index b082a86..f43418c 100644 --- a/proxy/uottun/uottun.go +++ b/proxy/uottun/uottun.go @@ -53,25 +53,25 @@ func NewUoTTunServer(s string, dialer proxy.Dialer) (proxy.Server, error) { func (s *UoTTun) ListenAndServe() { c, err := net.ListenPacket("udp", s.addr) if err != nil { - log.F("proxy-uottun failed to listen on %s: %v", s.addr, err) + log.F("[uottun] failed to listen on %s: %v", s.addr, err) return } defer c.Close() - log.F("proxy-uottun listening UDP on %s", s.addr) + log.F("[uottun] listening UDP on %s", s.addr) buf := make([]byte, conn.UDPBufSize) for { n, clientAddr, err := c.ReadFrom(buf) if err != nil { - log.F("proxy-uottun read error: %v", err) + log.F("[uottun] read error: %v", err) continue } rc, err := s.dialer.Dial("uot", s.raddr) if err != nil { - log.F("proxy-uottun failed to connect to server %v: %v", s.raddr, err) + log.F("[uottun] failed to connect to server %v: %v", s.raddr, err) continue } @@ -95,10 +95,10 @@ func (s *UoTTun) ListenAndServe() { _, err = rc.Write(buf[:n]) if err != nil { - log.F("proxy-uottun remote write error: %v", err) + log.F("[uottun] remote write error: %v", err) continue } - log.F("proxy-uottun %s <-> %s", clientAddr, s.raddr) + log.F("[uottun] %s <-> %s", clientAddr, s.raddr) } } diff --git a/proxy/v2ray/v2ray.go b/proxy/v2ray/v2ray.go index 2b58146..f0f36b1 100644 --- a/proxy/v2ray/v2ray.go +++ b/proxy/v2ray/v2ray.go @@ -167,7 +167,7 @@ func (s *V2Ray) Dial(network, addr string) (net.Conn, error) { v2net.TCPDestination(v2net.ParseAddress(host), v2net.Port(port))) if err != nil { - log.F("proxy-v2ray dial to %s error: %s", s.addr, err) + log.F("[v2ray] dial to %s error: %s", s.addr, err) return nil, err } diff --git a/rule.go b/rule.go index c837140..f45e237 100644 --- a/rule.go +++ b/rule.go @@ -65,7 +65,7 @@ func (rd *RuleDialer) NextDialer(dstAddr string) proxy.Dialer { host, _, err := net.SplitHostPort(dstAddr) if err != nil { // TODO: check here - // logf("proxy-rule SplitHostPort ERROR: %s", err) + // logf("[rule] SplitHostPort ERROR: %s", err) return rd.gDialer } diff --git a/strategy.go b/strategy.go index a04d1f5..3324d85 100644 --- a/strategy.go +++ b/strategy.go @@ -120,7 +120,7 @@ func (rr *rrDialer) checkDialer(idx int) { c, err := d.Dial("tcp", rr.website) if err != nil { rr.status.Store(idx, false) - log.F("proxy-check %s -> %s, set to DISABLED. error in dial: %s", d.Addr(), rr.website, err) + log.F("[check] %s -> %s, set to DISABLED. error in dial: %s", d.Addr(), rr.website, err) continue } @@ -129,15 +129,15 @@ func (rr *rrDialer) checkDialer(idx int) { _, err = io.ReadFull(c, buf) if err != nil { rr.status.Store(idx, false) - log.F("proxy-check %s -> %s, set to DISABLED. error in read: %s", d.Addr(), rr.website, err) + log.F("[check] %s -> %s, set to DISABLED. error in read: %s", d.Addr(), rr.website, err) } else if bytes.Equal([]byte("HTTP"), buf) { rr.status.Store(idx, true) retry = 2 dialTime := time.Since(startTime) - log.F("proxy-check %s -> %s, set to ENABLED. connect time: %s", d.Addr(), rr.website, dialTime.String()) + log.F("[check] %s -> %s, set to ENABLED. connect time: %s", d.Addr(), rr.website, dialTime.String()) } else { rr.status.Store(idx, false) - log.F("proxy-check %s -> %s, set to DISABLED. server response: %s", d.Addr(), rr.website, buf) + log.F("[check] %s -> %s, set to DISABLED. server response: %s", d.Addr(), rr.website, buf) } c.Close()