bughz/glider
1
0
Fork 0
mirror of https://github.com/nadoo/glider.git synced 2025-02-23 17:35:40 +08:00
Code Issues Actions 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() { func (s *DNS) ListenAndServeUDP() {
c, err := net.ListenPacket("udp", s.addr) c, err := net.ListenPacket("udp", s.addr)
if err != nil { 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 return
} }
defer c.Close() defer c.Close()
log.F("proxy-dns listening UDP on %s", s.addr) log.F("[dns] listening UDP on %s", s.addr)
for { for {
b := make([]byte, UDPMaxLen) b := make([]byte, UDPMaxLen)
n, clientAddr, err := c.ReadFrom(b) n, clientAddr, err := c.ReadFrom(b)
if err != nil { if err != nil {
log.F("proxy-dns local read error: %v", err) log.F("[dns] local read error: %v", err)
continue continue
} }
reqLen := uint16(n) reqLen := uint16(n)
// TODO: check here // TODO: check here
if reqLen <= HeaderLen+2 { if reqLen <= HeaderLen+2 {
log.F("proxy-dns not enough data") log.F("[dns] not enough data")
continue continue
} }
@ -204,13 +204,13 @@ func (s *DNS) ListenAndServeUDP() {
go func() { go func() {
_, respMsg, err := s.Exchange(reqLen, reqMsg, clientAddr.String()) _, respMsg, err := s.Exchange(reqLen, reqMsg, clientAddr.String())
if err != nil { if err != nil {
log.F("proxy-dns error in exchange: %s", err) log.F("[dns] error in exchange: %s", err)
return return
} }
_, err = c.WriteTo(respMsg, clientAddr) _, err = c.WriteTo(respMsg, clientAddr)
if err != nil { if err != nil {
log.F("proxy-dns error in local write: %s", err) log.F("[dns] error in local write: %s", err)
return return
} }
@ -222,16 +222,16 @@ func (s *DNS) ListenAndServeUDP() {
func (s *DNS) ListenAndServeTCP() { func (s *DNS) ListenAndServeTCP() {
l, err := net.Listen("tcp", s.addr) l, err := net.Listen("tcp", s.addr)
if err != nil { if err != nil {
log.F("proxy-dns-tcp error: %v", err) log.F("[dns]-tcp error: %v", err)
return return
} }
log.F("proxy-dns-tcp listening TCP on %s", s.addr) log.F("[dns]-tcp listening TCP on %s", s.addr)
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { 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 continue
} }
go s.ServeTCP(c) go s.ServeTCP(c)
@ -248,35 +248,35 @@ func (s *DNS) ServeTCP(c net.Conn) {
var reqLen uint16 var reqLen uint16
if err := binary.Read(c, binary.BigEndian, &reqLen); err != nil { 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 return
} }
// TODO: check here // TODO: check here
if reqLen <= HeaderLen+2 { if reqLen <= HeaderLen+2 {
log.F("proxy-dns-tcp not enough data") log.F("[dns]-tcp not enough data")
return return
} }
reqMsg := make([]byte, reqLen) reqMsg := make([]byte, reqLen)
_, err := io.ReadFull(c, reqMsg) _, err := io.ReadFull(c, reqMsg)
if err != nil { 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 return
} }
respLen, respMsg, err := s.Exchange(reqLen, reqMsg, c.RemoteAddr().String()) respLen, respMsg, err := s.Exchange(reqLen, reqMsg, c.RemoteAddr().String())
if err != nil { if err != nil {
log.F("proxy-dns-tcp error in exchange: %s", err) log.F("[dns]-tcp error in exchange: %s", err)
return return
} }
if err := binary.Write(c, binary.BigEndian, respLen); err != nil { 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 return
} }
if err := binary.Write(c, binary.BigEndian, respMsg); err != nil { 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 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[:])) // fmt.Printf("\ndns req len %d:\n%s\n", reqLen, hex.Dump(reqMsg[:]))
query, err := parseQuestion(reqMsg) query, err := parseQuestion(reqMsg)
if err != nil { if err != nil {
log.F("proxy-dns error in parseQuestion reqMsg: %s", err) log.F("[dns] error in parseQuestion reqMsg: %s", err)
return 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) rc, err := s.dialer.NextDialer(query.QNAME+":53").Dial("tcp", dnsServer)
if err != nil { 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 return
} }
defer rc.Close() defer rc.Close()
if err = binary.Write(rc, binary.BigEndian, reqLen); err != nil { 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 return
} }
if err = binary.Write(rc, binary.BigEndian, reqMsg); err != nil { 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 return
} }
if err = binary.Read(rc, binary.BigEndian, &respLen); err != nil { 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 return
} }
respMsg = make([]byte, respLen) respMsg = make([]byte, respLen)
_, err = io.ReadFull(rc, respMsg) _, err = io.ReadFull(rc, respMsg)
if err != nil { 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 return
} }
@ -326,7 +326,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1
var ip string var ip string
respReq, err := parseQuestion(respMsg) respReq, err := parseQuestion(respMsg)
if err != nil { if err != nil {
log.F("proxy-dns error in parseQuestion respMsg: %s", err) log.F("[dns] error in parseQuestion respMsg: %s", err)
return return
} }
@ -336,7 +336,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1
var answers []*RR var answers []*RR
answers, err = parseAnswers(respMsg[respReq.Offset:]) answers, err = parseAnswers(respMsg[respReq.Offset:])
if err != nil { if err != nil {
log.F("proxy-dns error in parseAnswers: %s", err) log.F("[dns] error in parseAnswers: %s", err)
return 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 return
} }

2
main.go
View File

@ -18,7 +18,7 @@ import (
_ "github.com/nadoo/glider/proxy/ss" _ "github.com/nadoo/glider/proxy/ss"
_ "github.com/nadoo/glider/proxy/ssr" _ "github.com/nadoo/glider/proxy/ssr"
_ "github.com/nadoo/glider/proxy/tcptun" _ "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/udptun"
_ "github.com/nadoo/glider/proxy/uottun" _ "github.com/nadoo/glider/proxy/uottun"
// _ "github.com/nadoo/glider/proxy/v2ray" // _ "github.com/nadoo/glider/proxy/v2ray"

24
proxy/http/http.go
View File

@ -83,7 +83,7 @@ func (s *HTTP) ListenAndServe() {
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { if err != nil {
log.F("proxy-http failed to accept: %v", err) log.F("[http] failed to accept: %v", err)
continue continue
} }
@ -123,7 +123,7 @@ func (s *HTTP) Serve(c net.Conn) {
url, err := url.ParseRequestURI(requestURI) url, err := url.ParseRequestURI(requestURI)
if err != nil { if err != nil {
log.F("proxy-http parse request url error: %s", err) log.F("[http] parse request url error: %s", err)
return return
} }
@ -135,7 +135,7 @@ func (s *HTTP) Serve(c net.Conn) {
rc, err := s.dialer.Dial("tcp", tgt) rc, err := s.dialer.Dial("tcp", tgt)
if err != nil { if err != nil {
fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto) 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 return
} }
defer rc.Close() defer rc.Close()
@ -171,7 +171,7 @@ func (s *HTTP) Serve(c net.Conn) {
respHeader, err := respTP.ReadMIMEHeader() respHeader, err := respTP.ReadMIMEHeader()
if err != nil { if err != nil {
log.F("proxy-http read header error:%s", err) log.F("[http] read header error:%s", err)
return return
} }
@ -182,7 +182,7 @@ func (s *HTTP) Serve(c net.Conn) {
writeFirstLine(proto, code, status, &respBuf) writeFirstLine(proto, code, status, &respBuf)
writeHeaders(respHeader, &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()) c.Write(respBuf.Bytes())
io.Copy(c, respR) io.Copy(c, respR)
@ -194,13 +194,13 @@ func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
if err != nil { if err != nil {
c.Write([]byte(proto)) c.Write([]byte(proto))
c.Write([]byte(" 502 ERROR\r\n\r\n")) 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 return
} }
c.Write([]byte("HTTP/1.0 200 Connection established\r\n\r\n")) 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) _, _, err = conn.Relay(c, rc)
if err != nil { 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) { func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
rc, err := s.dialer.Dial(network, s.addr) rc, err := s.dialer.Dial(network, s.addr)
if err != nil { 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 return nil, err
} }
@ -246,12 +246,12 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
if ok && code == "200" { if ok && code == "200" {
return rc, err return rc, err
} else if code == "407" { } 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" { } 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. // 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() line, err := tp.ReadLine()
// log.F("first line: %s", line) // log.F("first line: %s", line)
if err != nil { if err != nil {
log.F("proxy-http read first line error:%s", err) log.F("[http] read first line error:%s", err)
return return
} }

10
proxy/mixed/mixed.go
View File

@ -68,16 +68,16 @@ func (p *MixedProxy) ListenAndServe() {
l, err := net.Listen("tcp", p.addr) l, err := net.Listen("tcp", p.addr)
if err != nil { 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 return
} }
log.F("proxy-mixed listening TCP on %s", p.addr) log.F("[mixed] listening TCP on %s", p.addr)
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { if err != nil {
log.F("proxy-mixed failed to accept: %v", err) log.F("[mixed] failed to accept: %v", err)
continue continue
} }
@ -98,7 +98,7 @@ func (p *MixedProxy) Serve(c net.Conn) {
if p.socks5 != nil { if p.socks5 != nil {
head, err := cc.Peek(1) head, err := cc.Peek(1)
if err != nil { if err != nil {
log.F("proxy-mixed peek error: %s", err) log.F("[mixed] peek error: %s", err)
return return
} }
@ -112,7 +112,7 @@ func (p *MixedProxy) Serve(c net.Conn) {
if p.http != nil { if p.http != nil {
head, err := cc.Peek(8) head, err := cc.Peek(8)
if err != nil { if err != nil {
log.F("proxy-mixed peek error: %s", err) log.F("[mixed] peek error: %s", err)
return 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() { func (s *RedirProxy) ListenAndServe() {
l, err := net.Listen("tcp", s.addr) l, err := net.Listen("tcp", s.addr)
if err != nil { 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 return
} }
log.F("proxy-redir listening TCP on %s", s.addr) log.F("[redir] listening TCP on %s", s.addr)
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { if err != nil {
log.F("proxy-redir failed to accept: %v", err) log.F("[redir] failed to accept: %v", err)
continue continue
} }
@ -81,25 +81,25 @@ func (s *RedirProxy) ListenAndServe() {
tgt, err := getOrigDst(c, false) tgt, err := getOrigDst(c, false)
if err != nil { 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 return
} }
rc, err := s.dialer.Dial("tcp", tgt.String()) rc, err := s.dialer.Dial("tcp", tgt.String())
if err != nil { 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 return
} }
defer rc.Close() 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) _, _, err = conn.Relay(c, rc)
if err != nil { if err != nil {
if err, ok := err.(net.Error); ok && err.Timeout() { if err, ok := err.(net.Error); ok && err.Timeout() {
return // ignore i/o 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() { if err, ok := err.(net.Error); ok && err.Timeout() {
continue continue
} }
log.F("proxy-socks5 dialudp udp associate end") log.F("[socks5] dialudp udp associate end")
return return
} }
}() }()

38
proxy/socks5/socks5.go
View File

@ -88,16 +88,16 @@ func (s *SOCKS5) ListenAndServe() {
func (s *SOCKS5) ListenAndServeTCP() { func (s *SOCKS5) ListenAndServeTCP() {
l, err := net.Listen("tcp", s.addr) l, err := net.Listen("tcp", s.addr)
if err != nil { 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 return
} }
log.F("proxy-socks5 listening TCP on %s", s.addr) log.F("[socks5] listening TCP on %s", s.addr)
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { if err != nil {
log.F("proxy-socks5 failed to accept: %v", err) log.F("[socks5] failed to accept: %v", err)
continue continue
} }
@ -124,30 +124,30 @@ func (s *SOCKS5) ServeTCP(c net.Conn) {
if err, ok := err.(net.Error); ok && err.Timeout() { if err, ok := err.(net.Error); ok && err.Timeout() {
continue continue
} }
// log.F("proxy-socks5 servetcp udp associate end") // log.F("[socks5] servetcp udp associate end")
return return
} }
} }
log.F("proxy-socks5 failed to get target address: %v", err) log.F("[socks5] failed to get target address: %v", err)
return return
} }
rc, err := s.dialer.Dial("tcp", tgt.String()) rc, err := s.dialer.Dial("tcp", tgt.String())
if err != nil { 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 return
} }
defer rc.Close() 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) _, _, err = conn.Relay(c, rc)
if err != nil { if err != nil {
if err, ok := err.(net.Error); ok && err.Timeout() { if err, ok := err.(net.Error); ok && err.Timeout() {
return // ignore i/o 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() { func (s *SOCKS5) ListenAndServeUDP() {
lc, err := net.ListenPacket("udp", s.addr) lc, err := net.ListenPacket("udp", s.addr)
if err != nil { 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 return
} }
defer lc.Close() 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 var nm sync.Map
buf := make([]byte, conn.UDPBufSize) buf := make([]byte, conn.UDPBufSize)
@ -170,7 +170,7 @@ func (s *SOCKS5) ListenAndServeUDP() {
n, raddr, err := c.ReadFrom(buf) n, raddr, err := c.ReadFrom(buf)
if err != nil { if err != nil {
log.F("proxy-socks5-udp remote read error: %v", err) log.F("[socks5-udp] remote read error: %v", err)
continue continue
} }
@ -178,13 +178,13 @@ func (s *SOCKS5) ListenAndServeUDP() {
v, ok := nm.Load(raddr.String()) v, ok := nm.Load(raddr.String())
if !ok && v == nil { if !ok && v == nil {
if c.tgtAddr == 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 continue
} }
lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String()) lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String())
if err != nil { if err != nil {
log.F("proxy-socks5-udp remote dial error: %v", err) log.F("[socks5-udp] remote dial error: %v", err)
continue continue
} }
@ -203,11 +203,11 @@ func (s *SOCKS5) ListenAndServeUDP() {
_, err = pc.WriteTo(buf[:n], pc.writeAddr) _, err = pc.WriteTo(buf[:n], pc.writeAddr)
if err != nil { if err != nil {
log.F("proxy-socks5-udp remote write error: %v", err) log.F("[socks5-udp] remote write error: %v", err)
continue 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 { switch network {
case "tcp", "tcp6", "tcp4": case "tcp", "tcp6", "tcp4":
default: 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) 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) { func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
c, err := s.dialer.Dial("tcp", s.addr) c, err := s.dialer.Dial("tcp", s.addr)
if err != nil { 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 return nil, nil, err
} }
@ -276,7 +276,7 @@ func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.A
rep := buf[1] rep := buf[1]
if rep != 0 { 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") 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()) pc, nextHop, err := s.dialer.DialUDP(network, uAddr.String())
if err != nil { 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 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) ciph, err := core.PickCipher(method, nil, pass)
if err != nil { 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{ p := &SS{
@ -78,16 +78,16 @@ func (s *SS) ListenAndServe() {
func (s *SS) ListenAndServeTCP() { func (s *SS) ListenAndServeTCP() {
l, err := net.Listen("tcp", s.addr) l, err := net.Listen("tcp", s.addr)
if err != nil { 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 return
} }
log.F("proxy-ss listening TCP on %s", s.addr) log.F("[ss] listening TCP on %s", s.addr)
for { for {
c, err := l.Accept() c, err := l.Accept()
if err != nil { if err != nil {
log.F("proxy-ss failed to accept: %v", err) log.F("[ss] failed to accept: %v", err)
continue continue
} }
go s.ServeTCP(c) go s.ServeTCP(c)
@ -106,7 +106,7 @@ func (s *SS) ServeTCP(c net.Conn) {
tgt, err := socks.ReadAddr(c) tgt, err := socks.ReadAddr(c)
if err != nil { 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 return
} }
@ -115,17 +115,16 @@ func (s *SS) ServeTCP(c net.Conn) {
// udp over tcp? // udp over tcp?
uot := socks.UoT(tgt[0]) uot := socks.UoT(tgt[0])
if uot && dialer.Addr() == "DIRECT" { if uot && dialer.Addr() == "DIRECT" {
rc, err := net.ListenPacket("udp", "") rc, err := net.ListenPacket("udp", "")
if err != nil { 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() defer rc.Close()
req := make([]byte, conn.UDPBufSize) req := make([]byte, conn.UDPBufSize)
n, err := c.Read(req) n, err := c.Read(req)
if err != nil { 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 return
} }
@ -135,12 +134,12 @@ func (s *SS) ServeTCP(c net.Conn) {
buf := make([]byte, conn.UDPBufSize) buf := make([]byte, conn.UDPBufSize)
n, _, err = rc.ReadFrom(buf) n, _, err = rc.ReadFrom(buf)
if err != nil { if err != nil {
log.F("proxy-uottun read error: %v", err) log.F("[ss-uottun] read error: %v", err)
} }
c.Write(buf[:n]) 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 return
} }
@ -152,19 +151,19 @@ func (s *SS) ServeTCP(c net.Conn) {
rc, err := dialer.Dial(network, tgt.String()) rc, err := dialer.Dial(network, tgt.String())
if err != nil { 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 return
} }
defer rc.Close() 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) _, _, err = conn.Relay(c, rc)
if err != nil { if err != nil {
if err, ok := err.(net.Error); ok && err.Timeout() { if err, ok := err.(net.Error); ok && err.Timeout() {
return // ignore i/o 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() { func (s *SS) ListenAndServeUDP() {
lc, err := net.ListenPacket("udp", s.addr) lc, err := net.ListenPacket("udp", s.addr)
if err != nil { 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 return
} }
defer lc.Close() defer lc.Close()
lc = s.PacketConn(lc) 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 var nm sync.Map
buf := make([]byte, conn.UDPBufSize) buf := make([]byte, conn.UDPBufSize)
@ -190,7 +189,7 @@ func (s *SS) ListenAndServeUDP() {
n, raddr, err := c.ReadFrom(buf) n, raddr, err := c.ReadFrom(buf)
if err != nil { if err != nil {
log.F("proxy-ss-udp remote read error: %v", err) log.F("[ss-udp] remote read error: %v", err)
continue continue
} }
@ -199,7 +198,7 @@ func (s *SS) ListenAndServeUDP() {
if !ok && v == nil { if !ok && v == nil {
lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String()) lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String())
if err != nil { if err != nil {
log.F("proxy-ss-udp remote dial error: %v", err) log.F("[ss-udp] remote dial error: %v", err)
continue continue
} }
@ -218,11 +217,11 @@ func (s *SS) ListenAndServeUDP() {
_, err = pc.WriteTo(buf[:n], pc.writeAddr) _, err = pc.WriteTo(buf[:n], pc.writeAddr)
if err != nil { if err != nil {
log.F("proxy-ss-udp remote write error: %v", err) log.F("[ss-udp] remote write error: %v", err)
continue 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) { func (s *SS) Dial(network, addr string) (net.Conn, error) {
target := socks.ParseAddr(addr) target := socks.ParseAddr(addr)
if target == nil { 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" { 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) c, err := s.dialer.Dial("tcp", s.addr)
if err != nil { 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 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) { func (s *SS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
pc, nextHop, err := s.dialer.DialUDP(network, s.addr) pc, nextHop, err := s.dialer.DialUDP(network, s.addr)
if err != nil { 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 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) { func (s *SSR) Dial(network, addr string) (net.Conn, error) {
target := socks.ParseAddr(addr) target := socks.ParseAddr(addr)
if target == nil { 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) 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) c, err := s.dialer.Dial("tcp", s.addr)
if err != nil { 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 return nil, err
} }
@ -110,7 +110,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) {
ssrconn := shadowsocksr.NewSSTCPConn(c, cipher) ssrconn := shadowsocksr.NewSSTCPConn(c, cipher)
if ssrconn.Conn == nil || ssrconn.RemoteAddr() == nil { 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 // 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) ssrconn.IObfs = obfs.NewObfs(s.Obfs)
if ssrconn.IObfs == nil { 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{ obfsServerInfo := &ssr.ServerInfoForObfs{
@ -132,7 +132,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, error) {
ssrconn.IProtocol = protocol.NewProtocol(s.Protocol) ssrconn.IProtocol = protocol.NewProtocol(s.Protocol)
if ssrconn.IProtocol == nil { 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{ 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. // DialUDP connects to the given address via the proxy.
func (s *SSR) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) { 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() 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) _, _, err = conn.Relay(c, rc)
if err != nil { 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) { func (s *TLS) Dial(network, addr string) (net.Conn, error) {
cc, err := s.dialer.Dial("tcp", s.addr) cc, err := s.dialer.Dial("tcp", s.addr)
if err != nil { 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 return nil, err
} }
conf := &stdtls.Config{ conf := &stdtls.Config{
ServerName: s.serverName, ServerName: s.serverName,
//InsecureSkipVerify: true, InsecureSkipVerify: true,
} }
c := stdtls.Client(cc, conf) c := stdtls.Client(cc, conf)

18
proxy/tproxy/tproxy_linux.go
View File

@ -58,26 +58,26 @@ func (s *TProxy) ListenAndServe() {
// ListenAndServeTCP . // ListenAndServeTCP .
func (s *TProxy) 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 . // ListenAndServeUDP .
func (s *TProxy) ListenAndServeUDP() { func (s *TProxy) ListenAndServeUDP() {
laddr, err := net.ResolveUDPAddr("udp", s.addr) laddr, err := net.ResolveUDPAddr("udp", s.addr)
if err != nil { 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 return
} }
lc, err := net.ListenUDP("udp", laddr) lc, err := net.ListenUDP("udp", laddr)
if err != nil { 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 return
} }
fd, err := lc.File() fd, err := lc.File()
if err != nil { 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 return
} }
defer fd.Close() defer fd.Close()
@ -85,13 +85,13 @@ func (s *TProxy) ListenAndServeUDP() {
fileDescriptor := int(fd.Fd()) fileDescriptor := int(fd.Fd())
if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil { if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil {
syscall.Close(fileDescriptor) 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 return
} }
if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1); err != nil { if err = syscall.SetsockoptInt(fileDescriptor, syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1); err != nil {
syscall.Close(fileDescriptor) 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 return
} }
@ -100,15 +100,15 @@ func (s *TProxy) ListenAndServeUDP() {
_, srcAddr, dstAddr, err := ReadFromUDP(lc, buf) _, srcAddr, dstAddr, err := ReadFromUDP(lc, buf)
if err != nil { if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Temporary() { 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 continue
} }
log.F("proxy-tproxy Unrecoverable error while reading data: %s", err) log.F("[tproxy] Unrecoverable error while reading data: %s", err)
continue 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() { func (s *UDPTun) ListenAndServe() {
c, err := net.ListenPacket("udp", s.addr) c, err := net.ListenPacket("udp", s.addr)
if err != nil { 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 return
} }
defer c.Close() 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 var nm sync.Map
buf := make([]byte, conn.UDPBufSize) buf := make([]byte, conn.UDPBufSize)
@ -66,7 +66,7 @@ func (s *UDPTun) ListenAndServe() {
for { for {
n, raddr, err := c.ReadFrom(buf) n, raddr, err := c.ReadFrom(buf)
if err != nil { if err != nil {
log.F("proxy-udptun read error: %v", err) log.F("[udptun] read error: %v", err)
continue continue
} }
@ -78,7 +78,7 @@ func (s *UDPTun) ListenAndServe() {
pc, writeAddr, err = s.dialer.DialUDP("udp", s.raddr) pc, writeAddr, err = s.dialer.DialUDP("udp", s.raddr)
if err != nil { if err != nil {
log.F("proxy-udptun remote dial error: %v", err) log.F("[udptun] remote dial error: %v", err)
continue continue
} }
@ -96,11 +96,11 @@ func (s *UDPTun) ListenAndServe() {
_, err = pc.WriteTo(buf[:n], writeAddr) _, err = pc.WriteTo(buf[:n], writeAddr)
if err != nil { if err != nil {
log.F("proxy-udptun remote write error: %v", err) log.F("[udptun] remote write error: %v", err)
continue 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() { func (s *UoTTun) ListenAndServe() {
c, err := net.ListenPacket("udp", s.addr) c, err := net.ListenPacket("udp", s.addr)
if err != nil { 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 return
} }
defer c.Close() 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) buf := make([]byte, conn.UDPBufSize)
for { for {
n, clientAddr, err := c.ReadFrom(buf) n, clientAddr, err := c.ReadFrom(buf)
if err != nil { if err != nil {
log.F("proxy-uottun read error: %v", err) log.F("[uottun] read error: %v", err)
continue continue
} }
rc, err := s.dialer.Dial("uot", s.raddr) rc, err := s.dialer.Dial("uot", s.raddr)
if err != nil { 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 continue
} }
@ -95,10 +95,10 @@ func (s *UoTTun) ListenAndServe() {
_, err = rc.Write(buf[:n]) _, err = rc.Write(buf[:n])
if err != nil { if err != nil {
log.F("proxy-uottun remote write error: %v", err) log.F("[uottun] remote write error: %v", err)
continue 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))) v2net.TCPDestination(v2net.ParseAddress(host), v2net.Port(port)))
if err != nil { 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 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) host, _, err := net.SplitHostPort(dstAddr)
if err != nil { if err != nil {
// TODO: check here // TODO: check here
// logf("proxy-rule SplitHostPort ERROR: %s", err) // logf("[rule] SplitHostPort ERROR: %s", err)
return rd.gDialer 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) c, err := d.Dial("tcp", rr.website)
if err != nil { if err != nil {
rr.status.Store(idx, false) 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 continue
} }
@ -129,15 +129,15 @@ func (rr *rrDialer) checkDialer(idx int) {
_, err = io.ReadFull(c, buf) _, err = io.ReadFull(c, buf)
if err != nil { if err != nil {
rr.status.Store(idx, false) 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) { } else if bytes.Equal([]byte("HTTP"), buf) {
rr.status.Store(idx, true) rr.status.Store(idx, true)
retry = 2 retry = 2
dialTime := time.Since(startTime) 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 { } else {
rr.status.Store(idx, false) 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() c.Close()