func (srv *Server) readTCP(conn *net.TCPConn, timeout time.Duration) ([]byte, error) {
conn.SetReadDeadline(time.Now().Add(timeout))
l := make([]byte, 2)
n, err := conn.Read(l)
if err != nil || n != 2 {
if err != nil {
return nil, err
}
return nil, ErrShortRead
}
length, _ := unpackUint16(l, 0)
if length == 0 {
return nil, ErrShortRead
}
m := make([]byte, int(length))
n, err = conn.Read(m[:int(length)])
if err != nil || n == 0 {
if err != nil {
return nil, err
}
return nil, ErrShortRead
}
i := n
for i < int(length) {
j, err := conn.Read(m[i:int(length)])
if err != nil {
return nil, err
}
i += j
}
n = i
m = m[:n]
return m, nil
}
func (server *TcpServer) Start() (err error) {
for {
var conn *net.TCPConn
if conn, err = server.TCPListener.AcceptTCP(); err != nil {
return err
}
if server.keepAlive != nil {
if err := conn.SetKeepAlive(server.keepAlive.(bool)); err != nil {
return err
}
}
if server.keepAlivePeriod != nil {
if kap, ok := (net.Conn(conn)).(iKeepAlivePeriod); ok {
if err := kap.SetKeepAlivePeriod(server.keepAlivePeriod.(time.Duration)); err != nil {
return err
}
}
}
if server.linger != nil {
if err := conn.SetLinger(server.linger.(int)); err != nil {
return err
}
}
if server.noDelay != nil {
if err := conn.SetNoDelay(server.noDelay.(bool)); err != nil {
return err
}
}
if server.readBuffer != nil {
if err := conn.SetReadBuffer(server.readBuffer.(int)); err != nil {
return err
}
}
if server.writerBuffer != nil {
if err := conn.SetWriteBuffer(server.writerBuffer.(int)); err != nil {
return err
}
}
if server.deadline != nil {
if err := conn.SetDeadline(server.deadline.(time.Time)); err != nil {
return err
}
}
if server.readDeadline != nil {
if err := conn.SetReadDeadline(server.readDeadline.(time.Time)); err != nil {
return err
}
}
if server.writerDeadline != nil {
if err := conn.SetWriteDeadline(server.writerDeadline.(time.Time)); err != nil {
return err
}
}
if server.config != nil {
server.ServeTCP(tls.Client(conn, server.config))
} else {
server.ServeTCP(conn)
}
}
}
func pipeThenClose(src, dst *net.TCPConn, finishChannel chan bool) {
defer func() {
src.CloseRead()
dst.CloseWrite()
finishChannel <- true
}()
buf := asocks.GetBuffer()
defer asocks.GiveBuffer(buf)
for {
src.SetReadDeadline(time.Now().Add(60 * time.Second))
n, err := src.Read(buf)
if n > 0 {
data := buf[0:n]
encodeData(data)
if _, err := dst.Write(data); err != nil {
break
}
}
if err != nil {
break
}
}
}
func receiveTcpConn(conn *net.TCPConn, rc TcpReceiveCaller) {
for {
buf := bufio.NewReader(conn)
line, err := buf.ReadBytes('\n')
if err != nil {
// remove client
addr := conn.RemoteAddr().String()
if v, ok := clients[addr]; ok {
uid := v.UserId
delete(clients, addr)
addr2 := users[uid]
if strings.Index(addr2, "$") == -1 {
delete(users, uid)
} else {
users[uid] = strings.Replace(strings.Replace(addr2, addr, "", 1), "$$", "$", -1)
}
}
printf(true, "[ CLIENT][ DISCONN] - IP : %s disconnect!active clients : %d",
conn.RemoteAddr().String(), len(clients))
break
}
if d, err := rc(conn, line[:len(line)-1]); err != nil { // remove '\n'
conn.Write([]byte("error$" + err.Error()))
} else if d != nil {
conn.Write(d)
}
conn.Write([]byte("\n"))
conn.SetReadDeadline(time.Now().Add(ReadDeadLine)) // discount after 5m
}
}
//
// A TCP 'echo' example.
// Demonstrates using a timeout, and a 'graceful' shutdown if one occurs.
// 'Tested' using 'telnet localhost 45678'
//
func runReads(tcpConn *net.TCPConn) bool {
br := bufio.NewReader(tcpConn)
for {
// Set a timeout value, which needs to be set before each and every read.
d := time.Duration(30 * 1e9) // 30 seconds
w := time.Now() // from now
w = w.Add(d)
tcpConn.SetReadDeadline(w) // Set the deadline
//
buffer, err := br.ReadBytes('\n') // '\n' is delimiter
// If the read times out, this prints something like:
// Error = read tcp 127.0.0.1:57609: resource temporarily unavailable
if err != nil {
fmt.Printf("Error = %v\n", err)
return false
// panic("wtf04")
}
//
fmt.Printf("Bytes Read: %d\n", len(buffer))
var data = string(buffer)
fmt.Printf("Data Read: |%q|\n", data)
// This is now an 'echo' example.
out := "echo: " + data
tcpConn.Write([]byte(out))
// The \r in this data from telnet is a bit surprising ...
if data == "quit\r\n" {
fmt.Println("Breaking....")
break
}
}
return true
}
func session(conn *net.TCPConn) {
fmt.Println("here")
var buf [2048]byte
code := 0
for {
t := time.Now().Add(time.Millisecond * 100)
conn.SetReadDeadline(t)
n, err := conn.Read(buf[:])
e, ok := err.(net.Error)
if err != nil && ok && !e.Timeout() {
fmt.Println(err)
break
}
if n > 0 {
process(conn, buf[:n])
} else {
msg := fmt.Sprintf("%v", code)
code++
conn.Write([]byte(msg))
}
}
fmt.Println("session ended")
}
func (dc *DefaultConnector) receive(conn *net.TCPConn) ([]byte, error) {
err := conn.SetReadDeadline(time.Now().Add(dc.config.ReadTimeout))
if err != nil {
return nil, err
}
header := make([]byte, 8)
_, err = io.ReadFull(conn, header)
if err != nil {
return nil, err
}
decoder := NewBinaryDecoder(header)
length, err := decoder.GetInt32()
if err != nil {
return nil, err
}
response := make([]byte, length-4)
_, err = io.ReadFull(conn, response)
if err != nil {
return nil, err
}
return response, nil
}
// 协议封装读取
func TCPConnRead(conn *net.TCPConn) ([]byte, error) {
conn.SetReadDeadline(time.Now().Add(time.Second * 30))
result := bytes.NewBuffer(nil)
data := make([]byte, 4)
num, err := conn.Read(data)
if err != nil || num != 4 {
if err == nil {
err = errors.New("length read error")
}
return nil, err
}
result.Write(data[0:num])
var length int32
err = binary.Read(result, binary.LittleEndian, &length)
if err != nil {
return nil, err
}
if length > MAX_PACKET_SIZE {
return nil, errors.New("too large packet! packet size should less than 1M")
}
data = make([]byte, length)
result = bytes.NewBuffer(nil)
num, err = io.ReadFull(conn, data)
if err != nil {
return nil, err
}
result.Write(data[0:num])
return result.Bytes(), nil
}
// read a reply to a buffer based on the expected message type
// return error if reply message has different type of command than expected
func readHelloReply(conn *net.TCPConn) (proto.Message, error) {
duration := time.Second * 10
timeNow := time.Now()
err := conn.SetReadDeadline(timeNow.Add(duration))
if err != nil {
TimeEncodedPrint("Cant set read timeout", err.Error())
return nil, err
}
length := int32(0)
err = binary.Read(conn, binary.LittleEndian, &length)
if DEBUG_READING_MESSAGE {
fmt.Println("TRYING TO READ MESSAGE LENGTH => ", length, " ERROR: ", err)
}
if err != nil {
return nil, err
}
if BYPASS_CONNECTION_SERVER {
tempBuf := make([]byte, 8)
_, err = io.ReadFull(conn, tempBuf)
if DEBUG_READING_MESSAGE {
fmt.Println("Trying to read extra 8 bytes:", tempBuf, " PROBLEM: ", err)
}
if err != nil {
return nil, err
}
length = length - 8
}
rbuf := make([]byte, length)
n, err := io.ReadFull(conn, rbuf)
cmd := int(rbuf[0])
switch cmd {
case S2C_HelloInfoResult_CMD:
res := &Auth_S2C.HelloInfoResult{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
} else {
return res, nil
}
case ERROR_ErrorInfo_CMD:
res := &Auth_S2C.ErrorInfo{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
}
msg := fmt.Sprint("Server returns error: ")
return res, errors.New(msg)
default:
log.Fatal("Unexpected CMD: ", cmd, "length is: ", length, " number bytes read: ", n, " error: ", err)
}
return nil, nil
}
func (t *Duo) Pipe(conn *net.TCPConn) {
fd := t.Fd(conn)
defer func() {
t.Logger.Printf("disconnected: %s\n", fd)
conn.Close()
delete(t.Conn, fd)
}()
// Save in map
t.Conn[fd] = conn
// Read data
reader := bufio.NewReader(conn)
for {
body, err := t.Unpack(reader)
if err != nil {
if err == io.EOF {
return
}
if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
return
}
t.Logger.Print(err)
}
conn.SetReadDeadline(time.Now().Add(20 * time.Second))
if len(body) == 0 {
continue
}
t.handler(conn, body)
reader.Reset(conn)
}
}
//处理连接请求
func (this *server) handlerConnection(conn *net.TCPConn) {
defer logger.CatchException()
logger.Infof("New connection coming ... IP=%s ", conn.RemoteAddr())
conn.SetNoDelay(true) //无延迟
conn.SetKeepAlive(true) //保持激活
conn.SetReadBuffer(64 * 1024) //设置读缓冲区大小
conn.SetWriteBuffer(64 * 1024) //设置写缓冲区大小
conn.SetReadDeadline(time.Now().Add(30000000 * time.Second)) //设置读超时
session := network.NewSession(conn)
defer session.Close()
for {
msg, err := session.RecvMSG()
if err != nil {
logger.Infof("RecvMsgs IP=%s err=%v", conn.RemoteAddr(), err.Error())
return
}
ret := this.ProcessMessage(session, msg)
if ret == false {
return
}
}
}
// Takes two existing TCP connections and copies all incoming traffic to the
// other channel. Returns only upon an error
// This function has some commented out code. This was me playing with TCP
// keepalive and the annoying missing API from go.
// It doesn't work so it's now kept simple and just disconnects after inactivity.
func (p *proxy) pipe(src, dst *net.TCPConn) {
islocal := src == p.lconn
// Detecting a broken/down connection in TCP is a little tricky as it turns
// out:
// http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
// $ tail /proc/sys/net/ipv4/tcp_keepalive_*
// ==> /proc/sys/net/ipv4/tcp_keepalive_intvl <==
// 75
// ==> /proc/sys/net/ipv4/tcp_keepalive_probes <==
// 9
// ==> /proc/sys/net/ipv4/tcp_keepalive_time <==
// 7200
// Unfortunately GO sets both, interval and idle time :(
// http://felixge.de/2014/08/26/tcp-keepalive-with-golang.html
// src.SetKeepAlive(true)
// src.SetKeepAlivePeriod(TCP_KEEP_ALIVE) // Bad don't set (read blog post above)
// linuxEnableKeepAlive(src)
// directional copy (16k buffer)
buff := make([]byte, 0x3fff)
// This loop is our main copy loop. It takes each packet and just shoves it
// into the other side. This works for both ways
for {
// We will set a timeout so that we also drop clients after a while of
// no activity.
// Problem: This also dropps the connection even if sitting on an idle
// shell. But who really leaves it hanging for days without any input/output?
src.SetReadDeadline(time.Now().Add(TCP_READ_TIMEOUT))
n, err := src.Read(buff)
if err != nil {
if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
// Activate TCPs keepalive now which will close the connection
// if the client is gone
// TODO: Doesnt work:
// linuxEnableKeepAlive(src)
p.disconnect("Inactive client '%s'\n", err)
return
} else {
p.disconnect("Read failed '%s'\n", err)
return
}
}
b := buff[:n]
// write out result
n, err = dst.Write(b)
if err != nil {
p.disconnect("Write failed '%s'\n", err)
return
}
if islocal {
p.sentBytes += uint64(n)
} else {
p.receivedBytes += uint64(n)
}
}
}
// read a reply to a buffer based on the expected message type
// return error if reply message has different type of command than expected
func readReply(conn *net.TCPConn) (proto.Message, error) {
duration := time.Millisecond * 20
timeNow := time.Now()
err := conn.SetReadDeadline(timeNow.Add(duration))
if err != nil {
TimeEncodedPrint("Cant set read timeout", err.Error())
return nil, err
}
length := int32(0)
err = binary.Read(conn, binary.LittleEndian, &length)
if err != nil {
return nil, nil
}
if DEBUG_STEP {
fmt.Println("RECEIVE MESSAGE LENGTH: ", length)
}
// now wait longer for the message data
duration = time.Millisecond * 100
timeNow = time.Now()
err = conn.SetReadDeadline(timeNow.Add(duration))
rbuf := make([]byte, length)
io.ReadFull(conn, rbuf)
if DEBUG_STEP {
fmt.Println(rbuf)
}
cmd := int(rbuf[0])
switch cmd {
case S2C_HelloInfoResult_CMD:
res := &Auth_S2C.HelloInfoResult{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
} else {
return res, nil
}
case ERROR_ErrorInfo_CMD:
res := &Auth_S2C.ErrorInfo{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
}
msg := fmt.Sprint("Server returns error: ")
return res, errors.New(msg)
default:
log.Fatal("Unexpected CMD: ", cmd)
}
return nil, nil
}
func (s Sender) sendData(data []byte, conn *net.TCPConn) bool {
if len(data) == 0 {
return true
}
if conn == nil {
return false
}
/*
lenBuf := make([]byte, 4)
nData := len(data)
binary.PutUvarint(lenBuf, uint64(nData))
data = append(lenBuf, data...)
*/
st := time.Now()
packId := tcp_pack.GetPackId(data)
conn.SetDeadline(time.Now().Add(5 * time.Minute)) //设置超时
loglib.Info(fmt.Sprintf("sender%d start sending pack:%s length:%d", s.id, packId, len(data)))
n, err := conn.Write(data)
ed := time.Now()
loglib.Info(fmt.Sprintf("sender%d end sending pack:%s length:%d elapse:%s", s.id, packId, n, ed.Sub(st)))
lib.CheckError(err)
//写失败了就不用等应答了，肯定拿不到
if err == nil {
conn.SetReadDeadline(time.Now().Add(8 * time.Minute)) //设置超时
time1 := time.Now()
var temp []byte = make([]byte, 128)
count, err := conn.Read(temp)
if err == nil {
loglib.Info(fmt.Sprintf("sender%d get anwser data len:%d for pack:%s elapse:%s", s.id, count, packId, time.Now().Sub(time1)))
} else {
loglib.Info(fmt.Sprintf("sender%d get anwser data len:%d for pack:%s elapse:%s, error:%s", s.id, count, packId, time.Now().Sub(time1), err.Error()))
}
temp = temp[:count]
if string(temp) == "ok" { //发送成功
return true
} else if string(temp) == "wrong header" {
//包头错误,丢弃
loglib.Info(packId + " has wrong header, retry later!")
return false
} else { //发送失败
//报警
return false
}
} else {
loglib.Warning(fmt.Sprintf("write pack %s error:%s", packId, err.Error()))
}
return false
}
/*
keep routine for write and read
*/
func serverKeeper(conn *net.TCPConn) {
// conn.SetKeepAlive(true)
request := make([]byte, 1024) // set maxium request length to 128B to prevent flood attack
defer func() {
sendChan <- "&**& quit this server &**&" //退出协程并且删掉主对象
}() // close connection before exit
// send
go func() {
for {
sendData := <-sendChan
if sendData != "&**& quit this server &**&" {
// fmt.Println("server sending...", sendData)
_, err := conn.Write([]byte(sendData))
checkError(err)
} else {
//崩溃退出关闭发送协程
conn.Close()
fmt.Println("quit server Keeper success")
return
}
}
}()
//read
for {
conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout
read_len, err := conn.Read(request)
if err != nil {
if err.Error() == "EOF" {
fmt.Println("this is EOF")
break
}
fmt.Println(err)
fmt.Println(err.Error())
//break
}
if read_len == 0 {
break // connection already closed by client
} else {
fmt.Println("receive", string(request))
temp := gocommand.DeCode(string(request))
if temp == " !heart beat! " || temp == "" {
//heart beat
} else {
receiveChan <- temp
}
}
request = make([]byte, 1024) // clear last read content
}
}
// read a reply to a buffer based on the expected message type
// return error if reply message has different type of command than expected
func readHelloReply(conn *net.TCPConn) (proto.Message, error) {
duration, _ := time.ParseDuration("1s")
timeNow := time.Now()
err := conn.SetReadDeadline(timeNow.Add(duration))
if err != nil {
TimeEncodedPrint("Cant set read timeout", err.Error())
return nil, err
}
length := int32(0)
err = binary.Read(conn, binary.LittleEndian, &length)
if err != nil {
return nil, err
}
if BYPASS_CONNECTION_SERVER {
tempBuf := make([]byte, 8)
_, err = io.ReadFull(conn, tempBuf)
if err != nil {
return nil, err
}
length = length - 8
}
rbuf := make([]byte, length)
io.ReadFull(conn, rbuf)
cmd := int(rbuf[0])
switch cmd {
case S2C_HelloInfoResult_CMD:
res := &Auth_S2C.HelloInfoResult{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
} else {
return res, nil
}
case ERROR_ErrorInfo_CMD:
res := &Auth_S2C.ErrorInfo{}
err := proto.Unmarshal(rbuf[1:], res)
if err != nil {
log.Fatal(err)
}
msg := fmt.Sprint("Server returns error: ")
return res, errors.New(msg)
default:
log.Fatal("Unexpected CMD: ", cmd)
}
return nil, nil
}
func readStickPackLoop(c *net.TCPConn, rchan chan gotcp.Packet) {
defer func() {
recover()
c.Close()
}()
reader := bufio.NewReader(c)
unCompleteBuffer := make([]byte, 0)
buffer := make([]byte, 1024)
for {
/*
select {
case <-c.srv.exitChan:
return
case <-c.closeChan:
return
default:
}
*/
c.SetReadDeadline(time.Now().Add(time.Second * 30))
n, err := reader.Read(buffer)
if e, ok := err.(net.Error); ok && e.Timeout() {
continue
// This was a timeout
} else if err != nil {
if err == io.EOF {
l4g.Info("client read a eof error: %v", err)
}
l4g.Info("client read a error: %v", err)
return
// This was an error, but not a timeout
}
if n == 1 && string(buffer[:1]) == "P" {
l4g.Debug("connection %p reciev ping", c)
}
if n > 0 {
//fmt.Println("n is ========================================", n)
unCompleteBuffer = gotcp.Unpack(append(unCompleteBuffer, buffer[:n]...), rchan)
}
}
}
func (n *Node) receive(conn *net.TCPConn) (*message, error) {
dec := gob.NewDecoder(conn)
m := new(message)
deadline := time.Now().Add(n.getNetworkTimeout())
if err := conn.SetReadDeadline(deadline); err != nil {
return nil, err
}
if err := dec.Decode(&m); err != nil {
return nil, err
}
return m, nil
}
func readBytes(conn *net.TCPConn, buf []byte) (int, error) {
off := 0
for off != len(buf) {
if err := conn.SetReadDeadline(time.Now().Add(time.Second * 90)); err != nil {
return 0, err
}
if n, err := conn.Read(buf[off:]); err != nil {
return off, err
} else {
off += n
}
}
return off, nil
}
func readDataRoutine(fd int, did string, hash string, conn *net.TCPConn, callback ReadCallback) error {
buf := make([]byte, 1024*32)
for {
log.Println("[getrelayv2]fd=", fd, " Start to Read")
n, err := conn.Read(buf)
conn.SetReadDeadline(time.Now().Add(socket_read_timeout * time.Second))
if err != nil || err == io.EOF {
if err == io.EOF {
if n > 0 { //Recieve Content
is404 := strings.Contains(string(buf), "404 Not Found")
if is404 == true { // Recieve 404 report and close connection, no need to reconnect
closeFD(conn, fd, callback, true, error_404)
log.Println("[getrelayv2]readDataRoutine", " did=", did, " fd=", fd, "EOF&404")
return errors.New("404 found")
}
// Not 404, send to callback and reconnect
callback.ReadBytes(buf[0:n])
log.Println("[getrelayv2]readDataRoutine", "sendcallbac:", string(buf[0:n]))
go reconnect(fd, did, hash, callback)
log.Println("[getrelayv2]readDataRoutine", " did=", did, " fd=", fd, "EOF&Content")
return errors.New("EOF found")
} else { // no content , reconnect again
//closeFD(conn, fd, callback , false, error_none)
log.Println("[getrelayv2]readDataRoutine", " did=", did, " fd=", fd, "EOF")
go reconnect(fd, did, hash, callback)
return nil
}
} else { // Read Error
closeFD(conn, fd, callback, true, mapIoError(err))
log.Println("Read Error =", err)
return errors.New("TCP Read Error:")
}
} // End of EOF or read error
if n > 0 {
is404 := strings.Contains(string(buf), "404 Not Found")
if is404 == true { // Recieve 404 report and close connection, no need to reconnect
closeFD(conn, fd, callback, true, error_404)
log.Println("[getrelayv2]readDataRoutine", " did=", did, " fd=", fd, "404")
return errors.New("404 found")
}
// Not 404
callback.ReadBytes(buf[0:n])
log.Println("[getrelayv2]readDataRoutine", " did=", did, " fd=", fd, " SendToCallback=", string(buf[0:n]))
}
}
return nil
}
func loop(conn *net.TCPConn) {
defer conn.Close()
conn.SetLinger(5)
conn.SetKeepAlive(false)
conn.SetNoDelay(true)
now := time.Now()
conn.SetReadDeadline(now.Add(readWriteLimit))
if _, err := io.ReadFull(conn, buf); err == nil {
conn.Write(response)
}
}
// Demo multiple echo clients.
// 'Test' using 'telnet localhost 45678' from multiple open terminals.
func getData(c *net.TCPConn) {
var buffer = make([]byte, 4096)
a := c.RemoteAddr()
fmt.Printf("Net: %s, Remote: %s\n", a.Network(), a.String())
for {
if shutdown {
fmt.Println(c, "Shutdown")
break
}
fmt.Println(c, "Starting Read ...")
_ = c.SetReadDeadline(time.Now().Add(1 * time.Minute))
bytesRead, err := c.Read(buffer)
if err != nil && err.(net.Error).Timeout() {
continue
}
if err != nil {
fmt.Printf("Error = %v\n", err)
break
}
//
fmt.Println(c, "Bytes Read", bytesRead)
bufData := buffer[0:bytesRead]
fmt.Println(c, "Raw Buffer", bufData)
var data = string(bufData)
fmt.Println(c, "Data Read", data)
//
s := "Echo: " + data
if _, err := c.Write([]byte(s)); err != nil {
fmt.Printf("Error = %v\n", err)
panic("wtfwr01")
}
//
if strings.HasPrefix(data, "quit") {
break
}
//
if strings.HasPrefix(data, "shutdown") {
shutdown = true
}
}
//
fmt.Println(c, "Starting Close() 1")
err := c.Close()
if err != nil {
fmt.Printf("Error = %v\n", err)
panic("wtf05")
}
//
}
func (s *Server) handleConnection(conn *net.TCPConn) {
defer conn.Close()
conn.SetReadDeadline(time.Now().Add(time.Second))
r := bufio.NewReader(conn)
_, err := r.ReadString('\x00')
if err != nil {
if err != io.EOF {
log.Println(err)
}
return
}
conn.Write(s.b)
log.Println("fsp: Sent policy file to", conn.RemoteAddr().String())
}
func (server *Server) setupSocket(conn *net.TCPConn) (err error) {
if err = conn.SetLinger(0); err != nil {
return
}
if server.ConfigReadBuffer != 0 {
if err = conn.SetReadBuffer(int(server.ConfigReadBuffer)); err != nil {
return
}
}
if err = conn.SetKeepAlive(true); err != nil {
return
}
if err = conn.SetReadDeadline(time.Now().Add(server.ConfigIdleTimeout)); err != nil {
return
}
return
}
func handleTCPConn(tcpconn *net.TCPConn, encryptKey []byte, buffer *bytes.Buffer, bpool *bpool.SizedBufferPool) {
defer tcpconn.Close()
defer bpool.Put(buffer)
var receiveData []byte
//tcpconn need read all data in 20 second ,otherwise Timeout() will be true
tcpconn.SetReadDeadline(time.Now().Add(time.Duration(20) * time.Second))
bufReader := bufio.NewReader(tcpconn)
for {
rData, err := bufReader.ReadBytes(',')
if err != nil {
if err == io.EOF {
log.Printf("TCPConn Read error\n")
return
}
buffer.Write(rData)
continue
}
buffer.Write(rData)
receiveData, err = netstring.Unmarshall(buffer.Bytes())
if err != nil {
if err == netstring.ErrNsLenNotEqaulOrgLen {
continue
} else {
log.Printf("netstring unmarshall error : %v\n", err)
return
}
}
break
}
_, err := libsodium.DecryptData(encryptKey, receiveData)
if err != nil {
log.Printf("tcp DecryptData error : %v\n", err)
return
}
tcpconn.SetWriteDeadline(time.Now().Add(time.Duration(20) * time.Second))
_, err = tcpconn.Write(netstring.Marshall([]byte(homeip)))
if err != nil {
log.Printf("tcpconn error : %v\n", err)
}
}
func (cli *MelonClient) Run(conn *net.TCPConn, recvChan chan []MyPacket, closed func(conn *net.TCPConn)) {
var temp string
buffer := make([]byte, 1024)
for {
n, err := conn.Read(buffer)
if err != nil {
closed(conn)
return
}
if n == 0 {
closed(conn)
return
}
conn.SetReadDeadline(time.Now().Add(1 * time.Minute))
remain, pks := CheckPacket(temp + string(buffer[:n]))
recvChan <- pks
temp = remain
}
}
func handleReceivingMsg(conn *net.TCPConn, userid uint64, shouldQuit chan bool) {
defer func() {
shouldQuit <- true
conn.Close()
logger.Info("Close reading connection for user %d")
}()
for {
now := time.Now()
timeout := now.Add(time.Hour * time.Duration(readTimeoutInHour))
conn.SetReadDeadline(timeout)
msgTypeByte := make([]byte, 1)
_, err := io.ReadFull(conn, msgTypeByte)
if err != nil {
logger.Errorf("Connection Read Msg Type Error. Error: %s.", err)
break
}
msgTypeByte = append(make([]byte, 1), msgTypeByte[0])
msgType := uint16(binary.BigEndian.Uint16(msgTypeByte))
msgLenByte := make([]byte, 4)
_, err = io.ReadFull(conn, msgLenByte)
if err != nil {
logger.Errorf("Connection Read Msg Length Error. Error: %s.", err)
break
}
msgLen := int(binary.BigEndian.Uint32(msgLenByte))
buf := make([]byte, int64(msgLen))
_, err = io.ReadFull(conn, buf)
if err != nil {
logger.Errorf("Connection Read Msg Content Error. Error: %s", err)
break
}
connService.HandleReceivingMsg(msgType, buf)
}
}
func handleClient(source *net.TCPConn) {
atomic.AddInt32(&daemon.status.actives, 1)
defer func() {
atomic.AddInt32(&daemon.status.actives, -1)
daemon.wg.Done()
}()
Info("accept new connection: %v", source.RemoteAddr())
source.SetKeepAlive(true)
source.SetKeepAlivePeriod(time.Second * 60)
source.SetLinger(-1)
// read req
// set read request timeout
source.SetReadDeadline(time.Now().Add(time.Second * 30))
err, req := ReadReq(source)
if err != nil {
source.Close()
Error("conn:%v, read req failed: %v", source.RemoteAddr(), err)
return
}
// cancel read timeout
var t time.Time
source.SetReadDeadline(t)
// judge: new conn or reuse conn
switch req := req.(type) {
case *NewConnReq:
Info("new conn request:%v", req)
onNewConn(source, req)
case *ReuseConnReq:
Info("reuse conn request:%v", req)
onReuseConn(source, req)
default:
Info("unknown request:%v", req)
source.Close()
return
}
Info("connection close: %v", source.RemoteAddr())
}
func waitRegister(conn *net.TCPConn) *Client {
conn.SetReadDeadline(time.Now().Add(10 * time.Second))
buf := make([]byte, 10)
n, err := io.ReadFull(conn, buf)
if err != nil {
log.Errorf("readfull header failed (%v)", err)
conn.Close()
return nil
}
var header Header
if err := header.Deserialize(buf[0:n]); err != nil {
log.Errorf("parse header (%v)", err)
conn.Close()
return nil
}
//log.Printf("body len %d", header.Len)
data := make([]byte, header.Len)
if _, err := io.ReadFull(conn, data); err != nil {
log.Errorf("readfull body failed: (%v)", err)
conn.Close()
return nil
}
if header.Type != MSG_REGISTER {
log.Warnf("not register message")
conn.Close()
return nil
}
devid := string(data)
log.Infof("recv register devid (%s)", devid)
if DevMap.Check(devid) {
log.Warnf("device (%s) register already", devid)
conn.Close()
return nil
}
client := InitClient(conn, devid)
return client
}
func (server *Server) addConnection(tcpConn *net.TCPConn) *Connection {
clientId := tcpConn.RemoteAddr().String()
var err error
if server.ConfigDebug {
log.Printf("Server.addConnection: %s", clientId)
}
// TODO: set expected clientLocks to average+1
if err = server.initClientLocks(clientId, 1); err != nil {
log.Printf("Server.addConnection: %s %s", clientId, err.Error())
return nil
}
if err := server.setupSocket(tcpConn); err != nil {
log.Printf("Server.addConnection: %s setupSocket error: %s", clientId, err.Error())
return nil
}
conn := NewConnection(server, clientId)
conn.handlers = map[dlock.RequestType]HandlerFunc{
dlock.RequestType_Ping: handlePing,
dlock.RequestType_Lock: handleLock,
}
conn.funClose = tcpConn.Close
conn.funResetIdleTimeout = func() error { return tcpConn.SetReadDeadline(time.Now().Add(server.ConfigIdleTimeout)) }
conn.funResetReadTimeout = func() error { return tcpConn.SetReadDeadline(time.Now().Add(server.ConfigReadTimeout)) }
conn.funResetWriteTimeout = func() error { return tcpConn.SetWriteDeadline(time.Now().Add(server.ConfigWriteTimeout)) }
if server.ConfigReadBuffer == 0 {
conn.r = bufio.NewReader(tcpConn)
} else {
conn.r = bufio.NewReaderSize(tcpConn, int(server.ConfigReadBuffer))
}
conn.w = bufio.NewWriter(tcpConn)
server.wg.Add(1)
go conn.loop()
return conn
}
