]> git.r.bdr.sh - rbdr/mobius/blobdiff - hotline/flattened_file_object.go
Account for the root
[rbdr/mobius] / hotline / flattened_file_object.go
index 6b8d3d9f788a948416eda05d0a8f1fd7c5b6801d..99ce204569551931a296db469da803799cf75be3 100644 (file)
@@ -1,16 +1,20 @@
 package hotline
 
 import (
+       "bytes"
        "encoding/binary"
-       "os"
+       "io"
+       "slices"
 )
 
 type flattenedFileObject struct {
        FlatFileHeader                FlatFileHeader
-       FlatFileInformationForkHeader FlatFileInformationForkHeader
+       FlatFileInformationForkHeader FlatFileForkHeader
        FlatFileInformationFork       FlatFileInformationFork
-       FlatFileDataForkHeader        FlatFileDataForkHeader
-       FileData                      []byte
+       FlatFileDataForkHeader        FlatFileForkHeader
+       FlatFileResForkHeader         FlatFileForkHeader
+
+       readOffset int // Internal offset to track read progress
 }
 
 // FlatFileHeader is the first section of a "Flattened File Object".  All fields have static values.
@@ -18,66 +22,61 @@ type FlatFileHeader struct {
        Format    [4]byte  // Always "FILP"
        Version   [2]byte  // Always 1
        RSVD      [16]byte // Always empty zeros
-       ForkCount [2]byte  // Number of forks
-}
-
-// NewFlatFileHeader returns a FlatFileHeader struct
-func NewFlatFileHeader() FlatFileHeader {
-       return FlatFileHeader{
-               Format:    [4]byte{0x46, 0x49, 0x4c, 0x50}, // FILP
-               Version:   [2]byte{0, 1},
-               RSVD:      [16]byte{},
-               ForkCount: [2]byte{0, 2},
-       }
+       ForkCount [2]byte  // Number of forks, either 2 or 3 if there is a resource fork
 }
 
