X-Git-Url: https://git.r.bdr.sh/rbdr/mobius/blobdiff_plain/aebc4d3647b9823ae8cbb57b21b1af83bfd011fb..c4208f864659a6d5b5d9a2a7e0fe069565033f6b:/hotline/server.go

diff --git a/hotline/server.go b/hotline/server.go
index 1da2859..2bd5c04 100644
--- a/hotline/server.go
+++ b/hotline/server.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"go.uber.org/zap"
 	"io"
+	"io/fs"
 	"io/ioutil"
 	"math/big"
 	"math/rand"
@@ -20,7 +21,7 @@ import (
 	"sync"
 	"time"
 
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -91,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)
 			}
 		}()
@@ -355,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
@@ -365,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 {
@@ -395,7 +428,6 @@ func (s *Server) loadThreadedNews(threadedNewsPath string) error {
 		return err
 	}
 	decoder := yaml.NewDecoder(fh)
-	decoder.SetStrict(true)
 
 	return decoder.Decode(s.ThreadedNews)
 }
@@ -419,7 +451,6 @@ func (s *Server) loadAccounts(userDir string) error {
 
 		account := Account{}
 		decoder := yaml.NewDecoder(fh)
-		decoder.SetStrict(true)
 		if err := decoder.Decode(&account); err != nil {
 			return err
 		}
@@ -436,7 +467,6 @@ func (s *Server) loadConfig(path string) error {
 	}
 
 	decoder := yaml.NewDecoder(fh)
-	decoder.SetStrict(true)
 	err = decoder.Decode(s.Config)
 	if err != nil {
 		return err
@@ -448,17 +478,29 @@ const (
 	minTransactionLen = 22 // minimum length of any transaction
 )
 
+// dontPanic recovers and logs panics instead of crashing
+// TODO: remove this after known issues are fixed
+func dontPanic(logger *zap.SugaredLogger) {
+	if r := recover(); r != nil {
+		fmt.Println("stacktrace from panic: \n" + string(debug.Stack()))
+		logger.Errorw("PANIC", "err", r, "trace", string(debug.Stack()))
+	}
+}
+
 // handleNewConnection takes a new net.Conn and performs the initial login sequence
 func (s *Server) handleNewConnection(conn net.Conn) error {
-	handshakeBuf := make([]byte, 12) // handshakes are always 12 bytes in length
-	if _, err := conn.Read(handshakeBuf); err != nil {
+	defer dontPanic(s.Logger)
+
+	handshakeBuf := make([]byte, 12)
+	if _, err := io.ReadFull(conn, handshakeBuf); err != nil {
 		return err
 	}
-	if err := Handshake(conn, handshakeBuf[:12]); err != nil {
+	if err := Handshake(conn, handshakeBuf); err != nil {
 		return err
 	}
 
 	buf := make([]byte, 1024)
+	// TODO: fix potential short read with io.ReadFull
 	readLen, err := conn.Read(buf)
 	if readLen < minTransactionLen {
 		return err
@@ -474,13 +516,6 @@ func (s *Server) handleNewConnection(conn net.Conn) error {
 
 	c := s.NewClientConn(conn)
 	defer c.Disconnect()
-	defer func() {
-		if r := recover(); r != nil {
-			fmt.Println("stacktrace from panic: \n" + string(debug.Stack()))
-			c.Server.Logger.Errorw("PANIC", "err", r, "trace", string(debug.Stack()))
-			c.Disconnect()
-		}
-	}()
 
 	encodedLogin := clientLogin.GetField(fieldUserLogin).Data
 	encodedPassword := clientLogin.GetField(fieldUserPassword).Data
@@ -538,9 +573,16 @@ func (s *Server) handleNewConnection(conn net.Conn) error {
 	// assume simplified hotline v1.2.3 login flow that does not require agreement
 	if *c.Version == nil {
 		c.Agreed = true
-		if _, err := c.notifyNewUserHasJoined(); err != nil {
-			return err
-		}
+
+		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
@@ -606,22 +648,40 @@ 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() {
 
-	buf := make([]byte, 1024)
-	if _, err := conn.Read(buf); err != nil {
+		if err := conn.Close(); err != nil {
+			s.Logger.Errorw("error closing connection", "error", err)
+		}
+	}()
+
+	defer dontPanic(s.Logger)
+
+	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:
@@ -630,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)
@@ -652,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
@@ -738,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
@@ -756,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 := io.ReadFull(conn, 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)
@@ -779,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 := io.ReadFull(conn, 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 := io.ReadFull(conn, nextAction); err != nil {
+					return err
+				}
+
+				resumeDataLen := binary.BigEndian.Uint16(nextAction)
+				resumeDataBytes := make([]byte, resumeDataLen)
+				if _, err := io.ReadFull(conn, 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
@@ -792,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()),
 			)
 
@@ -813,7 +879,7 @@ 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
@@ -824,27 +890,41 @@ func (s *Server) TransferFile(conn net.Conn) error {
 				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)
+
+				fileTransfer.BytesSent += bytesRead
 
-				sentBytes, readErr := conn.Write(sendBuffer[:bytesRead])
-				totalBytesSent += sentBytes
-				if readErr != nil {
+				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 := io.ReadFull(conn, nextAction); err != nil {
+				return err
+			}
+
 			return nil
 		})
 
@@ -856,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,
@@ -864,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 := uint16(0); i < itemCount; i++ {
-			if _, err := conn.Read(readBuffer); err != nil {
+		for i := 0; i < fileTransfer.ItemCount(); i++ {
+			// TODO: fix potential short read with io.ReadFull
+			_, err := conn.Read(readBuffer)
+			if err != nil {
 				return err
 			}
 			fu := readFolderUpload(readBuffer)
@@ -889,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[:]),
@@ -897,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 := io.ReadFull(conn, 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
 				}
 			}
@@ -945,43 +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) {