func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string, target string) bool {
fmt.Println("ServerSetup")
bindaddrs, _ := getServerBindaddrs(bindaddrString)
for _, bindaddr := range bindaddrs {
name := bindaddr.MethodName
fmt.Println("bindaddr", bindaddr)
t := transports.Get(name)
if t == nil {
fmt.Println(name, "no such transport is supported")
continue
}
f, err := t.ServerFactory(stateDir, &bindaddr.Options)
if err != nil {
fmt.Println(name, err.Error())
continue
}
ln, err := net.ListenTCP("tcp", bindaddr.Addr)
if err != nil {
fmt.Println(name, err.Error())
continue
}
go serverAcceptLoop(termMon, f, ln, target)
log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
}
return true
}
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 ServerSetup(termMon *termmon.TermMonitor) (launched bool, listeners []net.Listener) {
ptServerInfo, err := pt.ServerSetup(transports.Transports())
if err != nil {
golog.Fatal(err)
}
for _, bindaddr := range ptServerInfo.Bindaddrs {
name := bindaddr.MethodName
t := transports.Get(name)
if t == nil {
pt.SmethodError(name, "no such transport is supported")
continue
}
f, err := t.ServerFactory(stateDir, &bindaddr.Options)
if err != nil {
pt.SmethodError(name, err.Error())
continue
}
ln, err := net.ListenTCP("tcp", bindaddr.Addr)
if err != nil {
pt.SmethodError(name, err.Error())
continue
}
go serverAcceptLoop(termMon, f, ln, &ptServerInfo)
if args := f.Args(); args != nil {
pt.SmethodArgs(name, ln.Addr(), *args)
} else {
pt.SmethodArgs(name, ln.Addr(), nil)
}
log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
listeners = append(listeners, ln)
launched = true
}
pt.SmethodsDone()
return
}
func ServerSetup(termMon *termmon.TermMonitor, bindaddrString string) (launched bool, listeners []net.Listener) {
ptServerInfo, err := pt.ServerSetup(transports.Transports())
if err != nil {
golog.Fatal(err)
}
fmt.Println("ServerSetup")
bindaddrs, _ := getServerBindaddrs(bindaddrString)
for _, bindaddr := range bindaddrs {
name := bindaddr.MethodName
fmt.Println("bindaddr", bindaddr)
t := transports.Get(name)
if t == nil {
fmt.Println(name, "no such transport is supported")
continue
}
f, err := t.ServerFactory(stateDir, &bindaddr.Options)
if err != nil {
fmt.Println(name, err.Error())
continue
}
ln, err := net.ListenTCP("tcp", bindaddr.Addr)
if err != nil {
fmt.Println(name, err.Error())
continue
}
go serverAcceptLoop(termMon, f, ln, &ptServerInfo)
log.Infof("%s - registered listener: %s", name, log.ElideAddr(ln.Addr().String()))
listeners = append(listeners, ln)
launched = true
}
return
}
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)
}
}