How to implement a simple port forwarding service using Golang

Golang (also known as Go) is an open source programming language developed by Google. Golang has the characteristics of high efficiency, simplicity, and C-like language, so it is widely used in network programming.

In network programming, port forwarding is an important technology. Port forwarding enables an application on one computer, such as a web server, to access an application on another computer. This technology is widely used in server construction, application development, etc. Golang is a language that is very suitable for port forwarding.

Port forwarding in Golang mainly uses the net package. The net package is a very important library in the Go language. It supports a series of network programming functions, including TCP/IP, UDP protocols, etc. In the net package, we can use the Listen function to listen to the local port and the Dial function to connect to the target service address.

Below, we demonstrate how to use Golang to implement a simple port forwarding service.

package main

import (
    "io"
    "log"
    "net"
)

func main() {
    listener, err := net.Listen("tcp", "127.0.0.1:9000")
    if err != nil {
        log.Fatal("listen error:", err)
    }
    defer listener.Close()
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Fatal("accept error:", err)
        }
        go forward(conn)
    }
}

func forward(localConn net.Conn) {
    remoteConn, err := net.Dial("tcp", "remote_server_ip:remote_server_port")
    if err != nil {
        localConn.Close()
        return
    }
    defer remoteConn.Close()
    go io.Copy(localConn, remoteConn)
    io.Copy(remoteConn, localConn)
}

In the above code, we first listen to the local port 9000 through the net.Listen function. When a new connection request arrives, we receive the connection through the listener.Accept function and pass the connection to the forward function.

In the forward function, we connect to the target service address through the net.Dial function. If the connection fails, we close the local connection. If the connection is successful, we start two goroutines at the same time, one is used to forward the data of the local connection to the remote connection, and the other is used to forward the data of the remote connection to the local connection.

Using golang to implement port forwarding is simple and efficient. Golang's coroutine mechanism enables code to have high concurrency, and Golang's memory management mechanism also makes concurrent programs more stable and safe. Therefore, Golang has gradually become the preferred language for many companies and individuals to develop network programming and high-concurrency programs.

The above is the detailed content of How to implement a simple port forwarding service using Golang. For more information, please follow other related articles on the PHP Chinese website!