-// FlatFileInformationForkHeader is the second section of a "Flattened File Object"
-type FlatFileInformationForkHeader struct {
-       ForkType        [4]byte // Always "INFO"
-       CompressionType [4]byte // Always 0; Compression was never implemented in the Hotline protocol
-       RSVD            [4]byte // Always zeros
-       DataSize        [4]byte // Size of the flat file information fork
+type FlatFileInformationFork struct {
+       Platform         [4]byte // Operating System used. ("AMAC" or "MWIN")
+       TypeSignature    [4]byte // File type signature
+       CreatorSignature [4]byte // File creator signature
+       Flags            [4]byte
+       PlatformFlags    [4]byte
+       RSVD             [32]byte
+       CreateDate       [8]byte
+       ModifyDate       [8]byte
+       NameScript       [2]byte
+       NameSize         [2]byte // Length of file name (Maximum 128 characters)
+       Name             []byte  // File name
+       CommentSize      [2]byte // Length of the comment
+       Comment          []byte  // File comment
+
+       readOffset int // Internal offset to track read progress
 }
 
-type FlatFileInformationFork struct {
-       Platform         []byte // Operating System used. ("AMAC" or "MWIN")
-       TypeSignature    []byte // File type signature
-       CreatorSignature []byte // File creator signature
-       Flags            []byte
-       PlatformFlags    []byte
-       RSVD             []byte
-       CreateDate       []byte
-       ModifyDate       []byte
-       NameScript       []byte // TODO: what is this?
-       NameSize         []byte // Length of file name (Maximum 128 characters)
-       Name             []byte // File name
-       CommentSize      []byte // Length of file comment
-       Comment          []byte // File comment
-}
-
-func NewFlatFileInformationFork(fileName string, modifyTime []byte, typeSignature string, creatorSignature string) FlatFileInformationFork {
+func NewFlatFileInformationFork(fileName string, modifyTime [8]byte, typeSignature string, creatorSignature string) FlatFileInformationFork {
        return FlatFileInformationFork{
-               Platform:         []byte("AMAC"),           // TODO: Remove hardcode to support "AWIN" Platform (maybe?)
-               TypeSignature:    []byte(typeSignature),    // TODO: Don't infer types from filename
-               CreatorSignature: []byte(creatorSignature), // TODO: Don't infer types from filename
-               Flags:            []byte{0, 0, 0, 0},       // TODO: What is this?
-               PlatformFlags:    []byte{0, 0, 1, 0},       // TODO: What is this?
-               RSVD:             make([]byte, 32),         // Unimplemented in Hotline Protocol
-               CreateDate:       modifyTime,               // some filesystems don't support createTime
+               Platform:         [4]byte{0x41, 0x4D, 0x41, 0x43},   // "AMAC" TODO: Remove hardcode to support "AWIN" Platform (maybe?)
+               TypeSignature:    [4]byte([]byte(typeSignature)),    // TODO: Don't infer types from filename
+               CreatorSignature: [4]byte([]byte(creatorSignature)), // TODO: Don't infer types from filename
+               PlatformFlags:    [4]byte{0, 0, 1, 0},               // TODO: What is this?
+               CreateDate:       modifyTime,                        // some filesystems don't support createTime
                ModifyDate:       modifyTime,
-               NameScript:       make([]byte, 2), // TODO: What is this?
                Name:             []byte(fileName),
-               CommentSize:      []byte{0, 0},
                Comment:          []byte{}, // TODO: implement (maybe?)
        }
 }
 
-func (ffif *FlatFileInformationFork) friendlyType() []byte {
+func (ffif *FlatFileInformationFork) FriendlyType() []byte {
+       if name, ok := friendlyCreatorNames[string(ffif.TypeSignature[:])]; ok {
+               return []byte(name)
+       }
+       return ffif.TypeSignature[:]
+}
 
-       if name, ok := friendlyCreatorNames[string(ffif.TypeSignature)]; ok {
+func (ffif *FlatFileInformationFork) FriendlyCreator() []byte {
+       if name, ok := friendlyCreatorNames[string(ffif.CreatorSignature[:])]; ok {
                return []byte(name)
        }
-       return ffif.CreatorSignature
+       return ffif.CreatorSignature[:]
+}
+
+func (ffif *FlatFileInformationFork) SetComment(comment []byte) error {
+       commentSize := make([]byte, 2)
+       ffif.Comment = comment
+       binary.BigEndian.PutUint16(commentSize, uint16(len(comment)))
+       ffif.CommentSize = [2]byte(commentSize)
+       // TODO: return err if comment is too long
+       return nil
 }
 
 // DataSize calculates the size of the flat file information fork, which is
@@ -85,22 +84,40 @@ func (ffif *FlatFileInformationFork) friendlyType() []byte {
 func (ffif *FlatFileInformationFork) DataSize() []byte {
        size := make([]byte, 4)
 
-       // TODO: Can I do math directly on two byte slices?
-       dataSize := len(ffif.Name) + len(ffif.Comment) + 74
+       dataSize := len(ffif.Name) + len(ffif.Comment) + 74 // 74 = len of fixed size headers
 
        binary.BigEndian.PutUint32(size, uint32(dataSize))
 
        return size
 }
 
-func (ffo *flattenedFileObject) TransferSize() []byte {
-       payloadSize := len(ffo.BinaryMarshal())
+func (ffif *FlatFileInformationFork) Size() [4]byte {
+       size := [4]byte{}
+
+       dataSize := len(ffif.Name) + len(ffif.Comment) + 74 // 74 = len of fixed size headers
+
+       binary.BigEndian.PutUint32(size[:], uint32(dataSize))
+
+       return size
+}
+
+func (ffo *flattenedFileObject) TransferSize(offset int64) []byte {
+       ffoCopy := *ffo
+
+       // get length of the flattenedFileObject, including the info fork
+       b, _ := io.ReadAll(&ffoCopy)
+       payloadSize := len(b)
+
+       // length of data fork
        dataSize := binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize[:])
 
-       transferSize := make([]byte, 4)
-       binary.BigEndian.PutUint32(transferSize, dataSize+uint32(payloadSize))
+       // length of resource fork
+       resForkSize := binary.BigEndian.Uint32(ffo.FlatFileResForkHeader.DataSize[:])
 
-       return transferSize
+       size := make([]byte, 4)
+       binary.BigEndian.PutUint32(size, dataSize+resForkSize+uint32(payloadSize)-uint32(offset))
+
+       return size
 }
 
 func (ffif *FlatFileInformationFork) ReadNameSize() []byte {
@@ -110,33 +127,92 @@ func (ffif *FlatFileInformationFork) ReadNameSize() []byte {
        return size
 }
 
-type FlatFileDataForkHeader struct {
-       ForkType        [4]byte
+type FlatFileForkHeader struct {
+       ForkType        [4]byte // Either INFO, DATA or MACR
        CompressionType [4]byte
        RSVD            [4]byte
        DataSize        [4]byte
 }
 
+func (ffif *FlatFileInformationFork) Read(p []byte) (int, error) {
+       buf := slices.Concat(
+               ffif.Platform[:],
+               ffif.TypeSignature[:],
+               ffif.CreatorSignature[:],
+               ffif.Flags[:],
+               ffif.PlatformFlags[:],
+               ffif.RSVD[:],
+               ffif.CreateDate[:],
+               ffif.ModifyDate[:],
+               ffif.NameScript[:],
+               ffif.ReadNameSize(),
+               ffif.Name,
+               ffif.CommentSize[:],
+               ffif.Comment,
+       )
+
+       if ffif.readOffset >= len(buf) {
+               return 0, io.EOF // All bytes have been read
+       }
+
+       n := copy(p, buf[ffif.readOffset:])
+       ffif.readOffset += n
+
+       return n, nil
+}
+
+// Write implements the io.Writer interface for FlatFileInformationFork
+func (ffif *FlatFileInformationFork) Write(p []byte) (int, error) {
+       nameSize := p[70:72]
+       bs := binary.BigEndian.Uint16(nameSize)
+       total := 72 + bs
+
+       ffif.Platform = [4]byte(p[0:4])
+       ffif.TypeSignature = [4]byte(p[4:8])
+       ffif.CreatorSignature = [4]byte(p[8:12])
+       ffif.Flags = [4]byte(p[12:16])
+       ffif.PlatformFlags = [4]byte(p[16:20])
+       ffif.RSVD = [32]byte(p[20:52])
+       ffif.CreateDate = [8]byte(p[52:60])
+       ffif.ModifyDate = [8]byte(p[60:68])
+       ffif.NameScript = [2]byte(p[68:70])
+       ffif.NameSize = [2]byte(p[70:72])
+       ffif.Name = p[72:total]
+
+       if len(p) > int(total) {
+               ffif.CommentSize = [2]byte(p[total : total+2])
+               commentLen := binary.BigEndian.Uint16(ffif.CommentSize[:])
+               commentStartPos := int(total) + 2
+               commentEndPos := int(total) + 2 + int(commentLen)
+
+               ffif.Comment = p[commentStartPos:commentEndPos]
+
+               //total = uint16(commentEndPos)
+       }
+
+       return len(p), nil
+}
+
 func (ffif *FlatFileInformationFork) UnmarshalBinary(b []byte) error {
        nameSize := b[70:72]
        bs := binary.BigEndian.Uint16(nameSize)
        nameEnd := 72 + bs
 
-       ffif.Platform = b[0:4]
-       ffif.TypeSignature = b[4:8]
-       ffif.CreatorSignature = b[8:12]
-       ffif.Flags = b[12:16]
-       ffif.PlatformFlags = b[16:20]
-       ffif.RSVD = b[20:52]
-       ffif.CreateDate = b[52:60]
-       ffif.ModifyDate = b[60:68]
-       ffif.NameScript = b[68:70]
-       ffif.NameSize = b[70:72]
+       ffif.Platform = [4]byte(b[0:4])
+       ffif.TypeSignature = [4]byte(b[4:8])
+       ffif.CreatorSignature = [4]byte(b[8:12])
+       ffif.Flags = [4]byte(b[12:16])
+       ffif.PlatformFlags = [4]byte(b[16:20])
+       ffif.RSVD = [32]byte(b[20:52])
+       ffif.CreateDate = [8]byte(b[52:60])
+       ffif.ModifyDate = [8]byte(b[60:68])
+       ffif.NameScript = [2]byte(b[68:70])
+       ffif.NameSize = [2]byte(b[70:72])
        ffif.Name = b[72:nameEnd]
 
        if len(b) > int(nameEnd) {
-               ffif.CommentSize = b[nameEnd : nameEnd+2]
-               commentLen := binary.BigEndian.Uint16(ffif.CommentSize)
+               ffif.CommentSize = [2]byte(b[nameEnd : nameEnd+2])
+               commentLen := binary.BigEndian.Uint16(ffif.CommentSize[:])
 
                commentStartPos := int(nameEnd) + 2
                commentEndPos := int(nameEnd) + 2 + int(commentLen)
@@ -147,72 +223,79 @@ func (ffif *FlatFileInformationFork) UnmarshalBinary(b []byte) error {
        return nil
 }
 
-func (f *flattenedFileObject) BinaryMarshal() []byte {
-       var out []byte
-       out = append(out, f.FlatFileHeader.Format[:]...)
-       out = append(out, f.FlatFileHeader.Version[:]...)
-       out = append(out, f.FlatFileHeader.RSVD[:]...)
-       out = append(out, f.FlatFileHeader.ForkCount[:]...)
-
-       out = append(out, []byte("INFO")...)
-       out = append(out, []byte{0, 0, 0, 0}...)
-       out = append(out, make([]byte, 4)...)
-       out = append(out, f.FlatFileInformationFork.DataSize()...)
-
-       out = append(out, f.FlatFileInformationFork.Platform...)
-       out = append(out, f.FlatFileInformationFork.TypeSignature...)
-       out = append(out, f.FlatFileInformationFork.CreatorSignature...)
-       out = append(out, f.FlatFileInformationFork.Flags...)
-       out = append(out, f.FlatFileInformationFork.PlatformFlags...)
-       out = append(out, f.FlatFileInformationFork.RSVD...)
-       out = append(out, f.FlatFileInformationFork.CreateDate...)
-       out = append(out, f.FlatFileInformationFork.ModifyDate...)
-       out = append(out, f.FlatFileInformationFork.NameScript...)
-       out = append(out, f.FlatFileInformationFork.ReadNameSize()...)
-       out = append(out, f.FlatFileInformationFork.Name...)
-       out = append(out, f.FlatFileInformationFork.CommentSize...)
-       out = append(out, f.FlatFileInformationFork.Comment...)
-
-       out = append(out, f.FlatFileDataForkHeader.ForkType[:]...)
-       out = append(out, f.FlatFileDataForkHeader.CompressionType[:]...)
-       out = append(out, f.FlatFileDataForkHeader.RSVD[:]...)
-       out = append(out, f.FlatFileDataForkHeader.DataSize[:]...)
-
-       return out
-}
-
-func NewFlattenedFileObject(fileRoot string, filePath, fileName []byte, dataOffset int64) (*flattenedFileObject, error) {
-       fullFilePath, err := readPath(fileRoot, filePath, fileName)
-       if err != nil {
-               return nil, err
+// Read implements the io.Reader interface for flattenedFileObject
+func (ffo *flattenedFileObject) Read(p []byte) (int, error) {
+       buf := slices.Concat(
+               ffo.FlatFileHeader.Format[:],
+               ffo.FlatFileHeader.Version[:],
+               ffo.FlatFileHeader.RSVD[:],
+               ffo.FlatFileHeader.ForkCount[:],
+               []byte("INFO"),
+               []byte{0, 0, 0, 0},
+               make([]byte, 4),
+               ffo.FlatFileInformationFork.DataSize(),
+               ffo.FlatFileInformationFork.Platform[:],
+               ffo.FlatFileInformationFork.TypeSignature[:],
+               ffo.FlatFileInformationFork.CreatorSignature[:],
+               ffo.FlatFileInformationFork.Flags[:],
+               ffo.FlatFileInformationFork.PlatformFlags[:],
+               ffo.FlatFileInformationFork.RSVD[:],
+               ffo.FlatFileInformationFork.CreateDate[:],
+               ffo.FlatFileInformationFork.ModifyDate[:],
+               ffo.FlatFileInformationFork.NameScript[:],
+               ffo.FlatFileInformationFork.ReadNameSize(),
+               ffo.FlatFileInformationFork.Name,
+               ffo.FlatFileInformationFork.CommentSize[:],
+               ffo.FlatFileInformationFork.Comment,
+               ffo.FlatFileDataForkHeader.ForkType[:],
+               ffo.FlatFileDataForkHeader.CompressionType[:],
+               ffo.FlatFileDataForkHeader.RSVD[:],
+               ffo.FlatFileDataForkHeader.DataSize[:],
+       )
+
+       if ffo.readOffset >= len(buf) {
+               return 0, io.EOF // All bytes have been read
        }
-       file, err := effectiveFile(fullFilePath)
-       if err != nil {
-               return nil, err
+
+       n := copy(p, buf[ffo.readOffset:])
+       ffo.readOffset += n
+
+       return n, nil
+}
+
+func (ffo *flattenedFileObject) ReadFrom(r io.Reader) (int64, error) {
+       var n int64
+
+       if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileHeader); err != nil {
+               return n, err
        }
 
-       defer func(file *os.File) { _ = file.Close() }(file)
+       if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileInformationForkHeader); err != nil {
+               return n, err
+       }
 
-       fileInfo, err := file.Stat()
+       dataLen := binary.BigEndian.Uint32(ffo.FlatFileInformationForkHeader.DataSize[:])
+       ffifBuf := make([]byte, dataLen)
+       if _, err := io.ReadFull(r, ffifBuf); err != nil {
+               return n, err
+       }
+
+       _, err := io.Copy(&ffo.FlatFileInformationFork, bytes.NewReader(ffifBuf))
        if err != nil {
-               return nil, err
+               return n, err
        }
 
-       dataSize := make([]byte, 4)
-       binary.BigEndian.PutUint32(dataSize, uint32(fileInfo.Size()-dataOffset))
+       if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileDataForkHeader); err != nil {
+               return n, err
+       }
 
-       mTime := toHotlineTime(fileInfo.ModTime())
+       return n, nil
+}
 
-       ft, _ := fileTypeFromInfo(fileInfo)
+func (ffo *flattenedFileObject) dataSize() int64 {
+       return int64(binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize[:]))
+}
 
-       return &flattenedFileObject{
-               FlatFileHeader:          NewFlatFileHeader(),
-               FlatFileInformationFork: NewFlatFileInformationFork(string(fileName), mTime, ft.TypeCode, ft.CreatorCode),
-               FlatFileDataForkHeader: FlatFileDataForkHeader{
-                       ForkType:        [4]byte{0x44, 0x41, 0x54, 0x41}, // "DATA"
-                       CompressionType: [4]byte{},
-                       RSVD:            [4]byte{},
-                       DataSize:        [4]byte{dataSize[0], dataSize[1], dataSize[2], dataSize[3]},
-               },
-       }, nil
+func (ffo *flattenedFileObject) rsrcSize() int64 {
+       return int64(binary.BigEndian.Uint32(ffo.FlatFileResForkHeader.DataSize[:]))
 }