func serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, info *pt.ServerInfo) {
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
name := f.Transport().Name()
addrStr := log.ElideAddr(conn.RemoteAddr().String())
log.Infof("%s(%s) - new connection", name, addrStr)
// Instantiate the server transport method and handshake.
remote, err := f.WrapConn(conn)
if err != nil {
log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
return
}
// Connect to the orport.
orConn, err := pt.DialOr(info, conn.RemoteAddr().String(), name)
if err != nil {
log.Errorf("%s(%s) - failed to connect to ORPort: %s", name, addrStr, log.ElideError(err))
return
}
defer orConn.Close()
if err = copyLoop(orConn, 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(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
}
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 serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, target string) {
var length16 uint16
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
name := f.Transport().Name()
addrStr := log.ElideAddr(conn.RemoteAddr().String())
fmt.Println("### handling", name)
log.Infof("%s(%s) - new connection", name, addrStr)
// Instantiate the server transport method and handshake.
remote, err := f.WrapConn(conn)
if err != nil {
fmt.Println("handshake failed", err)
log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
return
}
serverAddr, err := net.ResolveUDPAddr("udp", target)
if err != nil {
golog.Fatal(err)
}
localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
if err != nil {
golog.Fatal(err)
}
dest, err := net.DialUDP("udp", localAddr, serverAddr)
if err != nil {
golog.Fatal(err)
}
fmt.Println("pumping")
defer dest.Close()
lengthBuffer := make([]byte, 2)
for {
fmt.Println("reading...")
// Read the incoming connection into the buffer.
readLen, err := io.ReadFull(remote, lengthBuffer)
if err != nil {
fmt.Println("read error")
break
}
fmt.Println(readLen)
err = binary.Read(bytes.NewReader(lengthBuffer), binary.LittleEndian, &length16)
if err != nil {
fmt.Println("deserialization error")
return
}
fmt.Println("reading data")
readBuffer := make([]byte, length16)
readLen, err = io.ReadFull(remote, readBuffer)
if err != nil {
fmt.Println("read error")
break
}
dest.Write(readBuffer)
}
}
func serverHandler(termMon *termmon.TermMonitor, f base.ServerFactory, conn net.Conn, target string) {
var header *common.Message
defer conn.Close()
termMon.OnHandlerStart()
defer termMon.OnHandlerFinish()
name := f.Transport().Name()
addrStr := log.ElideAddr(conn.RemoteAddr().String())
fmt.Println("### handling", name)
log.Infof("%s(%s) - new connection", name, addrStr)
// Instantiate the server transport method and handshake.
remote, err := f.WrapConn(conn)
if err != nil {
fmt.Println("handshake failed", err)
log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
return
}
serverAddr, err := net.ResolveUDPAddr("udp", target)
if err != nil {
golog.Fatal(err)
}
localAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:0")
if err != nil {
golog.Fatal(err)
}
dest, err := net.DialUDP("udp", localAddr, serverAddr)
if err != nil {
golog.Fatal(err)
}
fmt.Println("pumping")
defer dest.Close()
headerBuffer := make([]byte, 20)
for {
fmt.Println("reading...")
// Read the incoming connection into the buffer.
_, err := io.ReadFull(remote, headerBuffer)
if err != nil {
fmt.Println("read error")
break
}
header, err = goturn.ParseStun(headerBuffer)
if err != nil {
fmt.Println("parse error")
break
}
fmt.Println(header.Length)
fmt.Println("reading data")
readBuffer := make([]byte, header.Length)
_, err = io.ReadFull(remote, readBuffer)
if err != nil {
fmt.Println("read error")
break
}
writeBuffer := append(headerBuffer, readBuffer...)
dest.Write(writeBuffer)
}
}