The gtcp module supports TLS encrypted communication servers and clients, which are essential in scenarios with high security demands. A TLS server can be created using either the NewServerTLS or NewServerKeyCrt methods. A TLS client can be created using either the NewConnKeyCrt or NewConnTLS methods.

    Examples:

    https://github.com/gogf/gf/v2/tree/master/.example/net/gtcp/tls

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/v2/frame/g"
    6.     "github.com/gogf/gf/v2/net/gtcp"
    7.     "github.com/gogf/gf/v2/util/gconv"
    8.     "time"
    9. )
    11. func main() {
    12.     address := "127.0.0.1:8999"
    13.     crtFile := "server.crt"
    14.     keyFile := "server.key"
    15.     // TLS Server
    16.     go gtcp.NewServerKeyCrt(address, crtFile, keyFile, func(conn *gtcp.Conn) {
    17.         defer conn.Close()
    18.         for {
    19.             data, err := conn.Recv(-1)
    20.             if len(data) > 0 {
    21.                 fmt.Println(string(data))
    22.             }
    23.             if err != nil {
    24.                 // if client closes, err will be: EOF
    25.                 g.Log().Error(err)
    26.                 break
    27.             }
    28.         }
    29.     }).Run()
    31.     time.Sleep(time.Second)
    33.     // Client
    34.     conn, err := gtcp.NewConnKeyCrt(address, crtFile, keyFile)
    35.     if err != nil {
    36.         panic(err)
    37.     }
    38.     defer conn.Close()
    39.     for i := 0; i < 10; i++ {
    40.         if err := conn.Send([]byte(gconv.String(i))); err != nil {
    41.             g.Log().Error(err)
    42.         }
    43.         time.Sleep(time.Second)
    44.         if i == 5 {
    45.             conn.Close()
    46.             break
    47.         }
    48.     }
    50.     // exit after 5 seconds
    51.     time.Sleep(5 * time.Second)
    52. }

    After execution, you may see an error reported when the client is running:

    1. panic: x509: certificate has expired or is not yet valid

    This is because our certificate was manually created and has expired. For demonstration purposes, we ignored the client’s verification of the certificate in the client code.

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/v2/net/gtcp"
    6.     "github.com/gogf/gf/v2/util/gconv"
    7.     "time"
    8. )
    10. func main() {
    11.     address := "127.0.0.1:8999"
    12.     crtFile := "server.crt"
    13.     keyFile := "server.key"
    14.     // TLS Server
    15.     go gtcp.NewServerKeyCrt(address, crtFile, keyFile, func(conn *gtcp.Conn) {
    16.         defer conn.Close()
    17.         for {
    18.             data, err := conn.Recv(-1)
    19.             if len(data) > 0 {
    20.                 fmt.Println(string(data))
    21.             }
    22.             if err != nil {
    23.                 // if client closes, err will be: EOF
    24.                 g.Log().Error(err)
    25.                 break
    26.             }
    27.         }
    28.     }).Run()
    30.     time.Sleep(time.Second)
    32.     // Client
    33.     tlsConfig, err := gtcp.LoadKeyCrt(crtFile, keyFile)
    34.     if err != nil {
    35.         panic(err)
    36.     }
    37.     tlsConfig.InsecureSkipVerify = true
    39.     conn, err := gtcp.NewConnTLS(address, tlsConfig)
    40.     if err != nil {
    41.         panic(err)
    42.     }
    43.     defer conn.Close()
    44.     for i := 0; i < 10; i++ {
    45.         if err := conn.Send([]byte(gconv.String(i))); err != nil {
    46.             g.Log().Error(err)
    47.         }
    48.         time.Sleep(time.Second)
    49.         if i == 5 {
    50.             conn.Close()
    51.             break
    52.         }
    53.     }
    55.     // exit after 5 seconds
    56.     time.Sleep(5 * time.Second)
    57. }

    Upon execution, the terminal output is:

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 2019-06-05 00:13:12.488 [ERRO] EOF
    7. Stack:
    8. 1. /Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/v2/geg/net/gtcp/tls/gtcp_server_client.go:25

    Here, the client closes the connection after 5 seconds, resulting in the server receiving an EOF error when receiving data. In practice, this kind of error can be ignored; the server can simply close the client’s connection upon encountering this error.