Update Docker instructions

[rbdr/mobius] / hotline / transfer.go

diff --git a/hotline/transfer.go b/hotline/transfer.go
index ecbe32436d4ea40f821ad3b64679876a05f3cd7b..78bd888ccc35e3b27f168fcdc4ab6e7c20b7f0e1 100644 (file)
--- a/hotline/transfer.go
+++ b/hotline/transfer.go
@@ -1,49 +1,113 @@
 package hotline
 
 import (
+       "bufio"
        "bytes"
        "encoding/binary"
        "errors"
+       "io"
 )
 
-type Transfer struct {
+type transfer struct {
        Protocol        [4]byte // "HTXF" 0x48545846
        ReferenceNumber [4]byte // Unique ID generated for the transfer
        DataSize        [4]byte // File size
        RSVD            [4]byte // Not implemented in Hotline Protocol
 }
 
-func NewReadTransfer(b []byte) (Transfer, error) {
-       r := bytes.NewReader(b)
-       var transfer Transfer
+var HTXF = [4]byte{0x48, 0x54, 0x58, 0x46} // (HTXF) is the only supported transfer protocol
 
-       if err := binary.Read(r, binary.BigEndian, &transfer); err != nil {
-               return transfer, err
+func (tf *transfer) Write(b []byte) (int, error) {
+       if err := binary.Read(bytes.NewReader(b), binary.BigEndian, tf); err != nil {
+               return 0, err
        }
 
-       // 0x48545846 (HTXF) is the only supported transfer protocol
-       if transfer.Protocol != [4]byte{0x48, 0x54, 0x58, 0x46} {
-               return transfer, errors.New("invalid protocol")
+       if tf.Protocol != HTXF {
+               return 0, errors.New("invalid protocol")
        }
 
-       return transfer, nil
+       return len(b), nil
+}
+
+const fileCopyBufSize = 524288 // 512k
+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
+       }
+
+       var ffh FlatFileHeader
+       err := binary.Read(bytes.NewReader(ffhBuf), binary.BigEndian, &ffh)
+       if err != nil {
+               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)
+       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 {
+               return err
+       }
+       if err := ffif.UnmarshalBinary(ffifBuf); err != nil {
+               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
+       }
+
+       // this will be zero if the file only has a resource fork
+       fileSize := int(binary.BigEndian.Uint32(ffdfh.DataSize[:]))
+
+       bw := bufio.NewWriterSize(targetFile, fileCopyBufSize)
+       _, err = io.CopyN(bw, conn, int64(fileSize))
+       if err != nil {
+               return err
+       }
+       if err := bw.Flush(); err != nil {
+               return err
+       }
+
+       if ffh.ForkCount == [2]byte{0, 3} {
+               var resForkHeader FlatFileDataForkHeader
+               resForkBuf := make([]byte, 16)
+               resForkBufWrter := bufio.NewWriterSize(resForkFile, 16)
+               if _, err := io.CopyN(resForkBufWrter, conn, 16); err != nil {
+                       return err
+               }
+               err = binary.Read(bytes.NewReader(resForkBuf), binary.BigEndian, &resForkHeader)
+               if err != nil {
+                       return err
+               }
+
+               fileSize = int(binary.BigEndian.Uint32(resForkHeader.DataSize[:]))
+
+               bw = bufio.NewWriterSize(resForkFile, fileCopyBufSize)
+               _, err = io.CopyN(resForkFile, conn, int64(fileSize))
+               if err != nil {
+                       return err
+               }
+               if err := bw.Flush(); err != nil {
+                       return err
+               }
+       }
+       return nil
 }
-//
-//type FolderTransfer struct {
-//     Protocol        [4]byte // "HTXF" 0x48545846
-//     ReferenceNumber [4]byte // Unique ID generated for the transfer
-//     DataSize        [4]byte // File size
-//     RSVD            [4]byte // Not implemented in Hotline Protocol
-//     Action          [2]byte // Next file action
-//}
-//
-//func ReadFolderTransfer(b []byte) (FolderTransfer, error) {
-//     r := bytes.NewReader(b)
-//     var decodedEvent FolderTransfer
-//
-//     if err := binary.Read(r, binary.BigEndian, &decodedEvent); err != nil {
-//             return decodedEvent, err
-//     }
-//
-//     return decodedEvent, nil
-//}