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

tls: allow InsecureSkipVerify

Browse Source
This commit is contained in:
nadoo 2018-06-28 23:20:04 +08:00
parent cce6fcf6ef
commit 4a72e79002
17 changed files with 127 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
dns/dns.go
View File

@ -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
}

2
main.go
View File

@ -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"

24
proxy/http/http.go
View File

@ -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
}

10
proxy/mixed/mixed.go
View File

@ -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
}

14
proxy/redir/redir_linux.go
View File

@ -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)
}
}()

2
proxy/socks5/packet.go
View File

@ -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
}
}()

38
proxy/socks5/socks5.go
View File

@ -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
}

43
proxy/ss/ss.go
View File

@ -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
}

12
proxy/ssr/ssr.go
View File

@ -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")
}

2
proxy/tcptun/tcptun.go
View File

@ -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 {

6
proxy/tls/tls.go
View File

@ -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)

18
proxy/tproxy/tproxy_linux.go
View File

@ -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())
}

12
proxy/udptun/udptun.go
View File

@ -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)
}
}

12
proxy/uottun/uottun.go
View File

@ -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)
}
}

2
proxy/v2ray/v2ray.go
View File

@ -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
}

2
rule.go
View File

@ -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
}

8
strategy.go
View File

@ -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()