golang melaksanakan fungsi ftp

FTP (Protokol Pemindahan Fail) ialah protokol pemindahan fail biasa yang boleh digunakan untuk memuat naik dan memuat turun fail antara pelayan dan klien. Bahasa Go ialah bahasa pengaturcaraan sumber terbuka dengan kecekapan tinggi dan prestasi serentak. Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk melaksanakan fungsi FTP.

1. Gambaran keseluruhan protokol FTP

Protokol FTP adalah berdasarkan model pelayan pelanggan, di mana pelanggan menghantar permintaan kepada pelayan untuk memuat naik atau memuat turun fail. Program klien FTP menggunakan protokol TCP untuk berkomunikasi dengan pelayan FTP, dan pelayan FTP mendengar pada port 21. Pelanggan FTP menggunakan nombor port yang berbeza untuk komunikasi data dengan pelayan FTP. Protokol FTP biasanya digunakan dalam senario seperti perkongsian fail, pengurusan fail tapak web dan sandaran.

2. Melaksanakan pelayan FTP

Pelayan FTP perlu mendengar port 21 dan menghuraikan arahan FTP yang dihantar oleh klien. Biasanya, klien FTP menghantar nama pengguna dan kata laluan ke pelayan FTP untuk pengesahan. Setelah pengesahan berjaya, klien FTP boleh melaksanakan pelbagai arahan FTP, seperti memuat turun fail, memuat naik fail, memadam fail, dsb.

Berikut ialah contoh kod untuk melaksanakan pelayan FTP:

package main

import (
    "fmt"
    "net"
    "os"
    "bufio"
    "strings"
)

