Convert hardcoded path separators to filepath.Join

[rbdr/mobius] / hotline / transfer.go

diff --git a/hotline/transfer.go b/hotline/transfer.go
index 703dae0582b02c9457fa0ef35c802dd53cf77b58..73331970e33648900b0642de8754a234da933f0f 100644 (file)
--- a/hotline/transfer.go
+++ b/hotline/transfer.go
@@ -1,6 +1,7 @@
 package hotline
 
 import (
 package hotline
 
 import (

+       "bufio"

        "bytes"
        "encoding/binary"
        "errors"
        "bytes"
        "encoding/binary"
        "errors"


@@ -28,77 +29,72 @@ func (tf *transfer) Write(b []byte) (int, error) {
        return len(b), nil
 }
 
        return len(b), nil
 }
 

-func receiveFile(conn io.Reader, targetFile io.Writer, resForkFile io.Writer) error {
-       ffhBuf := make([]byte, 24)
-       if _, err := conn.Read(ffhBuf); err != nil {
-               return err
-       }
+const fileCopyBufSize = 4096

 
 

-       var ffh FlatFileHeader
-       err := binary.Read(bytes.NewReader(ffhBuf), binary.BigEndian, &ffh)
-       if err != nil {
+func receiveFile(r io.Reader, targetFile, resForkFile, infoFork io.Writer) error {
+       var ffo flattenedFileObject
+       if _, err := ffo.ReadFrom(r); err != nil {

                return err
        }
 
                return err
        }
 

-       ffifhBuf := make([]byte, 16)
-       if _, err := conn.Read(ffifhBuf); err != nil {
-               return err
-       }
-
-       var ffifh FlatFileInformationForkHeader
-       err = binary.Read(bytes.NewReader(ffifhBuf), binary.BigEndian, &ffifh)
+       // Write the information fork
+       _, err := infoFork.Write(ffo.FlatFileInformationFork.MarshalBinary())

        if err != nil {
                return err
        }
 
        if err != nil {
                return err
        }
 

-       var ffif FlatFileInformationFork
-
-       dataLen := binary.BigEndian.Uint32(ffifh.DataSize[:])
-       ffifBuf := make([]byte, dataLen)
-       if _, err := conn.Read(ffifBuf); err != nil {
+       // read and write the data fork
+       bw := bufio.NewWriterSize(targetFile, fileCopyBufSize)
+       if _, err = io.CopyN(bw, r, ffo.dataSize()); err != nil {

                return err
        }
                return err
        }

-       if err := ffif.UnmarshalBinary(ffifBuf); err != nil {
+       if err := bw.Flush(); err != nil {

                return err
        }
 
                return err
        }
 

-       var ffdfh FlatFileDataForkHeader
-       ffdfhBuf := make([]byte, 16)
-       if _, err := conn.Read(ffdfhBuf); err != nil {
-               return err
-       }
-       err = binary.Read(bytes.NewReader(ffdfhBuf), binary.BigEndian, &ffdfh)
-       if err != nil {
-               return err
-       }
+       if ffo.FlatFileHeader.ForkCount == [2]byte{0, 3} {
+               if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileResForkHeader); err != nil {
+                       return err
+               }

 
 

-       // this will be zero if the file only has a resource fork
-       fileSize := int(binary.BigEndian.Uint32(ffdfh.DataSize[:]))
+               bw = bufio.NewWriterSize(resForkFile, fileCopyBufSize)
+               _, err = io.CopyN(resForkFile, r, ffo.rsrcSize())
+               if err != nil {
+                       return err
+               }
+               if err := bw.Flush(); err != nil {
+                       return err
+               }
+       }
+       return nil
+}

 
 

-       // Copy N bytes from conn to upload file
-       _, err = io.CopyN(targetFile, conn, int64(fileSize))
-       if err != nil {
+func sendFile(w io.Writer, r io.Reader, offset int) (err error) {
+       br := bufio.NewReader(r)
+       if _, err := br.Discard(offset); err != nil {

                return err
        }
 
                return err
        }
 

-       if ffh.ForkCount == [2]byte{0, 3} {
-               var resForkHeader FlatFileDataForkHeader
-               resForkBuf := make([]byte, 16)
+       rSendBuffer := make([]byte, 1024)
+       for {
+               var bytesRead int

 
 

-               if _, err := conn.Read(resForkBuf); err != nil {
-                       return err
+               if bytesRead, err = br.Read(rSendBuffer); err == io.EOF {
+                       if _, err := w.Write(rSendBuffer[:bytesRead]); err != nil {
+                               return err
+                       }
+                       return nil

                }
                }

-               err = binary.Read(bytes.NewReader(resForkBuf), binary.BigEndian, &resForkHeader)

                if err != nil {
                        return err
                }
                if err != nil {
                        return err
                }

+               // totalSent += int64(bytesRead)

 
 

-               fileSize = int(binary.BigEndian.Uint32(resForkHeader.DataSize[:]))
+               // fileTransfer.BytesSent += bytesRead

 
 

-               _, err = io.CopyN(resForkFile, conn, int64(fileSize))
-               if err != nil {
+               if _, err := w.Write(rSendBuffer[:bytesRead]); err != nil {

                        return err
                }
        }
                        return err
                }
        }

-       return nil
+

 }
 }