BasicFile should work fully.

More documentation (I hate it)

internal/inode/inode.go

@@ -49,18 +49,39 @@ func NewExtendedDirectory(rdr *io.Reader) (*ExtendedDirectory, error) {
 	return &inode, err
 }
 
-//BasicFile is self explainatory
+//BasicFileInit is the information that can be directoy decoded
-type BasicFile struct {
+type BasicFileInit struct {
 	BlockStart     uint32
 	FragmentIndex  uint32
 	FragmentOffset uint32
 	Size           uint32
-	BlockSizes     []uint32
 	//TODO: possibly fix BlockSizes
 }
 
-//ExtendedFile is a file with additional information
+//BasicFile is self explainatory
-type ExtendedFile struct {
+type BasicFile struct {
+	Init       BasicFileInit
+	BlockSizes []uint32
+}
+
+//NewBasicFile creates a new BasicFile
+func NewBasicFile(rdr *io.Reader, blockSize uint32) (*BasicFile, error) {
+	var inode BasicFile
+	err := binary.Read(*rdr, binary.LittleEndian, inode.Init)
+	if err != nil {
+		return &inode, err
+	}
+	blocks := inode.Init.Size / blockSize
+	if inode.Init.Size%blockSize > 0 {
+		blocks++
+	}
+	inode.BlockSizes = make([]uint32, blocks, blocks)
+	err = binary.Read(*rdr, binary.LittleEndian, inode.BlockSizes)
+	return &inode, err
+}
+
+//ExtendedFileInit is the information that can be directly decoded
+type ExtendedFileInit struct {
 	BlockStart     uint32
 	Size           uint32
 	Sparse         uint64
@@ -68,49 +89,76 @@ type ExtendedFile struct {
 	FragmentIndex  uint32
 	FragmentOffset uint32
 	XattrIndex     uint32
-	BlockSizes     []uint32
 	//TODO: possibly fix BlockSizes
 }
 
+//ExtendedFile is a file with more information
+type ExtendedFile struct {
+	Init       ExtendedFileInit
+	BlockSizes []uint32
+}
+
+//NewExtendedFile creates a new ExtendedFile
+func NewExtendedFile(rdr *io.Reader, blockSize uint32) (*ExtendedFile, error) {
+	var inode ExtendedFile
+	err := binary.Read(*rdr, binary.LittleEndian, inode.Init)
+	if err != nil {
+		return &inode, err
+	}
+	blocks := inode.Init.Size / blockSize
+	if inode.Init.Size%blockSize > 0 {
+		blocks++
+	}
+	inode.BlockSizes = make([]uint32, blocks, blocks)
+	err = binary.Read(*rdr, binary.LittleEndian, inode.BlockSizes)
+	return &inode, err
+}
+
+//BasicSymlinkInit is all the values that can be directly decoded
 type BasicSymlinkInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
+//BasicSymlink is a symlink
 type BasicSymlink struct {
 	Init       BasicSymlinkInit
 	targetPath []uint8 //len is TargetPathSize
 }
 
+//NewBasicSymlink creates a new BasicSymlink
 func NewBasicSymlink(rdr *io.Reader) (*BasicSymlink, error) {
 	var inode BasicSymlink
 	err := binary.Read(*rdr, binary.LittleEndian, inode.Init)
 	if err != nil {
 		return nil, err
 	}
-	inode.targetPath = make([]uint8, inode.Init.TargetPathSize)
+	inode.targetPath = make([]uint8, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
 	err = binary.Read(*rdr, binary.LittleEndian, inode.targetPath)
 	return &inode, err
 }
 
+//ExtendedSymlinkInit is all the values that can be directly decoded
 type ExtendedSymlinkInit struct {
 	HardLinks      uint32
 	TargetPathSize uint32
 }
 
+//ExtendedSymlink is a symlink with extra information
 type ExtendedSymlink struct {
 	Init       ExtendedSymlinkInit
 	TargetPath []uint8
 	XattrIndex uint32
 }
 
+//NewExtendedSymlink creates a new ExtendedSymlink
 func NewExtendedSymlink(rdr *io.Reader) (*ExtendedSymlink, error) {
 	var inode ExtendedSymlink
 	err := binary.Read(*rdr, binary.LittleEndian, inode.Init)
 	if err != nil {
 		return &inode, err
 	}
-	inode.TargetPath = make([]uint8, inode.Init.TargetPathSize)
+	inode.TargetPath = make([]uint8, inode.Init.TargetPathSize, inode.Init.TargetPathSize)
 	err = binary.Read(*rdr, binary.LittleEndian, &inode.XattrIndex)
 	return &inode, err
 }