in server.go [86:144]
func srvrHandleNewTcpConn(conn net.Conn) {
defer conn.Close()
server, port, err := net.SplitHostPort(conn.RemoteAddr().String())
ethrUnused(server, port)
if err != nil {
ui.printDbg("RemoteAddr: Split host port failed: %v", err)
return
}
lserver, lport, err := net.SplitHostPort(conn.LocalAddr().String())
if err != nil {
ui.printDbg("LocalAddr: Split host port failed: %v", err)
return
}
ethrUnused(lserver, lport)
ui.printDbg("New connection from %v, port %v to %v, port %v", server, port, lserver, lport)
test, isNew := createOrGetTest(server, TCP, All)
if test == nil {
return
}
if isNew {
ui.emitTestHdr()
}
isCPSorPing := true
// For CPS and Ping tests, there is no deterministic way to know when the test starts
// from the client side and when it ends. This defer function ensures that test is not
// created/deleted repeatedly by doing a deferred deletion. If another connection
// comes with-in 2s, then another reference would be taken on existing test object
// and it won't be deleted by safeDeleteTest call. This also ensures, test header is
// not printed repeatedly via emitTestHdr.
// Note: Similar mechanism is used in UDP tests to handle test lifetime as well.
defer func() {
if isCPSorPing {
time.Sleep(2 * time.Second)
}
safeDeleteTest(test)
}()
// Always increment CPS count and then check if the test is Bandwidth etc. and handle
// those cases as well.
atomic.AddUint64(&test.testResult.cps, 1)
testID, clientParam, err := handshakeWithClient(test, conn)
if err != nil {
ui.printDbg("Failed in handshake with the client. Error: %v", err)
return
}
isCPSorPing = false
if testID.Protocol == TCP {
if testID.Type == Bandwidth {
srvrRunTCPBandwidthTest(test, clientParam, conn)
} else if testID.Type == Latency {
ui.emitLatencyHdr()
srvrRunTCPLatencyTest(test, clientParam, conn)
}
}
}