/*
    文件名：client.go
    client客戶端的示例代碼（未處理粘包問題）
    通過無限循環無時間間隔發送數據給server服務器
    server將會不間斷的出現TCP粘包問題
*/
package main
import (
    "fmt"
    "net"
)
func main() {
    conn, err := net.Dial("tcp", ":9000")
    if err != nil {
        return
    }
    defer conn.Close()
    for {
        s := "Hello, Server!"
        n, err := conn.Write([]byte(s))
        if err != nil {
            fmt.Println("Error:", err)
            fmt.Println("Error N:", n)
            return
        }
        // 這里通過限制發送頻率和時間間隔來解決TCP粘包
        // 雖然能夠實現，但是頻率被限制，效率也會被限制
        // time.Sleep(time.Second * 1)
    }
}

/*
    文件名：server.go
    server服務端的示例代碼（未處理粘包問題）
    服務端接收到數據后立即打印
    此時將會不間斷的出現TCP粘包問題
*/
package main
import (
    "fmt"
    "net"
)
func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        return
    }
    for {
        conn, err := ln.Accept()
        if err != nil {
            continue
        }
        go handleConnection(conn)
    }
}
func handleConnection(conn net.Conn) {
    defer conn.Close()
    tmp := []byte{}
    for {
        buf := make([]byte, 1024)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("Read Error:", err)
            fmt.Println("Read N:", n)
            return
        }
        fmt.Println(string(buf))
    }
}

/*
    文件名：client.go
    使用包長協議，封裝TCP包并循環發送給server服務端
*/
package main
import (
    "encoding/binary"
    "fmt"
    "net"
)
func main() {
    conn, err := net.Dial("tcp", ":9000")
    if err != nil {
        return
    }
    defer conn.Close()
    for {
        s := "Hello, Server!"
        sbytes := make([]byte, 2+len(s))
        binary.BigEndian.PutUint16(sbytes, uint16(len(s)))
        copy(sbytes[2:], []byte(s))
        n, err := conn.Write(sbytes)
        if err != nil {
            fmt.Println("Error:", err)
            fmt.Println("Error N:", n)
            return
        }
        // time.Sleep(time.Second * 1)
    }
}

/*
    文件名：server.go
    使用包長協議，處理接收到的封包數據
    收到的封包數據，可能存在幾種情況：
    1、封包總長度不足2字節（這種情況不能完整獲取包頭），緩存起來與下次獲取的數據拼接
    2、封包總長度剛好2字節，數據長度信息讀出來是0，這種情況可以正常處理并清空緩存
    3、封包總長度大于2字節，數據長度信息大于封包數據實際長度，表示數據包不完整，需要等到下一次讀取再拼接起來
    4、封包總長度大于2字節，數據長度信息等于封包數據實際長度，這種情況（理想情況）可以正常處理并清空緩存
    5、封包總長度大于2字節，數據長度信息小于封包實際長度，表示數據包發生TCP粘包了，讀取實際數據后，將剩余部分緩存起來等待下次拼接
    PS：這里只總結出了這幾種情況，其他未發現的情況還需另外處理
*/
package main
import (
    "encoding/binary"
    "fmt"
    "net"
)
func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        return
    }
    for {
        conn, err := ln.Accept()
        if err != nil {
            continue
        }
        go handleConnection(conn)
    }
}
func handleConnection(conn net.Conn) {
    defer conn.Close()
    tmp := []byte{}
    for {
        buf := make([]byte, 1024)
        // fmt.Println("len:", len(buf), " cap:", cap(buf))
        n, err := conn.Read(buf)
        if err != nil {
            if e, ok := err.(*net.OpError); ok {
                fmt.Println(e.Source, e.Addr, e.Net, e.Op, e.Err)
                if e.Timeout() {
                    fmt.Println("Timeout Error")
                }
            }
            fmt.Println("Read Error:", err)
            fmt.Println("Read N:", n)
            return
        }
        if n == 0 {
            fmt.Println("Read N:", n)
            return
        }
        tmp = append(tmp, buf[:n]...)
        length := len(tmp)
        if length < 2 {
            continue
        }
        if length >= 2 {
            head := make([]byte, 2)
            copy(head, tmp[:2])
            dataLength := binary.BigEndian.Uint16(head)
            data := make([]byte, dataLength)
            copy(data, tmp[2:dataLength+2])
            fmt.Println(string(data)) // 得到數據
            if uint16(length) == 2+dataLength {
                tmp = []byte{}
            } else if uint16(length) > 2+dataLength {
                tmp = tmp[dataLength+2:]
            }
        }
        // fmt.Println(string(buf))
    }
}