tcp server/client

//server
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net"
    "sync"
)


type Datas struct {
    ID      string      `json:"id"`
    Text    string      `json:"text"`
}


var (
    clients = make(map[net.Conn]string)
    mu sync.Mutex
)


func handleConnection(conn net.Conn, id string) {
    defer func()  {
        conn.Close()
        mu.Lock()
        delete(clients, conn)
        mu.Unlock()
    }()


    for {
        var dec = json.NewDecoder(conn)

        var datas Datas

        if err := dec.Decode(&datas); err != nil {
            return
        }

        fmt.Println(datas)

        mu.Lock()
        for client, roomID := range clients {
            if roomID == id && client != conn {
                if err := json.NewEncoder(client).Encode(&datas); err != nil {
                    log.Println(err)
                    return
                }
            }
        }
        mu.Unlock()
    }
}


func startServer() {
    addr, err := net.ResolveTCPAddr("tcp", ":8000")

    if err != nil {
        log.Println(err)
        return
    }

    ln, err := net.ListenTCP("tcp", addr)

    if err != nil {
        log.Println(err)
        return
    }

    defer ln.Close()

    for {
        conn, err := ln.Accept()

        if err != nil {
            log.Println(err)
            return
        }

        var idB = make([]byte, 1024)

        n, err := conn.Read(idB)

        if err != nil {
            log.Println(err)
            return
        }

        var id = string(idB[:n])

        mu.Lock()
        clients[conn] = id
        mu.Unlock()

        fmt.Println(clients)

        go handleConnection(conn, id)
    }
}

//client
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net"
)


func read(conn net.Conn) {
    for {
        var received Datas

        var dec = json.NewDecoder(conn)

        if err := dec.Decode(&received); err != nil {
            log.Println(err)
            return
        }

        fmt.Println(received.Text)
    }
}


func write(conn net.Conn, id string, username string) {
    for {
        var text string

        if _, err := fmt.Scanln(&text); err != nil {
            log.Println(err)
            return
        }

        var datas = Datas{
            ID: id,
            Text: fmt.Sprintf("%s said %q", username, text),
        }

        var enc = json.NewEncoder(conn)

        if err := enc.Encode(&datas); err != nil {
            log.Println(err)
            return
        }
    }
}


func startClient(id string, username string) {
    conn, err := net.Dial("tcp", "localhost:8000")

    if err != nil {
        log.Println(err)
        return
    }

    if _, err := conn.Write([]byte(id)); err != nil {
        log.Println(err)
        return
    }

    go read(conn)
    go write(conn, id, username)

    select {}
}