How to use network programming functions in Go language to implement FTP client upload files?

How to use network programming functions in Go language to implement FTP client upload files?

Introduction:
FTP (File Transfer Protocol) is the file transfer protocol. It is a standard protocol for file transfer between computers. In network programming, we often need to use the FTP protocol to upload and download files. This article will introduce how to use network programming functions in the Go language to implement the file upload function of the FTP client, and comes with code examples.

Step 1: Import related packages
First, we need to import related packages:

package main

import (
    "fmt"
    "io"
    "log"
    "net"
    "os"
    "path/filepath"
    "strings"
)

Step 2: Establish FTP connection
Next, we need to establish an FTP connection, and Authenticate. In the Go language, you can use the net.Dial() function to establish a TCP connection, and then implement FTP operations by sending and receiving commands. The specific code is as follows:

func ftpConnect(server string, port string) net.Conn {
    conn, err := net.Dial("tcp", server+":"+port)
    if err != nil {
        log.Fatal(err)
    }
    _, err = conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }
    return conn
}

func ftpLogin(conn net.Conn, username string, password string) {
    conn.Write([]byte("USER " + username + "
"))
    _, err := conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }
    conn.Write([]byte("PASS " + password + "
"))
    _, err = conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }
}

Step 3: Upload files
Next, we need to implement the file upload function.

func ftpUpload(conn net.Conn, localFilePath string, remoteFileName string) {
    file, err := os.Open(localFilePath)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    _, err = conn.Write([]byte("TYPE I
"))
    if err != nil {
        log.Fatal(err)
    }

    _, err = conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }

    conn.Write([]byte("PASV
"))
    res := make([]byte, 1024)
    _, err = conn.Read(res)
    if err != nil {
        log.Fatal(err)
    }
    ip, port := parsePASVResponse(string(res))

    conn.Write([]byte("STOR " + remoteFileName + "
"))
    dataConn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", ip, port))
    if err != nil {
        log.Fatal(err)
    }

    _, err = conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }

    buff := make([]byte, 1024)
    for {
        n, err := file.Read(buff)
        if err != nil && err != io.EOF {
            log.Fatal(err)
        }
        if n == 0 {
            break
        }

        _, err = dataConn.Write(buff[:n])
        if err != nil {
            log.Fatal(err)
        }
    }

    _, err = conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }

    dataConn.Close()
}

Step 4: Auxiliary function
In order to facilitate the parsing of the IP address and port number in the PASV response, we also need to write an auxiliary function:

func parsePASVResponse(response string) (string, int) {
    parts := strings.Split(response, "(")
    addressParts := strings.Split(parts[1], ",")
    ip := strings.Join(addressParts[:4], ".")
    port := (toInt(addressParts[4]) << 8) + toInt(addressParts[5])
    return ip, port
}

func toInt(s string) int {
    var result int
    fmt.Sscanf(s, "%d", &result)
    return result
}

Step 5: Test code
Finally, we can write test code and use the above function to upload files:

func main() {
    server := "ftp.example.com"
    port := "21"
    username := "username"
    password := "password"
    localFilePath := "/path/to/local/file.txt"
    remoteFileName := "remote_file.txt"

    conn := ftpConnect(server, port)
    ftpLogin(conn, username, password)
    ftpUpload(conn, localFilePath, remoteFileName)

    conn.Write([]byte("QUIT
"))
    _, err := conn.Read(make([]byte, 1024))
    if err != nil {
        log.Fatal(err)
    }
    conn.Close()

    fmt.Println("File uploaded successfully!")
}

Note: Please change server, port, username in the above code Replace , password, localFilePath, and remoteFileName with the actual FTP server address, port, username, password, local file path, and remote file name.

Summary:
This article introduces the method of using the network programming function in the Go language to implement FTP client uploading files. By establishing FTP connection, login verification and file upload operations, we can easily implement FTP file upload function in Go language. I hope this article can help readers understand and apply network programming functions in Go language and achieve more useful functions.

The above is the detailed content of How to use network programming functions in Go language to implement FTP client upload files?. For more information, please follow other related articles on the PHP Chinese website!