How to use network programming functions in Go language to implement FTP client upload files?-Golang-php.cn

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

WBOY

Release： 2023-07-30 18:47:09

Original

1278 people have browsed it

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"
)

Copy after login

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)
    }
}

Copy after login

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()
}

Copy after login

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
}

Copy after login

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!")
}

Copy after login

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!