Code tweaks and added concurrency and transaction requests

Author: Imnotndesh

Receiver/Receiver_handler.go

@@ -6,35 +6,90 @@ import (
 	"log"
 	"net"
 	"os"
+	"strings"
+	"sync"
 )
 
-func StartReceiverServer(port string) {
-	listener, err := net.Listen("tcp", ":"+port)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer listener.Close()
-	conn, err := listener.Accept()
-	if err != nil {
-		log.Fatal(err)
-	}
+const (
+	machinename = "testreceiver"
+	port        = ":9080"
+	network     = "tcp"
+)
+
+func ExtractDataFromMessage(message string) (string, string) {
+	tmpMsg := strings.Split(message, ":")
+	return tmpMsg[0], tmpMsg[1]
+}
+func receiveFile(conn net.Conn, filename string) {
 	defer conn.Close()
-	outfile, err := os.Create("./output")
+	outfile, err := os.Create(filename)
 	if err != nil {
-		log.Fatal(err)
+		log.Panic("Error creating file", err)
 	}
 	defer outfile.Close()
-
 	buffer := make([]byte, 1024)
 	for {
-		n, err := conn.Read(buffer)
+		fileChunks, err := conn.Read(buffer)
 		if err == io.EOF {
 			break
 		}
 		if err != nil {
-			log.Fatal(err)
+			log.Panic("Cannot read from connection")
+		}
+		outfile.Write(buffer[:fileChunks])
+	}
+	fmt.Println("Received file successfully")
+}
+func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
+	defer conn.Close()
+	var response []byte
+	var responseStr string
+	buffer := make([]byte, 1024)
+	senderMsg, err := conn.Read(buffer)
+	if err != nil {
+		log.Println("Error reading from connection")
+		return
+	}
+	requestMsg := string(buffer[:senderMsg])
+	newFilename, senderAlias := ExtractDataFromMessage(requestMsg)
+	fmt.Println("Do you want to receive file : " + newFilename + ", From: " + senderAlias + " : (Y/N)")
+	fmt.Println("Response")
+	fmt.Scanln(&responseStr)
+	if err != nil {
+		log.Panic("Cannot read response from user")
+	}
+	response = []byte(strings.ToUpper(responseStr))
+	_, err = conn.Write(response)
+	if err != nil {
+		log.Panic("Error writing to connection")
+		return
+	}
+	if responseStr == "N" {
+		wg.Done()
+	}
+	receiveFile(conn, newFilename)
+	wg.Done()
+}
+func StartReceiveServer() {
+	server, err := net.Listen(network, port)
+	if err != nil {
+		log.Panic("Cannot start server", err)
+		return
+	}
+	defer server.Close()
+	fmt.Println("Receiver listening on 9080, CTRL+C to stop server")
+	var conn net.Conn
+	var wg sync.WaitGroup
+	for {
+		wg.Add(1)
+		fmt.Println("Waiting for connection...")
+		conn, err = server.Accept()
+		if err != nil {
+			log.Panic("Error accepting connection", err)
+			continue
 		}
-		outfile.Write(buffer[:n])
+		fmt.Println("----------File transfer----------")
+		go handleConnection(conn, &wg)
+		wg.Wait()
 	}
-	fmt.Println("File received successfully")
 }

Sender/Sender_handler.go

@@ -1,39 +1,76 @@
 package Sender
 
 import (
-	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net"
 	"os"
 )
 
-func SendFileToIP(filepath string, receiverIP string) error {
-	var err error
-	file, err := os.Open(filepath)
-	if err != nil {
-		return errors.New("Error opening file: " + err.Error())
-	}
+const (
+	machinename = "testsender"
+	network     = "tcp"
+)
+
+func sendFile(conn net.Conn, filename string) {
+	defer conn.Close()
+	fileBuffer := make([]byte, 1024)
+	file, err := os.Open(filename)
 	defer file.Close()
-	connection, err := net.Dial("tcp", receiverIP)
 	if err != nil {
-		return errors.New("Error establishing a connection ")
+		log.Fatal(err)
 	}
-	defer connection.Close()
-	buffer := make([]byte, 1024)
 	for {
-		n, err := file.Read(buffer)
+		chunks, err := file.Read(fileBuffer)
 		if err == io.EOF {
 			break
 		}
 		if err != nil {
-			log.Println("Error reading file: " + err.Error())
-			os.Exit(1)
+			log.Fatal(err)
 		}
-		_, err = connection.Write(buffer[:n])
+		_, err = conn.Write(fileBuffer[:chunks])
 		if err != nil {
-			return err
+			log.Fatal(err)
+			return
 		}
 	}
-	return nil
+	fmt.Println("Sent successfully to remote")
+}
+func responseListener(conn net.Conn) (string, net.Conn) {
+	buffer := make([]byte, 1024)
+	n, err := conn.Read(buffer)
+	if err != nil {
+		log.Println(err.Error())
+	}
+	return string(buffer[:n]), conn
+}
+
+var requestMessage []byte
+
+func SendToRemoteMachine(filename string, remoteIP string) {
+	receiverIP := remoteIP + ":9080"
+	conn, err := net.Dial(network, receiverIP)
+	if err != nil {
+		log.Println(err)
+	}
+	defer conn.Close()
+	reqString := filename + ":" + machinename
+	requestMessage = []byte(reqString)
+	_, err = conn.Write(requestMessage)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	responseText, establishedConn := responseListener(conn)
+	switch responseText {
+	case "Y":
+		sendFile(establishedConn, filename)
+		os.Exit(0)
+	case "N":
+		fmt.Println("Transfer request denied")
+		os.Exit(0)
+	default:
+		fmt.Println("Invalid response: Switching to default (Stop transfer)")
+		os.Exit(0)
+	}
 }

main.go

@@ -5,31 +5,21 @@ import (
 	"os"
 	"portage/Receiver"
 	"portage/Sender"
+	"strings"
 )
 
-const defaultPort = "8756"
-
 func main() {
-	switch os.Args[1] {
-	case "-s":
-		var filepath = os.Args[2]
+	var modes = strings.ToUpper(os.Args[1])
+	switch modes {
+	case "-S":
+		var file = os.Args[2]
 		var receiverIP = os.Args[3]
-		err := Sender.SendFileToIP(filepath, receiverIP)
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		fmt.Println("File set successfully")
-	case "-r":
-		var customPort = os.Args[2]
-		if customPort == "" {
-			fmt.Println("Starting server at port: " + defaultPort)
-			Receiver.StartReceiverServer(defaultPort)
-		} else {
-			fmt.Println("Starting server at port: " + customPort)
-			Receiver.StartReceiverServer(customPort)
-		}
-	case "-h":
+		Sender.SendToRemoteMachine(file, receiverIP)
+	case "-R":
+		Receiver.StartReceiveServer()
+	default:
+		fallthrough
+	case "-H":
 		fmt.Println("Help Text placeholder")
 	}
 }