How do you use the "net" package to implement networking protocols in Go?

In Go, the net package provides extensive networking capabilities, including TCP/IP, UDP protocols, and DNS resolution. Below, I will walk through several steps and examples to demonstrate how to use the net package in Go to implement network protocols.

1. Creating a TCP Server

To implement a TCP server, you need to use the net.Listen function to listen on a port and then use the Accept method to wait for incoming client connection requests.

go
package main

import (
    "fmt"
    "net"
    "os"
)

func main() {
    // Listen on port 8080
    ln, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        return
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Fprintf(os.Stderr, "Connection error: %v\n", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Read error: %v\n", err)
        return
    }
    fmt.Printf("Received message: %s\n", string(buffer[:n]))
    conn.Write([]byte("Received message\n"))
}

2. Creating a TCP Client

Creating a TCP client is straightforward; use net.Dial to connect to the server.

go
package main

import (
    "fmt"
    "net"
)

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

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

    // Receive data
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Read error:", err)
        return
    }
    fmt.Println("Received from server:", string(buffer[:n]))
}

3. Using UDP Protocol

Unlike TCP, UDP is connectionless. Below are simple examples of a UDP server and client.

UDP Server:

go
package main

import (
    "fmt"
    "net"
)

func main() {
    addr := net.UDPAddr{
        Port: 8081,
        IP:   net.ParseIP("127.0.0.1"),
    }
    conn, err := net.ListenUDP("udp", &addr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer conn.Close()

    buffer := make([]byte, 1024)
    for {
        n, remoteAddr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            fmt.Println("Read error:", err)
            continue
        }
        fmt.Printf("Received from %v: %s\n", remoteAddr, string(buffer[:n]))
        conn.WriteToUDP([]byte("Message received\n"), remoteAddr)
    }
}

UDP Client:

go
package main

import (
    "fmt"
    "net"
)

func main() {
    serverAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8081")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    conn, err := net.DialUDP("udp", nil, serverAddr)
    if err != nil {
        fmt.Println("Connection error:", err)
        return
    }
    defer conn.Close()

    _, err = conn.Write([]byte("Hello, UDP server!"))
    if err != nil {
        fmt.Println("Write error:", err)
        return
    }

    buffer := make([]byte, 1024)
    n, _, err := conn.ReadFromUDP(buffer)
    if err != nil {
        fmt.Println("Read error:", err)
        return
    }
    fmt.Println("Received from server:", string(buffer[:n]))
}

These examples demonstrate how to use the net package in Go to create TCP and UDP servers and clients. With these fundamental building blocks, you can build more complex network communication applications.