Local file copy over TCP socket in Go

socp.go

// Sample usage:
// ./socp -p 10000 -i ~/Downloads/ubuntu-14.04-desktop-amd64.iso -o ~/Desktop/ubuntu.iso
package main

import (
	"bufio"
	"flag"
	"fmt"
	"io"
	"net"
	"os"
	"strconv"
)

func main() {
	var targetFileName = flag.String("o", "", "Target file path")
	var sourceFileName = flag.String("i", "", "Source file path")
	var portPtr = flag.Int("p", 9999, "Operating port")
	flag.Parse()

	if _, err := os.Stat(*sourceFileName); err != nil {
		fmt.Println("Input file does not exist or cannot be read.")
		return
	}
	if _, err := os.Stat(*targetFileName); err == nil {
		fmt.Println("Target file already exists, won't overwrite.")
		return
	}
	portStr := strconv.Itoa(*portPtr)

	done := make(chan string)
	defer close(done)
	listen := make(chan bool)
	defer close(listen)

	go func() {
		outputFile, err := os.Create(*targetFileName)
		if err != nil {
			fmt.Println(err)
		}
		defer outputFile.Close()
		fileWriter := bufio.NewWriter(outputFile)

		serverListener, err := net.Listen("tcp", ":"+portStr)
		if err != nil {
			fmt.Println(err)
		}
		defer serverListener.Close()

		listen <- true

		serverConn, err := serverListener.Accept()
		if err != nil {
			fmt.Println(err)
		}
		defer serverConn.Close()
		serverConnReader := bufio.NewReader(serverConn)

		io.Copy(fileWriter, serverConnReader)
		fileWriter.Flush()
		outputFile.Sync()

		done <- "Writer"
	}()

	<-listen

	go func() {
		inputFile, err := os.Open(*sourceFileName)
		if err != nil {
			fmt.Println(err)
		}
		defer inputFile.Close()
		fileReader := bufio.NewReader(inputFile)

		clientConn, err := net.Dial("tcp", ":"+portStr)
		if err != nil {
			fmt.Println(err)
		}
		defer clientConn.Close()
		clientConnWriter := bufio.NewWriter(clientConn)

		io.Copy(clientConnWriter, fileReader)
		clientConnWriter.Flush()

		done <- "Reader"
	}()

	for i := 0; i < 2; i++ {
		fmt.Println("Done: " + <-done)
	}
}