func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Please provide a port number")
        return
    }

    PORT := ":" + arguments[1]
    l, err := net.Listen("tcp4", PORT)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer l.Close()

    fmt.Println("Listening on " + PORT)

    for {
        conn, err := l.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    fmt.Println("Received connection from " + conn.RemoteAddr().String())
    conn.Write([]byte("220 Welcome to FTP Server
"))
    username := ""
    for {
        message, err := bufio.NewReader(conn).ReadString('
')
        if err != nil && err.Error() == "EOF" {
            break
        }
        fmt.Print("Message Received:", string(message))
        command := strings.TrimSpace(string(message))
        parts := strings.Split(command, " ")
        if parts[0] == "USER" {
            username = parts[1]
            conn.Write([]byte("331 Password required for " + username + "
"))
        } else if parts[0] == "PASS" {
            password := parts[1]
            if username == "admin" && password == "password" {
                conn.Write([]byte("230 Logged on
"))
            } else {
                conn.Write([]byte("530 Authentication failed
"))
            }
        } else if parts[0] == "QUIT" {
            conn.Write([]byte("221 Goodbye
"))
            conn.Close()
            break
        } else {
            conn.Write([]byte("500 Command not implemented
"))
        }
    }
}

Dalam contoh ini, pelayan TCP dilaksanakan menggunakan pakej bersih perpustakaan standard. Pelayan mendengar pada nombor port dan memanggil fungsi handleConnection untuk memproses apabila sambungan baharu diterima. Fungsi handleConnection mula-mula menghantar mesej "220 Selamat Datang ke Pelayan FTP" kepada pelanggan. Seterusnya, pelayan menunggu klien menghantar nama pengguna dan kata laluan, dan membaca mesej yang dihantar oleh klien dengan memanggil fungsi ReadString dalam pakej bufio. Jika mesej yang diterima bermula dengan "USER", simpan nama pengguna dan hantar mesej "331 Kata Laluan diperlukan" kepada klien, menunggu klien memasukkan kata laluan. Jika mesej yang diterima bermula dengan "LULUS", sahkan bahawa kata laluan adalah betul. Jika pengesahan berjaya, mesej "230 Log masuk" dihantar kepada pelanggan, menunjukkan bahawa pengguna telah berjaya log masuk. Jika pengesahan kata laluan gagal, mesej "Pengesahan 530 gagal" dihantar kepada pelanggan. Jika mesej yang diterima bermula dengan "QUIT", mesej "221 Goodbye" dihantar kepada klien dan sambungan kepada klien ditutup.

3. Melaksanakan klien FTP

Pelanggan FTP perlu melaksanakan kod untuk berkomunikasi dengan pelayan FTP. Pelanggan FTP biasanya berinteraksi dengan pengguna melalui baris arahan atau antara muka GUI, menyediakan fungsi seperti memuat naik, memuat turun, memadam dan menamakan semula.

Berikut ialah contoh klien FTP mudah:

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Please provide a host:port string")
        return
    }

    CONNECT := arguments[1]
    c, err := net.Dial("tcp4", CONNECT)
    if err != nil {
        fmt.Println(err)
        return
    }

    for {
        message, err := bufio.NewReader(c).ReadString('
')
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Print("Message Received:", string(message))
        if strings.Contains(strings.ToLower(message), "goodbye") {
            return
        }

        fmt.Print(">> ")
        commandReader := bufio.NewReader(os.Stdin)
        command, _ := commandReader.ReadString('
')
        fmt.Fprintf(c, command+"
")
    }
}

Dalam contoh ini, klien FTP dilaksanakan menggunakan pakej bersih dalam perpustakaan standard. Pelanggan berinteraksi dengan pengguna melalui antara muka baris arahan. Pertama, pelanggan menyambung ke pelayan FTP melalui fungsi Dail. Pelanggan kemudiannya terus menerima mesej daripada pelayan FTP dan mencetaknya ke antara muka baris arahan. Seterusnya, klien menunggu pengguna memasukkan arahan dan menghantar arahan ke pelayan FTP melalui fungsi Fprintf. Pelanggan kemudiannya terus menunggu jawapan daripada pelayan FTP.

4. Melaksanakan muat naik dan muat turun fail FTP

Pelanggan FTP boleh menggunakan arahan STOR untuk memuat naik fail dan arahan RETR untuk memuat turun fail. Arahan STOR memuat naik fail ke pelayan FTP, manakala arahan RETR memuat turun fail daripada pelayan FTP.

Berikut ialah contoh muat naik dan muat turun fail FTP yang mudah:

package main

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

func main() {
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Please provide a host:port string")
        return
    }

    CONNECT := arguments[1]
    c, err := net.Dial("tcp4", CONNECT)
    if err != nil {
        fmt.Println(err)
        return
    }

    for {
        var input string
        fmt.Scanln(&input)

        if input == "STOP" {
            fmt.Println("Exiting FTP Client")
            return
        }

        if input == "RETR" {
            fmt.Fprintf(c, input+"
")
            handleFileDownload(c)
        } else if input == "STOR" {
            fmt.Fprintf(c, input+"
")
            handleFileUpload(c)
        } else {
            fmt.Fprintf(c, input+"
")
            handleServerResponse(c)
        }
    }
}

func handleFileDownload(conn net.Conn) {
    var filename string
    fmt.Scanln(&filename)

    file, err := os.Create(filename)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    data := make([]byte, 2048)
    for {
        n, err := conn.Read(data)
        if err != nil && err != io.EOF {
            fmt.Println(err)
            return
        }
        if n == 0 {
            fmt.Println("Download complete")
            return
        }

        _, err = file.Write(data[:n])
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

func handleFileUpload(conn net.Conn) {
    var filename string
    fmt.Scanln(&filename)

    file, err := os.Open(filename)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    fileInfo, err := file.Stat()
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Fprintf(conn, "%d
", fileInfo.Size())
    data := make([]byte, 2048)
    for {
        n, err := file.Read(data)
        if err != nil && err != io.EOF {
            fmt.Println(err)
            return
        }
        if n == 0 {
            fmt.Println("Upload complete")
            return
        }

        _, err = conn.Write(data[:n])
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

func handleServerResponse(conn net.Conn) {
    response := make([]byte, 2048)
    n, err := conn.Read(response)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(response[:n]))
}

Dalam contoh ini, klien FTP melaksanakan perintah "STOR" dan "RETR" untuk memuat naik dan memuat turun fail. Fungsi handleFileUpload membuka fail daripada nama fail yang dimasukkan oleh pengguna dan menghantar saiz fail ke pelayan FTP. Fungsi itu kemudian membaca kandungan fail dalam ketulan dan menghantarnya ke pelayan FTP. Fungsi handleFileDownload menerima data daripada pelayan FTP dan menulisnya ke fail yang baru dibuat. Fungsi handleServerResponse membaca respons daripada pelayan FTP dan mencetaknya ke konsol.

5. Kesimpulan

Pelayan dan klien FTP boleh dilaksanakan dengan mudah menggunakan bahasa Go. Komunikasi antara pelayan FTP dan klien FTP dilaksanakan melalui pakej bersih dan pakej bufio dalam perpustakaan standard. Selain itu, bahasa Go juga menyokong pengaturcaraan serentak yang cekap, yang boleh melaksanakan fungsi muat naik dan muat turun fail FTP dengan lebih baik.

Atas ialah kandungan terperinci golang melaksanakan fungsi ftp. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!