mirror of
https://github.com/tjboldt/ProDOS-Utilities.git
synced 2024-11-28 12:51:35 +00:00
443 lines
12 KiB
Go
443 lines
12 KiB
Go
// Copyright Terence J. Boldt (c)2021-2023
|
|
// Use of this source code is governed by an MIT
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file provides access to read, write and delete
|
|
// files on a ProDOS drive image
|
|
|
|
package prodos
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// LoadFile loads in a file from a ProDOS volume into a byte array
|
|
func LoadFile(reader io.ReaderAt, path string) ([]byte, error) {
|
|
fileEntry, err := GetFileEntry(reader, path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockList, err := getDataBlocklist(reader, fileEntry)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
buffer := make([]byte, fileEntry.EndOfFile)
|
|
|
|
for i := uint16(0); i < uint16(len(blockList)); i++ {
|
|
block, err := ReadBlock(reader, blockList[i])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for j := uint16(0); j < 512 && uint32(i)*512+uint32(j) < fileEntry.EndOfFile; j++ {
|
|
buffer[i*512+j] = block[j]
|
|
}
|
|
}
|
|
|
|
return buffer, nil
|
|
}
|
|
|
|
// WriteFile writes a file to a ProDOS volume from a byte array
|
|
func WriteFile(readerWriter ReaderWriterAt, path string, fileType uint8, auxType uint16, createdTime time.Time, modifiedTime time.Time, buffer []byte) error {
|
|
directory, fileName := GetDirectoryAndFileNameFromPath(path)
|
|
|
|
if len(fileName) > 15 {
|
|
return errors.New("filename too long")
|
|
}
|
|
|
|
existingFileEntry, _ := GetFileEntry(readerWriter, path)
|
|
if existingFileEntry.StorageType != StorageDeleted {
|
|
return errors.New(("file already exists"))
|
|
}
|
|
|
|
// get list of blocks to write file to
|
|
blockList, err := createBlockList(readerWriter, uint32(len(buffer)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// seedling file
|
|
if len(buffer) <= 0x200 {
|
|
writeSeedlingFile(readerWriter, buffer, blockList)
|
|
}
|
|
|
|
// sapling file needs index block
|
|
if len(buffer) > 0x200 && len(buffer) <= 0x20000 {
|
|
writeSaplingFile(readerWriter, buffer, blockList)
|
|
}
|
|
|
|
// tree file needs master index and index blocks
|
|
if len(buffer) > 0x20000 && len(buffer) <= 0x1000000 {
|
|
writeTreeFile(readerWriter, buffer, blockList)
|
|
}
|
|
|
|
if len(buffer) > 0x1000000 {
|
|
return errors.New("files > 16MB not supported by ProDOS")
|
|
}
|
|
|
|
updateVolumeBitmap(readerWriter, blockList)
|
|
|
|
// add file entry to directory
|
|
fileEntry, err := getFreeFileEntryInDirectory(readerWriter, directory)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fileEntry.FileName = fileName
|
|
fileEntry.BlocksUsed = uint16(len(blockList))
|
|
fileEntry.CreationTime = createdTime
|
|
fileEntry.ModifiedTime = modifiedTime
|
|
fileEntry.AuxType = auxType
|
|
fileEntry.EndOfFile = uint32(len(buffer))
|
|
fileEntry.FileType = fileType
|
|
fileEntry.KeyPointer = blockList[0]
|
|
fileEntry.Version = 0x24
|
|
fileEntry.MinVersion = 0x00
|
|
fileEntry.Access = 0b11100011
|
|
if len(blockList) == 1 {
|
|
fileEntry.StorageType = StorageSeedling
|
|
} else if len(blockList) <= 257 {
|
|
fileEntry.StorageType = StorageSapling
|
|
} else {
|
|
fileEntry.StorageType = StorageTree
|
|
}
|
|
|
|
writeFileEntry(readerWriter, fileEntry)
|
|
|
|
return incrementFileCount(readerWriter, fileEntry)
|
|
}
|
|
|
|
func incrementFileCount(readerWriter ReaderWriterAt, fileEntry FileEntry) error {
|
|
directoryHeaderBlock, err := ReadBlock(readerWriter, fileEntry.HeaderPointer)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
directoryHeader := parseDirectoryHeader(directoryHeaderBlock, fileEntry.HeaderPointer)
|
|
directoryHeader.ActiveFileCount++
|
|
writeDirectoryHeader(readerWriter, directoryHeader)
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteFile deletes a file from a ProDOS volume
|
|
func DeleteFile(readerWriter ReaderWriterAt, path string) error {
|
|
fileEntry, err := GetFileEntry(readerWriter, path)
|
|
// DumpFileEntry(fileEntry)
|
|
// oldDirectoryBlock, _ := ReadBlock(readerWriter, fileEntry.DirectoryBlock)
|
|
// DumpBlock(oldDirectoryBlock)
|
|
|
|
if err != nil {
|
|
return errors.New("file not found")
|
|
}
|
|
if fileEntry.StorageType == StorageDeleted {
|
|
return errors.New("file already deleted")
|
|
}
|
|
if fileEntry.StorageType == StorageDirectory {
|
|
return errors.New("directory deletion not supported")
|
|
}
|
|
|
|
// free the blocks
|
|
blocks, err := getAllBlockList(readerWriter, fileEntry)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
volumeBitmap, err := ReadVolumeBitmap(readerWriter)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 0; i < len(blocks); i++ {
|
|
freeBlockInVolumeBitmap(volumeBitmap, blocks[i])
|
|
}
|
|
writeVolumeBitmap(readerWriter, volumeBitmap)
|
|
|
|
// decrement the directory entry count
|
|
directoryBlock, err := ReadBlock(readerWriter, fileEntry.HeaderPointer)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
directoryHeader := parseDirectoryHeader(directoryBlock, fileEntry.HeaderPointer)
|
|
|
|
directoryHeader.ActiveFileCount--
|
|
writeDirectoryHeader(readerWriter, directoryHeader)
|
|
|
|
// zero out directory entry
|
|
fileEntry.StorageType = 0
|
|
fileEntry.FileName = ""
|
|
writeFileEntry(readerWriter, fileEntry)
|
|
|
|
return nil
|
|
}
|
|
|
|
// FileExists return true if the file exists
|
|
func FileExists(reader io.ReaderAt, path string) (bool, error) {
|
|
fileEntry, _ := GetFileEntry(reader, path)
|
|
return fileEntry.StorageType != StorageDeleted, nil
|
|
}
|
|
|
|
// GetDirectoryAndFileNameFromPath gets the directory and filename from a path
|
|
func GetDirectoryAndFileNameFromPath(path string) (string, string) {
|
|
path = strings.ToUpper(path)
|
|
paths := strings.Split(path, "/")
|
|
|
|
var directoryBuilder strings.Builder
|
|
|
|
for i := 1; i < len(paths)-1; i++ {
|
|
directoryBuilder.WriteString("/")
|
|
directoryBuilder.WriteString(paths[i])
|
|
}
|
|
|
|
directory := directoryBuilder.String()
|
|
fileName := paths[len(paths)-1]
|
|
|
|
return directory, fileName
|
|
}
|
|
|
|
func updateVolumeBitmap(readerWriter ReaderWriterAt, blockList []uint16) error {
|
|
|
|
volumeBitmap, err := ReadVolumeBitmap(readerWriter)
|
|
if err != nil {
|
|
fmt.Printf("%s", err)
|
|
return err
|
|
}
|
|
for i := uint16(0); i < uint16(len(blockList)); i++ {
|
|
markBlockInVolumeBitmap(volumeBitmap, blockList[i])
|
|
}
|
|
return writeVolumeBitmap(readerWriter, volumeBitmap)
|
|
}
|
|
|
|
func writeSeedlingFile(writer io.WriterAt, buffer []byte, blockList []uint16) {
|
|
WriteBlock(writer, blockList[0], buffer)
|
|
}
|
|
|
|
func writeSaplingFile(writer io.WriterAt, buffer []byte, blockList []uint16) {
|
|
// write index block with pointers to data blocks
|
|
indexBuffer := make([]byte, 512)
|
|
for i := 0; i < 256; i++ {
|
|
if i < len(blockList)-1 {
|
|
indexBuffer[i] = byte(blockList[i+1] & 0x00FF)
|
|
indexBuffer[i+256] = byte(blockList[i+1] >> 8)
|
|
} else {
|
|
indexBuffer[i] = 0
|
|
indexBuffer[i+256] = 0
|
|
}
|
|
}
|
|
WriteBlock(writer, blockList[0], indexBuffer)
|
|
|
|
// write all data blocks
|
|
blockBuffer := make([]byte, 512)
|
|
blockPointer := 0
|
|
blockIndexNumber := 1
|
|
for i := 0; i < len(buffer); i++ {
|
|
blockBuffer[blockPointer] = buffer[i]
|
|
if blockPointer == 511 {
|
|
WriteBlock(writer, blockList[blockIndexNumber], blockBuffer)
|
|
blockPointer = 0
|
|
blockIndexNumber++
|
|
} else if i == len(buffer)-1 {
|
|
for j := blockPointer; j < 512; j++ {
|
|
blockBuffer[j] = 0
|
|
}
|
|
WriteBlock(writer, blockList[blockIndexNumber], blockBuffer)
|
|
} else {
|
|
blockPointer++
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeTreeFile(writer io.WriterAt, buffer []byte, blockList []uint16) {
|
|
// write master index block with pointers to index blocks
|
|
indexBuffer := make([]byte, 512)
|
|
numberOfIndexBlocks := len(blockList)/256 + 1
|
|
if len(blockList)%256 == 0 {
|
|
numberOfIndexBlocks--
|
|
}
|
|
for i := 0; i < 256; i++ {
|
|
if i < numberOfIndexBlocks {
|
|
indexBuffer[i] = byte(blockList[i+1] & 0x00FF)
|
|
indexBuffer[i+256] = byte(blockList[i+1] >> 8)
|
|
} else {
|
|
indexBuffer[i] = 0
|
|
indexBuffer[i+256] = 0
|
|
}
|
|
}
|
|
WriteBlock(writer, blockList[0], indexBuffer)
|
|
numberOfIndexBlocks++
|
|
|
|
// write index blocks
|
|
for i := 0; i < len(blockList)/256+1; i++ {
|
|
for j := 0; j < 256; j++ {
|
|
if i*256+j < len(blockList)-numberOfIndexBlocks {
|
|
indexBuffer[j] = byte(blockList[i*256+numberOfIndexBlocks+j] & 0x00FF)
|
|
indexBuffer[j+256] = byte(blockList[i*256+j+2] >> 8)
|
|
} else {
|
|
indexBuffer[j] = 0
|
|
indexBuffer[j+256] = 0
|
|
}
|
|
}
|
|
WriteBlock(writer, blockList[i+1], indexBuffer)
|
|
}
|
|
|
|
// write all data blocks
|
|
blockBuffer := make([]byte, 512)
|
|
blockPointer := 0
|
|
blockIndexNumber := numberOfIndexBlocks
|
|
for i := 0; i < len(buffer); i++ {
|
|
blockBuffer[blockPointer] = buffer[i]
|
|
if blockPointer == 511 {
|
|
WriteBlock(writer, blockList[blockIndexNumber], blockBuffer)
|
|
blockPointer = 0
|
|
blockIndexNumber++
|
|
} else if i == len(buffer)-1 {
|
|
for j := blockPointer; j < 512; j++ {
|
|
blockBuffer[j] = 0
|
|
}
|
|
WriteBlock(writer, blockList[blockIndexNumber], blockBuffer)
|
|
} else {
|
|
blockPointer++
|
|
}
|
|
}
|
|
}
|
|
|
|
func getDataBlocklist(reader io.ReaderAt, fileEntry FileEntry) ([]uint16, error) {
|
|
return getBlocklist(reader, fileEntry, true)
|
|
}
|
|
|
|
func getAllBlockList(reader io.ReaderAt, fileEntry FileEntry) ([]uint16, error) {
|
|
return getBlocklist(reader, fileEntry, false)
|
|
}
|
|
|
|
// Returns all blocks, including index blocks
|
|
func getBlocklist(reader io.ReaderAt, fileEntry FileEntry, dataOnly bool) ([]uint16, error) {
|
|
blocks := make([]uint16, fileEntry.BlocksUsed)
|
|
|
|
switch fileEntry.StorageType {
|
|
case StorageSeedling:
|
|
blocks[0] = fileEntry.KeyPointer
|
|
return blocks, nil
|
|
case StorageSapling:
|
|
index, err := ReadBlock(reader, fileEntry.KeyPointer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
blockOffset := uint16(1)
|
|
blocks[0] = fileEntry.KeyPointer
|
|
for i := uint16(0); i < fileEntry.BlocksUsed-1; i++ {
|
|
blocks[i+blockOffset] = uint16(index[i]) + uint16(index[i+256])*256
|
|
}
|
|
if dataOnly {
|
|
return blocks[1:], nil
|
|
}
|
|
return blocks, nil
|
|
case StorageTree:
|
|
// this is actually too large
|
|
dataBlocks := make([]uint16, fileEntry.BlocksUsed)
|
|
// this is also actually too large
|
|
numberOfIndexBlocks := fileEntry.BlocksUsed/256 + 2
|
|
indexBlocks := make([]uint16, numberOfIndexBlocks)
|
|
masterIndex, err := ReadBlock(reader, fileEntry.KeyPointer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
numberOfDataBlocks := 0
|
|
|
|
indexBlocks[0] = fileEntry.KeyPointer
|
|
indexBlockCount := 1
|
|
|
|
for i := uint16(0); i < 128; i++ {
|
|
indexBlock := uint16(masterIndex[i]) + uint16(masterIndex[i+256])*256
|
|
if indexBlock == 0 {
|
|
break
|
|
}
|
|
indexBlocks[indexBlockCount] = indexBlock
|
|
indexBlockCount++
|
|
index, err := ReadBlock(reader, indexBlock)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for j := uint16(0); j < 256 && i*256+j < fileEntry.BlocksUsed; j++ {
|
|
if (uint16(index[j]) + uint16(index[j+256])*256) == 0 {
|
|
break
|
|
}
|
|
numberOfDataBlocks++
|
|
dataBlocks[i*256+j] = uint16(index[j]) + uint16(index[j+256])*256
|
|
}
|
|
}
|
|
|
|
if dataOnly {
|
|
return dataBlocks, nil
|
|
}
|
|
|
|
blocks = append(indexBlocks[0:numberOfIndexBlocks], dataBlocks[0:numberOfDataBlocks]...)
|
|
return blocks, nil
|
|
}
|
|
|
|
return nil, errors.New("unsupported file storage type")
|
|
}
|
|
|
|
func createBlockList(reader io.ReaderAt, fileSize uint32) ([]uint16, error) {
|
|
numberOfBlocks := uint16(fileSize / 512)
|
|
|
|
if fileSize%512 > 0 {
|
|
numberOfBlocks++
|
|
}
|
|
|
|
if fileSize > 0x200 && fileSize <= 0x20000 {
|
|
numberOfBlocks++ // add index block
|
|
}
|
|
|
|
if fileSize > 0x20000 && fileSize <= 0x1000000 {
|
|
// add index blocks for each 256 blocks
|
|
numberOfBlocks += numberOfBlocks / 256
|
|
// add index block for any remaining blocks
|
|
if numberOfBlocks%256 > 0 {
|
|
numberOfBlocks++
|
|
}
|
|
// add master index block
|
|
numberOfBlocks++
|
|
}
|
|
if fileSize > 0x1000000 {
|
|
return nil, errors.New("file size too large")
|
|
}
|
|
|
|
volumeBitmap, err := ReadVolumeBitmap(reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blockList := findFreeBlocks(volumeBitmap, numberOfBlocks)
|
|
|
|
return blockList[0:numberOfBlocks], nil
|
|
}
|
|
|
|
// GetFileEntry returns a file entry for the given path
|
|
func GetFileEntry(reader io.ReaderAt, path string) (FileEntry, error) {
|
|
directory, fileName := GetDirectoryAndFileNameFromPath(path)
|
|
_, _, fileEntries, err := ReadDirectory(reader, directory)
|
|
if err != nil {
|
|
return FileEntry{}, err
|
|
}
|
|
|
|
if fileEntries == nil || len(fileEntries) == 0 {
|
|
return FileEntry{}, errors.New("file entry not found")
|
|
}
|
|
|
|
var fileEntry FileEntry
|
|
|
|
for i := 0; i < len(fileEntries); i++ {
|
|
if fileEntries[i].FileName == fileName {
|
|
fileEntry = fileEntries[i]
|
|
}
|
|
}
|
|
|
|
if fileEntry.StorageType == StorageDeleted {
|
|
return FileEntry{}, errors.New("file not found")
|
|
}
|
|
|
|
return fileEntry, nil
|
|
}
|