func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFactory, conn *net.UDPConn, proxyURI *url.URL) {
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
fmt.Println("@@@ handling...")
tracker := make(ConnTracker)
name := f.Transport().Name()
fmt.Println("Transport is", name)
buf := make([]byte, 1024)
// Receive UDP packets and forward them over transport connections forever
for {
n, addr, err := conn.ReadFromUDP(buf)
fmt.Println("Received ", string(buf[0:n]), " from ", addr)
if err != nil {
fmt.Println("Error: ", err)
}
fmt.Println(tracker)
if state, ok := tracker[addr.String()]; ok {
// There is an open transport connection, or a connection attempt is in progress.
if state.Waiting {
// The connection attempt is in progress.
// Drop the packet.
fmt.Println("recv: waiting")
} else {
// There is an open transport connection.
// Send the packet through the transport.
fmt.Println("recv: write")
fmt.Println("writing...")
(*state.Conn).Write(buf)
}
} else {
// There is not an open transport connection and a connection attempt is not in progress.
// Open a transport connection.
fmt.Println("Opening connection to ", target)
openConnection(&tracker, addr.String(), target, termMon, f, proxyURI)
// Drop the packet.
fmt.Println("recv: Open")
}
}
}
func dialConn(tracker *ConnTracker, addr string, target string, f base.ClientFactory, proxyURI *url.URL) {
// Obtain the proxy dialer if any, and create the outgoing TCP connection.
dialFn := proxy.Direct.Dial
if proxyURI != nil {
dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
if err != nil {
// This should basically never happen, since config protocol
// verifies this.
fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
log.Errorf("(%s) - failed to obtain proxy dialer: %s", target, log.ElideError(err))
return
}
dialFn = dialer.Dial
}
fmt.Println("Dialing....")
// Deal with arguments.
args, err := f.ParseArgs(&pt.Args{})
if err != nil {
fmt.Println("Invalid arguments")
log.Errorf("(%s) - invalid arguments: %s", target, err)
delete(*tracker, addr)
return
}
fmt.Println("Dialing ", target)
remote, err := f.Dial("tcp", target, dialFn, args)
if err != nil {
fmt.Println("outgoing connection failed", err)
log.Errorf("(%s) - outgoing connection failed: %s", target, log.ElideError(err))
fmt.Println("Failed")
delete(*tracker, addr)
return
}
fmt.Println("Success")
(*tracker)[addr] = ConnState{&remote, false}
}
func clientHandler(termMon *termmon.TermMonitor, f base.ClientFactory, conn net.Conn, proxyURI *url.URL) {
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
name := f.Transport().Name()
// Read the client's SOCKS handshake.
socksReq, err := socks5.Handshake(conn)
if err != nil {
log.Errorf("%s - client failed socks handshake: %s", name, err)
return
}
addrStr := log.ElideAddr(socksReq.Target)
// Deal with arguments.
args, err := f.ParseArgs(&socksReq.Args)
if err != nil {
log.Errorf("%s(%s) - invalid arguments: %s", name, addrStr, err)
socksReq.Reply(socks5.ReplyGeneralFailure)
return
}
// Obtain the proxy dialer if any, and create the outgoing TCP connection.
dialFn := proxy.Direct.Dial
if proxyURI != nil {
dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
if err != nil {
// This should basically never happen, since config protocol
// verifies this.
log.Errorf("%s(%s) - failed to obtain proxy dialer: %s", name, addrStr, log.ElideError(err))
socksReq.Reply(socks5.ReplyGeneralFailure)
return
}
dialFn = dialer.Dial
}
fmt.Println("Got dialer", dialFn, proxyURI, proxy.Direct)
remote, err := f.Dial("tcp", socksReq.Target, dialFn, args)
if err != nil {
log.Errorf("%s(%s) - outgoing connection failed: %s", name, addrStr, log.ElideError(err))
socksReq.Reply(socks5.ErrorToReplyCode(err))
return
}
defer remote.Close()
err = socksReq.Reply(socks5.ReplySucceeded)
if err != nil {
log.Errorf("%s(%s) - SOCKS reply failed: %s", name, addrStr, log.ElideError(err))
return
}
if err = copyLoop(conn, remote); err != nil {
log.Warnf("%s(%s) - closed connection: %s", name, addrStr, log.ElideError(err))
} else {
log.Infof("%s(%s) - closed connection", name, addrStr)
}
return
}
func clientHandler(target string, termMon *termmon.TermMonitor, f base.ClientFactory, conn net.Conn, proxyURI *url.URL) {
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
fmt.Println("handling...")
name := f.Transport().Name()
fmt.Println("Transport is", name)
// Deal with arguments.
args, err := f.ParseArgs(&pt.Args{})
if err != nil {
fmt.Println("Invalid arguments")
log.Errorf("%s(%s) - invalid arguments: %s", name, target, err)
return
}
fmt.Println("Making dialer...")
// Obtain the proxy dialer if any, and create the outgoing TCP connection.
dialFn := proxy.Direct.Dial
if proxyURI != nil {
dialer, err := proxy.FromURL(proxyURI, proxy.Direct)
if err != nil {
// This should basically never happen, since config protocol
// verifies this.
fmt.Println("failed to obtain dialer", proxyURI, proxy.Direct)
log.Errorf("%s(%s) - failed to obtain proxy dialer: %s", name, target, log.ElideError(err))
return
}
dialFn = dialer.Dial
}
fmt.Println("Dialing...")
remote, err := f.Dial("tcp", target, dialFn, args)
if err != nil {
fmt.Println("outgoing connection failed")
log.Errorf("%s(%s) - outgoing connection failed: %s", name, target, log.ElideError(err))
return
}
defer remote.Close()
fmt.Println("copying...")
if err = copyLoop(conn, remote); err != nil {
log.Warnf("%s(%s) - closed connection: %s", name, target, log.ElideError(err))
} else {
log.Infof("%s(%s) - closed connection", name, target)
}
fmt.Println("done")
return
}