Sample code in Go lang to handle network protocols

1. TCP Server and Client:

go
// TCP Server
package main

import (
    "fmt"
    "net"
)

func main() {
    // Listen on TCP port
    ln, err := net.Listen("tcp", "80")
    if err != nil {
        fmt.Println("Failed to listen:", err)
        return
    }
    defer ln.Close()

    fmt.Println("Listening on 80")

    for {
        // Wait for connection
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println("Failed to accept connection:", err)
            continue
        }

        // Handle the connection in a new goroutine.
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Println("Failed to read from connection:", err)
        return
    }

    fmt.Println("Received:", string(buf[:n]))
    _, err = conn.Write([]byte("Hello, client!"))
    if err != nil {
        fmt.Println("Failed to write to connection:", err)
        return
    }
}

// TCP Client
package main

import (
    "fmt"
    "net"
)

func main() {
    // Connect to the server
    conn, err := net.Dial("tcp", "localhost80")
    if err != nil {
        fmt.Println("Failed to connect:", err)
        return
    }
    defer conn.Close()

    // Send data to the server
    _, err = conn.Write([]byte("Hello, server!"))
    if err != nil {
        fmt.Println("Failed to write to connection:", err)
        return
    }

    // Read the response from the server
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Println("Failed to read from connection:", err)
        return
    }

    fmt.Println("Received:", string(buf[:n]))
}

2. UDP Server and Client:

go
// UDP Server
package main

import (
    "fmt"
    "net"
)

func main() {
    // Listen on UDP port
    addr, err := net.ResolveUDPAddr("udp", "80")
    if err != nil {
        fmt.Println("Failed to resolve UDP address:", err)
        return
    }

    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
        fmt.Println("Failed to listen on UDP port:", err)
        return
    }
    defer conn.Close()

    fmt.Println("Listening on 80")

    buf := make([]byte, 1024)
    for {
        // Read data from the connection
        n, addr, err := conn.ReadFromUDP(buf)
        if err != nil {
            fmt.Println("Failed to read from UDP connection:", err)
            continue
        }

        fmt.Println("Received from", addr, ":", string(buf[:n]))

        // Write a response back to the client
        _, err = conn.WriteToUDP([]byte("Hello, client!"), addr)
        if err != nil {
            fmt.Println("Failed to write to UDP connection:", err)
            continue
        }
    }
}

// UDP Client
package main

import (
    "fmt"
    "net"
)

func main() {
    // Connect to the UDP server
    addr, err := net.ResolveUDPAddr("udp", "localhost80")
    if err != nil {
        fmt.Println("Failed to resolve UDP address:", err)
        return
    }

    conn, err := net.DialUDP("udp", nil, addr)
    if err != nil {
        fmt.Println("Failed to connect to UDP server:", err)
        return
    }
    defer conn.Close()

    // Send data to the server
    _, err = conn.Write([]byte("Hello, server!"))
    if err != nil {
        fmt.Println("Failed to write to UDP connection:", err)
        return
    }

    // Read the response from the server
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Println("Failed to read from UDP connection:", err)
        return
    }

    fmt.Println("Received:", string(buf[:n]))
}

These examples demonstrate how to create a simple TCP and UDP server and client in Go. The TCP example shows how to handle incoming connections in a new goroutine, while the UDP example shows how to read and write data to a UDP connection.

You can use these examples as a starting point to build more complex network protocols in Go, such as HTTP, WebSocket, or custom protocols.