Basics of Golang Network Programming

1. Overview#

Network programming is actually a vast field, and this article simply demonstrates how to use Golang's network package for communication.

There are two types of network programming:

TCP socket programming (the mainstream of network programming, based on TCP/IP at the lower level)
B/S structure HTTP programming (when accessing websites using a browser, the HTTP protocol is used, and HTTP is also implemented using TCP sockets at the lower level)

TCP socket programming:

Server processing flow:
- Listen on a port
- Accept TCP requests from clients and establish a connection with the client
- Create a goroutine to handle the requests for that connection
Client processing flow:
- Establish a connection with the server
- Send request data and receive the results returned by the server
- Close the connection

2. Internet Layered Model#

The logical implementation of the Internet is divided into several layers, each responsible for its own content, much like a building where each layer requires support from the layer below. Most of what we encounter is the topmost layer, which is encapsulated layer by layer and presented to us in the most user-friendly way.

3. Several Core Network Packages#

3.1 net#

The net.Dial() method is used for the client to connect to the network.

The net.Listen() method is used for the server to accept network connections.

3.2 net/http#

The net/http package provides functions for developing powerful web servers and clients.

The http.Get() and https.Get() methods can be used by the client to send HTTP and HTTPS requests.

The http.ListenAndServe() method can be used to create a web server, specifying the IP address and TCP port number that the server listens on, and then handle incoming requests in that method.

3.3 http.RoundTripper#

RoundTripper can be seen as middleware for http.Client.

Use cases:

Caching HTTP responses (if cache exists, retrieve directly from the cache)
Setting appropriate HTTP headers
Rate limiting

Reference Link

4. Go Implementation of DNS Query#

The role of DNS (Domain Name System) is to convert IP addresses to domain names or to convert domain names to IP addresses.

package main
import (
	"fmt"
	"net"
	"os"
)
func main() {
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Please provide an argument!")
		return
	}
	input := arguments[1]
	IPaddress := net.ParseIP(input)  // The function net.ParseIP parses the input string into an IP address
	if IPaddress == nil {
		IPs, err := lookHostname(input)
		if err == nil {
			for _, singleIP := range IPs {
				fmt.Println(singleIP)
			}
		}
	} else {
		hosts, err := lookIP(input)
		if err == nil {
			for _, hostname := range hosts {
				fmt.Println(hostname)
			}
		}
	}
}
func lookIP(address string) ([]string, error) {
	hosts, err := net.LookupAddr(address) // Returns a list of hosts matching the provided IP address (/etc/hosts)
	if err != nil {
		return nil, err
	}
	return hosts, nil
}
func lookHostname(hostname string) ([]string, error) {
	IPs, err := net.LookupHost(hostname) // Returns a list of IP addresses matching the provided hostname
	if err != nil {
		return nil, err
	}
	return IPs, nil
}

5. Go Implementation of Web Functionality#

You can use Go's standard library functions to implement a web server.

If you need a truly powerful web server, it is still recommended to use web servers like Apache or Nginx.

5.1 Web Server#

package main
import (
	"fmt"
	"net/http"
	"os"
	"time"
)
func main() {
	PORT := ":8001"
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Using default port number: ", PORT)
	}else{
		PORT = ":" + arguments[1]
	}
	http.HandleFunc("/time", timeHandler) // Associate a URL route with a handler function
	http.HandleFunc("/", myHandler)
	err := http.ListenAndServe(PORT, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
}
func myHandler(w http.ResponseWriter, r *http.Request) { 
	fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
	fmt.Printf("Served: %s\n", r.Host)
}
func timeHandler(w http.ResponseWriter, r *http.Request) { 
	t := time.Now().Format(time.RFC1123)
	Body := "The current time is:" // Dynamic output
	fmt.Fprintf(w, "<h1 align=\"center\">%s</h1>", Body)
	fmt.Fprintf(w, "<h2 align=\"center\">%s</h2>\n", t)
	fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
	fmt.Fprintf(w, "Served time for: %s\n", r.Host)
}

5.2 Web Client#

