8 type flattenedFileObject struct {
9 FlatFileHeader FlatFileHeader
10 FlatFileInformationForkHeader FlatFileForkHeader
11 FlatFileInformationFork FlatFileInformationFork
12 FlatFileDataForkHeader FlatFileForkHeader
13 FlatFileResForkHeader FlatFileForkHeader
16 // FlatFileHeader is the first section of a "Flattened File Object". All fields have static values.
17 type FlatFileHeader struct {
18 Format [4]byte // Always "FILP"
19 Version [2]byte // Always 1
20 RSVD [16]byte // Always empty zeros
21 ForkCount [2]byte // Number of forks, either 2 or 3 if there is a resource fork
24 type FlatFileInformationFork struct {
25 Platform []byte // Operating System used. ("AMAC" or "MWIN")
26 TypeSignature []byte // File type signature
27 CreatorSignature []byte // File creator signature
34 NameSize []byte // Length of file name (Maximum 128 characters)
35 Name []byte // File name
36 CommentSize []byte // Length of the comment
37 Comment []byte // File comment
40 func NewFlatFileInformationFork(fileName string, modifyTime []byte, typeSignature string, creatorSignature string) FlatFileInformationFork {
41 return FlatFileInformationFork{
42 Platform: []byte("AMAC"), // TODO: Remove hardcode to support "AWIN" Platform (maybe?)
43 TypeSignature: []byte(typeSignature), // TODO: Don't infer types from filename
44 CreatorSignature: []byte(creatorSignature), // TODO: Don't infer types from filename
45 Flags: []byte{0, 0, 0, 0}, // TODO: What is this?
46 PlatformFlags: []byte{0, 0, 1, 0}, // TODO: What is this?
47 RSVD: make([]byte, 32), // Unimplemented in Hotline Protocol
48 CreateDate: modifyTime, // some filesystems don't support createTime
49 ModifyDate: modifyTime,
50 NameScript: make([]byte, 2), // TODO: What is this?
51 Name: []byte(fileName),
52 CommentSize: []byte{0, 0},
53 Comment: []byte{}, // TODO: implement (maybe?)
57 func (ffif *FlatFileInformationFork) friendlyType() []byte {
58 if name, ok := friendlyCreatorNames[string(ffif.TypeSignature)]; ok {
61 return ffif.TypeSignature
64 func (ffif *FlatFileInformationFork) friendlyCreator() []byte {
65 if name, ok := friendlyCreatorNames[string(ffif.CreatorSignature)]; ok {
68 return ffif.CreatorSignature
71 func (ffif *FlatFileInformationFork) setComment(comment []byte) error {
72 ffif.Comment = comment
73 binary.BigEndian.PutUint16(ffif.CommentSize, uint16(len(comment)))
75 // TODO: return err if comment is too long
79 // DataSize calculates the size of the flat file information fork, which is
80 // 72 bytes for the fixed length fields plus the length of the Name + Comment
81 func (ffif *FlatFileInformationFork) DataSize() []byte {
82 size := make([]byte, 4)
84 dataSize := len(ffif.Name) + len(ffif.Comment) + 74 // 74 = len of fixed size headers
86 binary.BigEndian.PutUint32(size, uint32(dataSize))
91 func (ffif *FlatFileInformationFork) Size() [4]byte {
94 dataSize := len(ffif.Name) + len(ffif.Comment) + 74 // 74 = len of fixed size headers
96 binary.BigEndian.PutUint32(size[:], uint32(dataSize))
101 func (ffo *flattenedFileObject) TransferSize(offset int64) []byte {
102 // get length of the flattenedFileObject, including the info fork
103 payloadSize := len(ffo.BinaryMarshal())
105 // length of data fork
106 dataSize := binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize[:])
108 // length of resource fork
109 resForkSize := binary.BigEndian.Uint32(ffo.FlatFileResForkHeader.DataSize[:])
111 size := make([]byte, 4)
112 binary.BigEndian.PutUint32(size[:], dataSize+resForkSize+uint32(payloadSize)-uint32(offset))
117 func (ffif *FlatFileInformationFork) ReadNameSize() []byte {
118 size := make([]byte, 2)
119 binary.BigEndian.PutUint16(size, uint16(len(ffif.Name)))
124 type FlatFileForkHeader struct {
125 ForkType [4]byte // Either INFO, DATA or MACR
126 CompressionType [4]byte
131 func (ffif *FlatFileInformationFork) MarshalBinary() []byte {
133 b = append(b, ffif.Platform...)
134 b = append(b, ffif.TypeSignature...)
135 b = append(b, ffif.CreatorSignature...)
136 b = append(b, ffif.Flags...)
137 b = append(b, ffif.PlatformFlags...)
138 b = append(b, ffif.RSVD...)
139 b = append(b, ffif.CreateDate...)
140 b = append(b, ffif.ModifyDate...)
141 b = append(b, ffif.NameScript...)
142 b = append(b, ffif.ReadNameSize()...)
143 b = append(b, ffif.Name...)
144 b = append(b, ffif.CommentSize...)
145 b = append(b, ffif.Comment...)
150 func (ffif *FlatFileInformationFork) UnmarshalBinary(b []byte) error {
152 bs := binary.BigEndian.Uint16(nameSize)
155 ffif.Platform = b[0:4]
156 ffif.TypeSignature = b[4:8]
157 ffif.CreatorSignature = b[8:12]
158 ffif.Flags = b[12:16]
159 ffif.PlatformFlags = b[16:20]
161 ffif.CreateDate = b[52:60]
162 ffif.ModifyDate = b[60:68]
163 ffif.NameScript = b[68:70]
164 ffif.NameSize = b[70:72]
165 ffif.Name = b[72:nameEnd]
167 if len(b) > int(nameEnd) {
168 ffif.CommentSize = b[nameEnd : nameEnd+2]
169 commentLen := binary.BigEndian.Uint16(ffif.CommentSize)
171 commentStartPos := int(nameEnd) + 2
172 commentEndPos := int(nameEnd) + 2 + int(commentLen)
174 ffif.Comment = b[commentStartPos:commentEndPos]
180 func (ffo *flattenedFileObject) BinaryMarshal() []byte {
182 out = append(out, ffo.FlatFileHeader.Format[:]...)
183 out = append(out, ffo.FlatFileHeader.Version[:]...)
184 out = append(out, ffo.FlatFileHeader.RSVD[:]...)
185 out = append(out, ffo.FlatFileHeader.ForkCount[:]...)
187 out = append(out, []byte("INFO")...)
188 out = append(out, []byte{0, 0, 0, 0}...)
189 out = append(out, make([]byte, 4)...)
190 out = append(out, ffo.FlatFileInformationFork.DataSize()...)
192 out = append(out, ffo.FlatFileInformationFork.Platform...)
193 out = append(out, ffo.FlatFileInformationFork.TypeSignature...)
194 out = append(out, ffo.FlatFileInformationFork.CreatorSignature...)
195 out = append(out, ffo.FlatFileInformationFork.Flags...)
196 out = append(out, ffo.FlatFileInformationFork.PlatformFlags...)
197 out = append(out, ffo.FlatFileInformationFork.RSVD...)
198 out = append(out, ffo.FlatFileInformationFork.CreateDate...)
199 out = append(out, ffo.FlatFileInformationFork.ModifyDate...)
200 out = append(out, ffo.FlatFileInformationFork.NameScript...)
201 out = append(out, ffo.FlatFileInformationFork.ReadNameSize()...)
202 out = append(out, ffo.FlatFileInformationFork.Name...)
203 out = append(out, ffo.FlatFileInformationFork.CommentSize...)
204 out = append(out, ffo.FlatFileInformationFork.Comment...)
206 out = append(out, ffo.FlatFileDataForkHeader.ForkType[:]...)
207 out = append(out, ffo.FlatFileDataForkHeader.CompressionType[:]...)
208 out = append(out, ffo.FlatFileDataForkHeader.RSVD[:]...)
209 out = append(out, ffo.FlatFileDataForkHeader.DataSize[:]...)
214 func (ffo *flattenedFileObject) ReadFrom(r io.Reader) (int, error) {
217 if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileHeader); err != nil {
221 if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileInformationForkHeader); err != nil {
225 dataLen := binary.BigEndian.Uint32(ffo.FlatFileInformationForkHeader.DataSize[:])
226 ffifBuf := make([]byte, dataLen)
227 if _, err := io.ReadFull(r, ffifBuf); err != nil {
231 if err := ffo.FlatFileInformationFork.UnmarshalBinary(ffifBuf); err != nil {
235 if err := binary.Read(r, binary.BigEndian, &ffo.FlatFileDataForkHeader); err != nil {
242 func (ffo *flattenedFileObject) dataSize() int64 {
243 return int64(binary.BigEndian.Uint32(ffo.FlatFileDataForkHeader.DataSize[:]))
246 func (ffo *flattenedFileObject) rsrcSize() int64 {
247 return int64(binary.BigEndian.Uint32(ffo.FlatFileResForkHeader.DataSize[:]))