Golang -- realize file transfer

With the help of TCP Complete the file transfer , The basic idea is as follows ：

1. The sender （ client ） Send the file name to the server , The server saves the file name .
2. The receiving party （ Server side ） Return a message to the client ok, Confirm that the file name is saved successfully .
3. The sender （ client ） After receiving the message , Start sending file data to the server .
4. The receiving party （ Server side ） Read file contents , Write to the previously saved file .

First get the file name . With the help of os In bag stat() Function to get file attribute information . The file attribute returned by the function contains the file name and file size .Stat Parameters name What is passed in is the absolute path of file access .FileInfo Medium Name() Function can extract the list of files .

func Stat(name string) (FileInfo, error) 
type FileInfo interface {
    
   Name() string       
   Size() int64        
   Mode() FileMode     
   ModTime() time.Time 
   IsDir() bool        
   Sys() interface{
    }   
}

The sender ：

package main

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

func sendFile(conn net.Conn, filePath string) {
    
	//  Read only open file 
	f, err := os.Open(filePath)
	if err != nil {
    
		fmt.Println("os.Open err:", err)
		return
	}
	defer f.Close()

	//  From this document , Reading data , Write to the network receiver .  How much do you read , How much to write . Wholly intact .
	buf := make([]byte, 1024)
	for {
    
		n, err := f.Read(buf)
		if err != nil {
    
			if err == io.EOF {
    
				fmt.Println(" Send file complete .")
			} else {
    
				fmt.Println("os.Open err:", err)
			}
			return
		}
		//  Write to the network socket in 
		_, err = conn.Write(buf[:n])
		if err != nil {
    
			fmt.Println("conn.Write err:", err)
			return
		}
	}
}

func main() {
    
	list := os.Args //  Get command line parameters 

	if len(list) != 2 {
    
		fmt.Println(" The format is ：go run xxx.go  File absolute path ")
		return
	}
	//  extract   The absolute path to the file 
	filePath := list[1]

	// Extract filename 
	fileInfo, err := os.Stat(filePath)
	if err != nil {
    
		fmt.Println("os.Stat err:", err)
		return
	}
	fileName := fileInfo.Name()

	//  Initiate a connection request 
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
    
		fmt.Println("net.Dial err:", err)
		return
	}
	defer conn.Close()

	//  Send the file name to   The receiver 
	_, err = conn.Write([]byte(fileName))
	if err != nil {
    
		fmt.Println("conn.Write err:", err)
		return
	}
	//  Read the message sent back by the server  OK
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
    
		fmt.Println("conn.Read err:", err)
		return
	}

	if "ok" == string(buf[:n]) {
    
		//  Write the contents of the file to the server —— With the help of conn
		sendFile(conn, filePath)
	}
}

The receiver ：

package main

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

func recvFile(conn net.Conn, fileName string) {
    
	//  Create a new file by file name 
	f, err := os.Create(fileName)
	if err != nil {
    
		fmt.Println("os.Create err:", err)
		return
	}
	defer f.Close()

	//  from   Read data in the network , Write to local file 
	buf := make([]byte, 1024)
	for {
    
		n, _ := conn.Read(buf)
		if n == 0 {
    
			fmt.Println(" Receive file complete .")
			return
		}
		//  Write to local file , How much do you read , How much to write .
		f.Write(buf[:n])
	}
}

func main() {
    
	//  Create a for listening socket
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
    
		fmt.Println(" net.Listen err:", err)
		return
	}
	defer listener.Close()

	fmt.Println(" The receiving end is started successfully , Wait for the sender to send the file ！")

	//  Blocking monitor 
	conn, err := listener.Accept()
	if err != nil {
    
		fmt.Println(" listener.Accept() err:", err)
		return
	}
	defer conn.Close()

	//  Get the file name , preservation 
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
    
		fmt.Println(" conn.Read err:", err)
		return
	}
	fileName := string(buf[:n])

	//  Write back  ok  To the sender 
	conn.Write([]byte("ok"))

	//  Get file content 
	recvFile(conn, fileName)
}