package main
import (
	"fmt"
	"net/http"
	"net/http/httputil"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"time"
)
func main() {
	if len(os.Args) != 2 {
		fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0]))
		return
	}
	URL, err := url.Parse(os.Args[1]) // Parse the provided URL
	if err != nil {
		fmt.Println("Error in parsing:", err)
		return
	}
	c := &http.Client{
		Timeout: 15 * time.Second,
	}
	request, err := http.NewRequest("GET", URL.String(), nil)
	if err != nil {
		fmt.Println("Get:", err)
		return
	}
	httpData, err := c.Do(request)
	if err != nil {
		fmt.Println("Error in Do():", err)
		return
	}
	fmt.Println("Status code:", httpData.Status)
	header, _ := httputil.DumpResponse(httpData, false)
	fmt.Println(string(header))
	contentType := httpData.Header.Get("Content-Type")
	characterSet := strings.SplitAfter(contentType, "charset=")
	if len(characterSet) > 1 {
		fmt.Println("Character Set:", characterSet[1])
	}
	if httpData.ContentLength == -1 {
		fmt.Println("ContentLength is unknown!")
	} else {
		fmt.Println("ContentLength:", httpData.ContentLength)
	}
	length := 0
	var buffer [1024]byte
	r := httpData.Body
	for {
		n, err := r.Read(buffer[0:])
		if err != nil {
			fmt.Println(err)
			break
		}
		length = length + n
	}
	fmt.Println("Calculated response data length:", length)
}

6. Go Implementation of TCP Functionality#

6.1 TCP Server#

package main
import(
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
	"time"
)
func main() {
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Please provide port number")
		return
	}
	PORT := ":" + arguments[1]
	l, err := net.Listen("tcp" , PORT)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer l.Close()
	c, err := l.Accept()
	if err != nil {
		fmt.Println(err)
		return
	}
	for {
		netData, err := bufio.NewReader(c).ReadString('\n')
		if err != nil {
			fmt.Println(err)
			return
		}
		if strings.TrimSpace(string(netData)) == "STOP" {
			fmt.Println("Exiting TCP server!")
			return
		}
		fmt.Print("-> ", string(netData))
		t := time.Now()
		myTime := t.Format(time.RFC3339) + "\n"
		c.Write([]byte(myTime))
	}
}

6.2 TCP Client#

package main
import (
	"bufio"
	"fmt"
	"net"
	"os"
	"strings"
)
func main(){
	arguments := os.Args
	if len(arguments) == 1 {
		fmt.Println("Please provide host:port.")
		return
	}
	CONNECT := arguments[1]
	c, err := net.Dial("tcp", CONNECT)
	if err != nil {
		fmt.Println(err)
		return
	}
	for {
		reader := bufio.NewReader(os.Stdin)
		fmt.Print(">> ")
		text, _ := reader.ReadString('\n')
		fmt.Fprintf(c, text + "\n")
		message, _ := bufio.NewReader(c).ReadString('\n')
		fmt.Print("->: " + message)
		if strings.TrimSpace(string(text)) == "STOP" {
			fmt.Println("TCP client exiting...")
			return
		}
	}
}

7. Go Implementation of UDP Functionality#

7.1 UDP Server#

package main

import (
	"fmt"
	"net"
)

func main() {
	// Create listener
	socket, err := net.ListenUDP("udp4", &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 8080,
	})
	if err != nil {
		fmt.Println("Listening failed!", err)
		return
	}
	defer socket.Close()

	for {
		// Loop to read data
		data := make([]byte, 4096)
		read, remoteAddr, err := socket.ReadFromUDP(data)
		if err != nil {
			fmt.Println("Failed to read data!", err)
			continue
		}
		fmt.Println(read, remoteAddr)
		fmt.Printf("%s\n\n", data)

		// Send data
		senddata := []byte("hello client!")
		_, err = socket.WriteToUDP(senddata, remoteAddr)
		if err != nil {
			return
			fmt.Println("Failed to send data!", err)
		}
	}
}

7.2 UDP Client#

package main

import (
	"fmt"
	"net"
)

func main() {
	// Create connection
	socket, err := net.DialUDP("udp4", nil, &net.UDPAddr{
		IP:   net.IPv4(192, 168, 110, 110),
		Port: 8080,
	})
	if err != nil {
		fmt.Println("Connection failed!", err)
		return
	}
	defer socket.Close()

	// Send data
	senddata := []byte("hello server!")
	_, err = socket.Write(senddata)
	if err != nil {
		fmt.Println("Failed to send data!", err)
		return
	}

	// Receive data
	data := make([]byte, 4096)
	read, remoteAddr, err := socket.ReadFromUDP(data)
	if err != nil {
		fmt.Println("Failed to read data!", err)
		return
	}
	fmt.Println(read, remoteAddr)
	fmt.Printf("%s\n", data)
}

8. Summary#

This article mainly introduces the Go version of web servers, clients, TCP servers, clients, and UDP servers, clients, as well as the concept of network layering, Go version DNS queries, and several network packages.