X-Git-Url: https://git.r.bdr.sh/rbdr/mobius/blobdiff_plain/92a7e455a347e5be7fb69b6846b9f27ca698ae12..0a92e50b2704c1eb02233c9aa5778d21455d345b:/hotline/server.go?ds=sidebyside

diff --git a/hotline/server.go b/hotline/server.go
index 2ee31cf..cf022fc 100644
--- a/hotline/server.go
+++ b/hotline/server.go
@@ -7,8 +7,8 @@ import (
 	"fmt"
 	"go.uber.org/zap"
 	"io"
+	"io/fs"
 	"io/ioutil"
-	"log"
 	"math/big"
 	"math/rand"
 	"net"
@@ -21,8 +21,7 @@ import (
 	"sync"
 	"time"
 
-	"golang.org/x/crypto/bcrypt"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -50,8 +49,8 @@ type Server struct {
 	APIListener  net.Listener
 	FileListener net.Listener
 
-	newsReader io.Reader
-	newsWriter io.WriteCloser
+	// newsReader io.Reader
+	// newsWriter io.WriteCloser
 
 	outbox chan Transaction
 
@@ -93,7 +92,7 @@ func (s *Server) ServeFileTransfers(ln net.Listener) error {
 		}
 
 		go func() {
-			if err := s.TransferFile(conn); err != nil {
+			if err := s.handleFileTransfer(conn); err != nil {
 				s.Logger.Errorw("file transfer error", "reason", err)
 			}
 		}()
@@ -111,7 +110,7 @@ func (s *Server) sendTransaction(t Transaction) error {
 	client := s.Clients[uint16(clientID)]
 	s.mux.Unlock()
 	if client == nil {
-		return errors.New("invalid client")
+		return fmt.Errorf("invalid client id %v", *t.clientID)
 	}
 	userName := string(client.UserName)
 	login := client.Account.Login
@@ -169,7 +168,7 @@ func (s *Server) Serve(ctx context.Context, cancelRoot context.CancelFunc, ln ne
 }
 
 const (
-	agreementFile    = "Agreement.txt"
+	agreementFile = "Agreement.txt"
 )
 
 // NewServer constructs a new Server from a config dir
@@ -278,8 +277,8 @@ func (s *Server) keepaliveHandler() {
 		s.mux.Lock()
 
 		for _, c := range s.Clients {
-			*c.IdleTime += idleCheckInterval
-			if *c.IdleTime > userIdleSeconds && !c.Idle {
+			c.IdleTime += idleCheckInterval
+			if c.IdleTime > userIdleSeconds && !c.Idle {
 				c.Idle = true
 
 				flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(*c.Flags)))
@@ -327,15 +326,13 @@ func (s *Server) NewClientConn(conn net.Conn) *ClientConn {
 		Connection: conn,
 		Server:     s,
 		Version:    &[]byte{},
-		IdleTime:   new(int),
-		AutoReply:  &[]byte{},
+		AutoReply:  []byte{},
 		Transfers:  make(map[int][]*FileTransfer),
+		Agreed:     false,
 	}
 	*s.NextGuestID++
 	ID := *s.NextGuestID
 
-	*clientConn.IdleTime = 0
-
 	binary.BigEndian.PutUint16(*clientConn.ID, ID)
 	s.Clients[ID] = clientConn
 
@@ -359,7 +356,39 @@ func (s *Server) NewUser(login, name, password string, access []byte) error {
 	}
 	s.Accounts[login] = &account
 
-	return ioutil.WriteFile(s.ConfigDir+"Users/"+login+".yaml", out, 0666)
+	return FS.WriteFile(s.ConfigDir+"Users/"+login+".yaml", out, 0666)
+}
+
+func (s *Server) UpdateUser(login, newLogin, name, password string, access []byte) error {
+	s.mux.Lock()
+	defer s.mux.Unlock()
+
+	fmt.Printf("login: %v, newLogin: %v: ", login, newLogin)
+
+	// update renames the user login
+	if login != newLogin {
+		err := os.Rename(s.ConfigDir+"Users/"+login+".yaml", s.ConfigDir+"Users/"+newLogin+".yaml")
+		if err != nil {
+			return err
+		}
+		s.Accounts[newLogin] = s.Accounts[login]
+		delete(s.Accounts, login)
+	}
+
+	account := s.Accounts[newLogin]
+	account.Access = &access
+	account.Name = name
+	account.Password = password
+
+	out, err := yaml.Marshal(&account)
+	if err != nil {
+		return err
+	}
+	if err := os.WriteFile(s.ConfigDir+"Users/"+newLogin+".yaml", out, 0666); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // DeleteUser deletes the user account
@@ -369,7 +398,7 @@ func (s *Server) DeleteUser(login string) error {
 
 	delete(s.Accounts, login)
 
-	return os.Remove(s.ConfigDir + "Users/" + login + ".yaml")
+	return FS.Remove(s.ConfigDir + "Users/" + login + ".yaml")
 }
 
 func (s *Server) connectedUsers() []Field {
@@ -377,7 +406,10 @@ func (s *Server) connectedUsers() []Field {
 	defer s.mux.Unlock()
 
 	var connectedUsers []Field
-	for _, c := range s.Clients {
+	for _, c := range sortedClients(s.Clients) {
+		if !c.Agreed {
+			continue
+		}
 		user := User{
 			ID:    *c.ID,
 			Icon:  *c.Icon,
@@ -396,7 +428,6 @@ func (s *Server) loadThreadedNews(threadedNewsPath string) error {
 		return err
 	}
 	decoder := yaml.NewDecoder(fh)
-	decoder.SetStrict(true)
 
 	return decoder.Decode(s.ThreadedNews)
 }
@@ -413,14 +444,13 @@ func (s *Server) loadAccounts(userDir string) error {
 	}
 
 	for _, file := range matches {
-		fh, err := os.Open(file)
+		fh, err := FS.Open(file)
 		if err != nil {
 			return err
 		}
 
 		account := Account{}
 		decoder := yaml.NewDecoder(fh)
-		decoder.SetStrict(true)
 		if err := decoder.Decode(&account); err != nil {
 			return err
 		}
@@ -431,13 +461,12 @@ func (s *Server) loadAccounts(userDir string) error {
 }
 
 func (s *Server) loadConfig(path string) error {
-	fh, err := os.Open(path)
+	fh, err := FS.Open(path)
 	if err != nil {
 		return err
 	}
 
 	decoder := yaml.NewDecoder(fh)
-	decoder.SetStrict(true)
 	err = decoder.Decode(s.Config)
 	if err != nil {
 		return err
@@ -536,9 +565,21 @@ func (s *Server) handleNewConnection(conn net.Conn) error {
 	// Show agreement to client
 	c.Server.outbox <- *NewTransaction(tranShowAgreement, c.ID, NewField(fieldData, s.Agreement))
 
-	if _, err := c.notifyNewUserHasJoined(); err != nil {
-		return err
+	// assume simplified hotline v1.2.3 login flow that does not require agreement
+	if *c.Version == nil {
+		c.Agreed = true
+
+		c.notifyOthers(
+			*NewTransaction(
+				tranNotifyChangeUser, nil,
+				NewField(fieldUserName, c.UserName),
+				NewField(fieldUserID, *c.ID),
+				NewField(fieldUserIconID, *c.Icon),
+				NewField(fieldUserFlags, *c.Flags),
+			),
+		)
 	}
+
 	c.Server.Stats.LoginCount += 1
 
 	const readBuffSize = 1024000 // 1KB - TODO: what should this be?
@@ -571,21 +612,6 @@ func (s *Server) handleNewConnection(conn net.Conn) error {
 	}
 }
 
-func hashAndSalt(pwd []byte) string {
-	// Use GenerateFromPassword to hash & salt pwd.
-	// MinCost is just an integer constant provided by the bcrypt
-	// package along with DefaultCost & MaxCost.
-	// The cost can be any value you want provided it isn't lower
-	// than the MinCost (4)
-	hash, err := bcrypt.GenerateFromPassword(pwd, bcrypt.MinCost)
-	if err != nil {
-		log.Println(err)
-	}
-	// GenerateFromPassword returns a byte slice so we need to
-	// convert the bytes to a string and return it
-	return string(hash)
-}
-
 // NewTransactionRef generates a random ID for the file transfer.  The Hotline client includes this ID
 // in the file transfer request payload, and the file transfer server will use it to map the request
 // to a transfer
@@ -617,22 +643,45 @@ const dlFldrActionSendFile = 1
 const dlFldrActionResumeFile = 2
 const dlFldrActionNextFile = 3
 
-func (s *Server) TransferFile(conn net.Conn) error {
-	defer func() { _ = conn.Close() }()
+// handleFileTransfer receives a client net.Conn from the file transfer server, performs the requested transfer type, then closes the connection
+func (s *Server) handleFileTransfer(conn io.ReadWriteCloser) error {
+	defer func() {
+
+		if err := conn.Close(); err != nil {
+			s.Logger.Errorw("error closing connection", "error", err)
+		}
+	}()
 
-	buf := make([]byte, 1024)
-	if _, err := conn.Read(buf); err != nil {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("stacktrace from panic: \n" + string(debug.Stack()))
+			s.Logger.Errorw("PANIC", "err", r, "trace", string(debug.Stack()))
+		}
+	}()
+
+	txBuf := make([]byte, 16)
+	if _, err := io.ReadFull(conn, txBuf); err != nil {
 		return err
 	}
 
 	var t transfer
-	_, err := t.Write(buf[:16])
-	if err != nil {
+	if _, err := t.Write(txBuf); err != nil {
 		return err
 	}
 
 	transferRefNum := binary.BigEndian.Uint32(t.ReferenceNumber[:])
-	fileTransfer := s.FileTransfers[transferRefNum]
+	defer func() {
+		s.mux.Lock()
+		delete(s.FileTransfers, transferRefNum)
+		s.mux.Unlock()
+	}()
+
+	s.mux.Lock()
+	fileTransfer, ok := s.FileTransfers[transferRefNum]
+	s.mux.Unlock()
+	if !ok {
+		return errors.New("invalid transaction ID")
+	}
 
 	switch fileTransfer.Type {
 	case FileDownload:
@@ -641,20 +690,23 @@ func (s *Server) TransferFile(conn net.Conn) error {
 			return err
 		}
 
-		ffo, err := NewFlattenedFileObject(
-			s.Config.FileRoot,
-			fileTransfer.FilePath,
-			fileTransfer.FileName,
-		)
+		var dataOffset int64
+		if fileTransfer.fileResumeData != nil {
+			dataOffset = int64(binary.BigEndian.Uint32(fileTransfer.fileResumeData.ForkInfoList[0].DataSize[:]))
+		}
+
+		ffo, err := NewFlattenedFileObject(s.Config.FileRoot, fileTransfer.FilePath, fileTransfer.FileName, dataOffset)
 		if err != nil {
 			return err
 		}
 
-		s.Logger.Infow("File download started", "filePath", fullFilePath, "transactionRef", fileTransfer.ReferenceNumber, "RemoteAddr", conn.RemoteAddr().String())
+		s.Logger.Infow("File download started", "filePath", fullFilePath, "transactionRef", fileTransfer.ReferenceNumber)
 
-		// Start by sending flat file object to client
-		if _, err := conn.Write(ffo.BinaryMarshal()); err != nil {
-			return err
+		if fileTransfer.options == nil {
+			// Start by sending flat file object to client
+			if _, err := conn.Write(ffo.BinaryMarshal()); err != nil {
+				return err
+			}
 		}
 
 		file, err := FS.Open(fullFilePath)
@@ -663,75 +715,52 @@ func (s *Server) TransferFile(conn net.Conn) error {
 		}
 
 		sendBuffer := make([]byte, 1048576)
+		var totalSent int64
 		for {
 			var bytesRead int
-			if bytesRead, err = file.Read(sendBuffer); err == io.EOF {
+			if bytesRead, err = file.ReadAt(sendBuffer, dataOffset+totalSent); err == io.EOF {
+				if _, err := conn.Write(sendBuffer[:bytesRead]); err != nil {
+					return err
+				}
 				break
 			}
+			if err != nil {
+				return err
+			}
+			totalSent += int64(bytesRead)
 
 			fileTransfer.BytesSent += bytesRead
 
-			delete(s.FileTransfers, transferRefNum)
-
 			if _, err := conn.Write(sendBuffer[:bytesRead]); err != nil {
 				return err
 			}
 		}
 	case FileUpload:
-		if _, err := conn.Read(buf); err != nil {
-			return err
-		}
-
-		ffo := ReadFlattenedFileObject(buf)
-		payloadLen := len(ffo.BinaryMarshal())
-		fileSize := int(binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize))
-
 		destinationFile := s.Config.FileRoot + ReadFilePath(fileTransfer.FilePath) + "/" + string(fileTransfer.FileName)
-		s.Logger.Infow(
-			"File upload started",
-			"transactionRef", fileTransfer.ReferenceNumber,
-			"RemoteAddr", conn.RemoteAddr().String(),
-			"size", fileSize,
-			"dstFile", destinationFile,
-		)
+		tmpFile := destinationFile + ".incomplete"
 
-		newFile, err := os.Create(destinationFile)
-		if err != nil {
-			return err
+		file, err := effectiveFile(destinationFile)
+		if errors.Is(err, fs.ErrNotExist) {
+			file, err = FS.Create(tmpFile)
+			if err != nil {
+				return err
+			}
 		}
 
-		defer func() { _ = newFile.Close() }()
+		defer func() { _ = file.Close() }()
 
-		const buffSize = 1024
+		s.Logger.Infow("File upload started", "transactionRef", fileTransfer.ReferenceNumber, "dstFile", destinationFile)
 
-		if _, err := newFile.Write(buf[payloadLen:]); err != nil {
+		// TODO: replace io.Discard with a real file when ready to implement storing of resource fork data
+		if err := receiveFile(conn, file, io.Discard); err != nil {
 			return err
 		}
-		receivedBytes := buffSize - payloadLen
-
-		for {
-			if (fileSize - receivedBytes) < buffSize {
-				s.Logger.Infow(
-					"File upload complete",
-					"transactionRef", fileTransfer.ReferenceNumber,
-					"RemoteAddr", conn.RemoteAddr().String(),
-					"size", fileSize,
-					"dstFile", destinationFile,
-				)
 
-				if _, err := io.CopyN(newFile, conn, int64(fileSize-receivedBytes)); err != nil {
-					return fmt.Errorf("file transfer failed: %s", err)
-				}
-				return nil
-			}
-
-			// Copy N bytes from conn to upload file
-			n, err := io.CopyN(newFile, conn, buffSize)
-			if err != nil {
-				return err
-			}
-			receivedBytes += int(n)
+		if err := os.Rename(destinationFile+".incomplete", destinationFile); err != nil {
+			return err
 		}
+
+		s.Logger.Infow("File upload complete", "transactionRef", fileTransfer.ReferenceNumber, "dstFile", destinationFile)
 	case FolderDownload:
 		// Folder Download flow:
 		// 1. Get filePath from the transfer
@@ -749,7 +778,7 @@ func (s *Server) TransferFile(conn net.Conn) error {
 		//			[2]byte // Resume data size
 		//			[]byte file resume data (see myField_FileResumeData)
 		//
-		// 3. Otherwise download of the file is requested and client sends []byte{0x00, 0x01}
+		// 3. Otherwise, download of the file is requested and client sends []byte{0x00, 0x01}
 		//
 		// When download is requested (case 2 or 3), server replies with:
 		// 			[4]byte - file size
@@ -767,22 +796,28 @@ func (s *Server) TransferFile(conn net.Conn) error {
 
 		basePathLen := len(fullFilePath)
 
-		readBuffer := make([]byte, 1024)
+		s.Logger.Infow("Start folder download", "path", fullFilePath, "ReferenceNumber", fileTransfer.ReferenceNumber)
 
-		s.Logger.Infow("Start folder download", "path", fullFilePath, "ReferenceNumber", fileTransfer.ReferenceNumber, "RemoteAddr", conn.RemoteAddr())
+		nextAction := make([]byte, 2)
+		if _, err := conn.Read(nextAction); err != nil {
+			return err
+		}
 
 		i := 0
-		_ = filepath.Walk(fullFilePath+"/", func(path string, info os.FileInfo, _ error) error {
+		err = filepath.Walk(fullFilePath+"/", func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
 			i += 1
-			subPath := path[basePathLen:]
+			subPath := path[basePathLen+1:]
 			s.Logger.Infow("Sending fileheader", "i", i, "path", path, "fullFilePath", fullFilePath, "subPath", subPath, "IsDir", info.IsDir())
 
-			fileHeader := NewFileHeader(subPath, info.IsDir())
-
 			if i == 1 {
 				return nil
 			}
 
+			fileHeader := NewFileHeader(subPath, info.IsDir())
+
 			// Send the file header to client
 			if _, err := conn.Write(fileHeader.Payload()); err != nil {
 				s.Logger.Errorf("error sending file header: %v", err)
@@ -790,12 +825,37 @@ func (s *Server) TransferFile(conn net.Conn) error {
 			}
 
 			// Read the client's Next Action request
-			//TODO: Remove hardcoded behavior and switch behaviors based on the next action send
-			if _, err := conn.Read(readBuffer); err != nil {
+			if _, err := conn.Read(nextAction); err != nil {
 				return err
 			}
 
-			s.Logger.Infow("Client folder download action", "action", fmt.Sprintf("%X", readBuffer[0:2]))
+			s.Logger.Infow("Client folder download action", "action", fmt.Sprintf("%X", nextAction[0:2]))
+
+			var dataOffset int64
+
+			switch nextAction[1] {
+			case dlFldrActionResumeFile:
+				// client asked to resume this file
+				var frd FileResumeData
+				// get size of resumeData
+				if _, err := conn.Read(nextAction); err != nil {
+					return err
+				}
+
+				resumeDataLen := binary.BigEndian.Uint16(nextAction)
+				resumeDataBytes := make([]byte, resumeDataLen)
+				if _, err := conn.Read(resumeDataBytes); err != nil {
+					return err
+				}
+
+				if err := frd.UnmarshalBinary(resumeDataBytes); err != nil {
+					return err
+				}
+				dataOffset = int64(binary.BigEndian.Uint32(frd.ForkInfoList[0].DataSize[:]))
+			case dlFldrActionNextFile:
+				// client asked to skip this file
+				return nil
+			}
 
 			if info.IsDir() {
 				return nil
@@ -803,18 +863,13 @@ func (s *Server) TransferFile(conn net.Conn) error {
 
 			splitPath := strings.Split(path, "/")
 
-			ffo, err := NewFlattenedFileObject(
-				strings.Join(splitPath[:len(splitPath)-1], "/"),
-				nil,
-				[]byte(info.Name()),
-			)
+			ffo, err := NewFlattenedFileObject(strings.Join(splitPath[:len(splitPath)-1], "/"), nil, []byte(info.Name()), dataOffset)
 			if err != nil {
 				return err
 			}
 			s.Logger.Infow("File download started",
 				"fileName", info.Name(),
 				"transactionRef", fileTransfer.ReferenceNumber,
-				"RemoteAddr", conn.RemoteAddr().String(),
 				"TransferSize", fmt.Sprintf("%x", ffo.TransferSize()),
 			)
 
@@ -824,38 +879,52 @@ func (s *Server) TransferFile(conn net.Conn) error {
 				return err
 			}
 
-			// Send file bytes to client
+			// Send ffo bytes to client
 			if _, err := conn.Write(ffo.BinaryMarshal()); err != nil {
 				s.Logger.Error(err)
 				return err
 			}
 
-			file, err := os.Open(path)
+			file, err := FS.Open(path)
 			if err != nil {
 				return err
 			}
 
+			// // Copy N bytes from file to connection
+			// _, err = io.CopyN(conn, file, int64(binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize[:])))
+			// if err != nil {
+			// 	return err
+			// }
+			// file.Close()
 			sendBuffer := make([]byte, 1048576)
-			totalBytesSent := len(ffo.BinaryMarshal())
-
+			var totalSent int64
 			for {
-				bytesRead, err := file.Read(sendBuffer)
-				if err == io.EOF {
-					// Read the client's Next Action request
-					//TODO: Remove hardcoded behavior and switch behaviors based on the next action send
-					if _, err := conn.Read(readBuffer); err != nil {
-						s.Logger.Errorf("error reading next action: %v", err)
+				var bytesRead int
+				if bytesRead, err = file.ReadAt(sendBuffer, dataOffset+totalSent); err == io.EOF {
+					if _, err := conn.Write(sendBuffer[:bytesRead]); err != nil {
 						return err
 					}
 					break
 				}
+				if err != nil {
+					panic(err)
+				}
+				totalSent += int64(bytesRead)
 
-				sentBytes, readErr := conn.Write(sendBuffer[:bytesRead])
-				totalBytesSent += sentBytes
-				if readErr != nil {
+				fileTransfer.BytesSent += bytesRead
+
+				if _, err := conn.Write(sendBuffer[:bytesRead]); err != nil {
 					return err
 				}
 			}
+
+			// TODO: optionally send resource fork header and resource fork data
+
+			// Read the client's Next Action request.  This is always 3, I think?
+			if _, err := conn.Read(nextAction); err != nil {
+				return err
+			}
+
 			return nil
 		})
 
@@ -867,7 +936,6 @@ func (s *Server) TransferFile(conn net.Conn) error {
 		s.Logger.Infow(
 			"Folder upload started",
 			"transactionRef", fileTransfer.ReferenceNumber,
-			"RemoteAddr", conn.RemoteAddr().String(),
 			"dstPath", dstPath,
 			"TransferSize", fmt.Sprintf("%x", fileTransfer.TransferSize),
 			"FolderItemCount", fileTransfer.FolderItemCount,
@@ -875,24 +943,23 @@ func (s *Server) TransferFile(conn net.Conn) error {
 
 		// Check if the target folder exists.  If not, create it.
 		if _, err := FS.Stat(dstPath); os.IsNotExist(err) {
-			s.Logger.Infow("Creating target path", "dstPath", dstPath)
 			if err := FS.Mkdir(dstPath, 0777); err != nil {
-				s.Logger.Error(err)
+				return err
 			}
 		}
 
-		readBuffer := make([]byte, 1024)
-
 		// Begin the folder upload flow by sending the "next file action" to client
 		if _, err := conn.Write([]byte{0, dlFldrActionNextFile}); err != nil {
 			return err
 		}
 
 		fileSize := make([]byte, 4)
-		itemCount := binary.BigEndian.Uint16(fileTransfer.FolderItemCount)
+		readBuffer := make([]byte, 1024)
+
+		for i := 0; i < fileTransfer.ItemCount(); i++ {
 
-		for i := uint16(0); i < itemCount; i++ {
-			if _, err := conn.Read(readBuffer); err != nil {
+			_, err := conn.Read(readBuffer)
+			if err != nil {
 				return err
 			}
 			fu := readFolderUpload(readBuffer)
@@ -900,7 +967,6 @@ func (s *Server) TransferFile(conn net.Conn) error {
 			s.Logger.Infow(
 				"Folder upload continued",
 				"transactionRef", fmt.Sprintf("%x", fileTransfer.ReferenceNumber),
-				"RemoteAddr", conn.RemoteAddr().String(),
 				"FormattedPath", fu.FormattedPath(),
 				"IsFolder", fmt.Sprintf("%x", fu.IsFolder),
 				"PathItemCount", binary.BigEndian.Uint16(fu.PathItemCount[:]),
@@ -908,44 +974,104 @@ func (s *Server) TransferFile(conn net.Conn) error {
 
 			if fu.IsFolder == [2]byte{0, 1} {
 				if _, err := os.Stat(dstPath + "/" + fu.FormattedPath()); os.IsNotExist(err) {
-					s.Logger.Infow("Target path does not exist; Creating...", "dstPath", dstPath)
 					if err := os.Mkdir(dstPath+"/"+fu.FormattedPath(), 0777); err != nil {
-						s.Logger.Error(err)
+						return err
 					}
 				}
 
 				// Tell client to send next file
 				if _, err := conn.Write([]byte{0, dlFldrActionNextFile}); err != nil {
-					s.Logger.Error(err)
 					return err
 				}
 			} else {
-				// TODO: Check if we have the full file already.  If so, send dlFldrAction_NextFile to client to skip.
-				// TODO: Check if we have a partial file already.  If so, send dlFldrAction_ResumeFile to client to resume upload.
-				// Send dlFldrAction_SendFile to client to begin transfer
-				if _, err := conn.Write([]byte{0, dlFldrActionSendFile}); err != nil {
+				nextAction := dlFldrActionSendFile
+
+				// Check if we have the full file already.  If so, send dlFldrAction_NextFile to client to skip.
+				_, err := os.Stat(dstPath + "/" + fu.FormattedPath())
+				if err != nil && !errors.Is(err, fs.ErrNotExist) {
 					return err
 				}
+				if err == nil {
+					nextAction = dlFldrActionNextFile
+				}
 
-				if _, err := conn.Read(fileSize); err != nil {
-					fmt.Println("Error reading:", err.Error()) // TODO: handle
+				//  Check if we have a partial file already.  If so, send dlFldrAction_ResumeFile to client to resume upload.
+				inccompleteFile, err := os.Stat(dstPath + "/" + fu.FormattedPath() + incompleteFileSuffix)
+				if err != nil && !errors.Is(err, fs.ErrNotExist) {
+					return err
+				}
+				if err == nil {
+					nextAction = dlFldrActionResumeFile
 				}
 
-				s.Logger.Infow("Starting file transfer", "fileNum", i+1, "totalFiles", itemCount, "fileSize", fileSize)
+				fmt.Printf("Next Action: %v\n", nextAction)
 
-				if err := transferFile(conn, dstPath+"/"+fu.FormattedPath()); err != nil {
-					s.Logger.Error(err)
+				if _, err := conn.Write([]byte{0, uint8(nextAction)}); err != nil {
+					return err
 				}
 
-				// Tell client to send next file
-				if _, err := conn.Write([]byte{0, dlFldrActionNextFile}); err != nil {
-					s.Logger.Error(err)
-					return err
+				switch nextAction {
+				case dlFldrActionNextFile:
+					continue
+				case dlFldrActionResumeFile:
+					offset := make([]byte, 4)
+					binary.BigEndian.PutUint32(offset, uint32(inccompleteFile.Size()))
+
+					file, err := os.OpenFile(dstPath+"/"+fu.FormattedPath()+incompleteFileSuffix, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+					if err != nil {
+						return err
+					}
+
+					fileResumeData := NewFileResumeData([]ForkInfoList{
+						*NewForkInfoList(offset),
+					})
+
+					b, _ := fileResumeData.BinaryMarshal()
+
+					bs := make([]byte, 2)
+					binary.BigEndian.PutUint16(bs, uint16(len(b)))
+
+					if _, err := conn.Write(append(bs, b...)); err != nil {
+						return err
+					}
+
+					if _, err := conn.Read(fileSize); err != nil {
+						return err
+					}
+
+					if err := receiveFile(conn, file, ioutil.Discard); err != nil {
+						s.Logger.Error(err)
+					}
+
+					err = os.Rename(dstPath+"/"+fu.FormattedPath()+".incomplete", dstPath+"/"+fu.FormattedPath())
+					if err != nil {
+						return err
+					}
+
+				case dlFldrActionSendFile:
+					if _, err := conn.Read(fileSize); err != nil {
+						return err
+					}
+
+					filePath := dstPath + "/" + fu.FormattedPath()
+					s.Logger.Infow("Starting file transfer", "path", filePath, "fileNum", i+1, "totalFiles", "zz", "fileSize", binary.BigEndian.Uint32(fileSize))
+
+					newFile, err := FS.Create(filePath + ".incomplete")
+					if err != nil {
+						return err
+					}
+
+					if err := receiveFile(conn, newFile, ioutil.Discard); err != nil {
+						s.Logger.Error(err)
+					}
+					_ = newFile.Close()
+					if err := os.Rename(filePath+".incomplete", filePath); err != nil {
+						return err
+					}
 				}
 
-				// Client sends "MACR" after the file.  Read and discard.
-				// TODO: This doesn't seem to be documented.  What is this?  Maybe resource fork?
-				if _, err := conn.Read(readBuffer); err != nil {
+				// Tell client to send next file
+				if _, err := conn.Write([]byte{0, dlFldrActionNextFile}); err != nil {
 					return err
 				}
 			}
@@ -956,44 +1082,6 @@ func (s *Server) TransferFile(conn net.Conn) error {
 	return nil
 }
 
-func transferFile(conn net.Conn, dst string) error {
-	const buffSize = 1024
-	buf := make([]byte, buffSize)
-
-	// Read first chunk of bytes from conn; this will be the Flat File Object and initial chunk of file bytes
-	if _, err := conn.Read(buf); err != nil {
-		return err
-	}
-	ffo := ReadFlattenedFileObject(buf)
-	payloadLen := len(ffo.BinaryMarshal())
-	fileSize := int(binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize))
-
-	newFile, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = newFile.Close() }()
-	if _, err := newFile.Write(buf[payloadLen:]); err != nil {
-		return err
-	}
-	receivedBytes := buffSize - payloadLen
-
-	for {
-		if (fileSize - receivedBytes) < buffSize {
-			_, err := io.CopyN(newFile, conn, int64(fileSize-receivedBytes))
-			return err
-		}
-
-		// Copy N bytes from conn to upload file
-		n, err := io.CopyN(newFile, conn, buffSize)
-		if err != nil {
-			return err
-		}
-		receivedBytes += int(n)
-	}
-}
-
-
 // sortedClients is a utility function that takes a map of *ClientConn and returns a sorted slice of the values.
 // The purpose of this is to ensure that the ordering of client connections is deterministic so that test assertions work.
 func sortedClients(unsortedClients map[uint16]*ClientConn) (clients []*ClientConn) {