mirror of
https://github.com/tjboldt/ProDOS-Utilities.git
synced 2024-12-03 14:49:31 +00:00
318 lines
9.1 KiB
Go
318 lines
9.1 KiB
Go
// Copyright Terence J. Boldt (c)2021-2024
|
|
// Use of this source code is governed by an MIT
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This file provides a command line utility to read, write and delete
|
|
// files and directories on a ProDOS drive image as well as format
|
|
// new volumes
|
|
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/tjboldt/ProDOS-Utilities/prodos"
|
|
)
|
|
|
|
const version = "0.5.1"
|
|
|
|
func main() {
|
|
var fileName string
|
|
var pathName string
|
|
var command string
|
|
var outFileName string
|
|
var inFileName string
|
|
var blockNumber uint
|
|
var volumeSize uint
|
|
var volumeName string
|
|
var fileType uint
|
|
var auxType uint
|
|
flag.StringVar(&fileName, "d", "", "A ProDOS format drive image")
|
|
flag.StringVar(&pathName, "p", "", "Path name in ProDOS drive image (default is root of volume)")
|
|
flag.StringVar(&command, "c", "ls", "Command to execute: ls, create, rm, mkdir, get, getraw, put, putall, putallrecursive, readblock, writeblock")
|
|
flag.StringVar(&outFileName, "o", "", "Name of file to write")
|
|
flag.StringVar(&inFileName, "i", "", "Name of file to read")
|
|
flag.UintVar(&volumeSize, "s", 65535, "Number of blocks to create the volume with (default 65535, 64 to 65535, 0x0040 to 0xFFFF hex input accepted)")
|
|
flag.StringVar(&volumeName, "v", "NO.NAME", "Specifiy a name for the volume from 1 to 15 characters")
|
|
flag.UintVar(&blockNumber, "b", 0, "A block number to read/write from 0 to 65535 (0x0000 to 0xFFFF hex input accepted)")
|
|
flag.UintVar(&fileType, "t", 0, "ProDOS FileType: 0x04 for TXT, 0x06 for BIN, 0xFC for BAS, 0xFF for SYS etc., omit to autodetect")
|
|
flag.UintVar(&auxType, "a", 0, "ProDOS AuxType from 0 to 65535 (0x0000 to 0xFFFF hex input accepted), omit to autodetect")
|
|
flag.Parse()
|
|
|
|
if len(fileName) == 0 {
|
|
printReadme()
|
|
flag.PrintDefaults()
|
|
os.Exit(1)
|
|
}
|
|
|
|
switch command {
|
|
case "ls":
|
|
ls(fileName, pathName)
|
|
case "get":
|
|
get(fileName, pathName, outFileName)
|
|
case "getraw":
|
|
getRaw(fileName, pathName)
|
|
case "put":
|
|
put(fileName, pathName, uint8(fileType), uint16(auxType), inFileName)
|
|
case "readblock":
|
|
readBlock(uint16(blockNumber), fileName)
|
|
case "writeblock":
|
|
writeBlock(uint16(blockNumber), fileName, inFileName)
|
|
case "create":
|
|
create(fileName, volumeName, uint16(volumeSize))
|
|
case "putall":
|
|
putall(fileName, inFileName, pathName, false)
|
|
case "putallrecursive":
|
|
putall(fileName, inFileName, pathName, true)
|
|
case "rm":
|
|
rm(fileName, pathName)
|
|
case "mkdir":
|
|
mkdir(fileName, pathName)
|
|
case "dumpfile":
|
|
dumpFile(fileName, pathName)
|
|
case "dumpdirectory":
|
|
dumpDirectory(fileName, pathName)
|
|
default:
|
|
fmt.Printf("Invalid command: %s\n\n", command)
|
|
flag.PrintDefaults()
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func dumpFile(fileName string, pathName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
fileEntry, err := prodos.GetFileEntry(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to path %s:\n %s", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
prodos.DumpFileEntry(fileEntry)
|
|
}
|
|
|
|
func dumpDirectory(fileName string, pathName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
_, directoryheader, _, err := prodos.ReadDirectory(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to read directory %s:\n %s", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
prodos.DumpDirectoryHeader(directoryheader)
|
|
}
|
|
|
|
func mkdir(fileName string, pathName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDWR, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
err = prodos.CreateDirectory(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("failed to create directory %s: %s\n", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func rm(fileName string, pathName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDWR, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
prodos.DeleteFile(file, pathName)
|
|
}
|
|
|
|
func putall(fileName string, inFileName string, pathName string, recursive bool) {
|
|
if len(inFileName) == 0 {
|
|
inFileName = "."
|
|
}
|
|
file, err := os.OpenFile(fileName, os.O_RDWR, 0755)
|
|
if err != nil {
|
|
fmt.Printf("failed to create file: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
err = prodos.AddFilesFromHostDirectory(file, inFileName, pathName, recursive)
|
|
if err != nil {
|
|
fmt.Printf("failed to add host files: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func create(fileName string, volumeName string, volumeSize uint16) {
|
|
file, err := os.Create(fileName)
|
|
if err != nil {
|
|
fmt.Printf("failed to create file: %s\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
prodos.CreateVolume(file, volumeName, volumeSize)
|
|
}
|
|
|
|
func writeBlock(blockNumber uint16, fileName string, inFileName string) {
|
|
checkInFileName(inFileName)
|
|
fmt.Printf("Writing block 0x%04X (%d):\n\n", blockNumber, blockNumber)
|
|
file, err := os.OpenFile(fileName, os.O_RDWR, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
inFile, err := os.ReadFile(inFileName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open input file %s: %s", inFileName, err)
|
|
os.Exit(1)
|
|
}
|
|
prodos.WriteBlock(file, blockNumber, inFile)
|
|
}
|
|
|
|
func readBlock(blockNumber uint16, fileName string) {
|
|
fmt.Printf("Reading block 0x%04X (%d):\n\n", blockNumber, blockNumber)
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
block, err := prodos.ReadBlock(file, blockNumber)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
prodos.DumpBlock(block)
|
|
}
|
|
|
|
func put(fileName string, pathName string, fileType uint8, auxType uint16, inFileName string) {
|
|
checkPathName(pathName)
|
|
checkInFileName(inFileName)
|
|
file, err := os.OpenFile(fileName, os.O_RDWR, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
fileInfo, err := os.Stat(fileName)
|
|
if err != nil {
|
|
fmt.Printf("Failed get fileInfo for %s - %s", fileName, err)
|
|
}
|
|
|
|
err = prodos.WriteFileFromFile(file, pathName, fileType, auxType, fileInfo.ModTime(), inFileName, false)
|
|
if err != nil {
|
|
fmt.Printf("Failed to write file %s", err)
|
|
}
|
|
}
|
|
|
|
func get(fileName string, pathName string, outFileName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
getFile, err := prodos.LoadFile(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to read file %s: %s\n", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
if len(outFileName) == 0 {
|
|
_, outFileName = prodos.GetDirectoryAndFileNameFromPath(pathName)
|
|
}
|
|
outFile, err := os.Create(outFileName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to create output file %s: %s\n", outFileName, err)
|
|
os.Exit(1)
|
|
}
|
|
if strings.HasSuffix(strings.ToLower(outFileName), ".bas") {
|
|
fmt.Fprint(outFile, prodos.ConvertBasicToText(getFile))
|
|
} else {
|
|
outFile.Write(getFile)
|
|
}
|
|
}
|
|
|
|
func getRaw(fileName string, pathName string) {
|
|
checkPathName(pathName)
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
getFile, err := prodos.LoadFile(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to read file %s: %s\n", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
fileEntry, err := prodos.GetFileEntry(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to get file entry %s: %s\n", pathName, err)
|
|
os.Exit(1)
|
|
}
|
|
fileType := prodos.FileTypeToString(fileEntry.FileType)
|
|
outFileName := fmt.Sprintf("%s.%s$%04X", fileEntry.FileName, fileType, fileEntry.AuxType)
|
|
|
|
outFile, err := os.Create(outFileName)
|
|
if err != nil {
|
|
fmt.Printf("Failed to create output file %s: %s\n", outFileName, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
outFile.Write(getFile)
|
|
}
|
|
|
|
func ls(fileName string, pathName string) {
|
|
file, err := os.OpenFile(fileName, os.O_RDONLY, 0755)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
defer file.Close()
|
|
pathName = strings.ToUpper(pathName)
|
|
volumeHeader, _, fileEntries, err := prodos.ReadDirectory(file, pathName)
|
|
if err != nil {
|
|
fmt.Printf("Error: %s", err)
|
|
}
|
|
if len(pathName) == 0 {
|
|
pathName = "/" + volumeHeader.VolumeName
|
|
}
|
|
volumeBitmap, err := prodos.ReadVolumeBitmap(file)
|
|
if err != nil {
|
|
fmt.Printf("Failed to open drive image %s:\n %s", fileName, err)
|
|
os.Exit(1)
|
|
}
|
|
freeBlocks := prodos.GetFreeBlockCount(volumeBitmap, volumeHeader.TotalBlocks)
|
|
prodos.DumpDirectory(freeBlocks, volumeHeader.TotalBlocks, pathName, fileEntries)
|
|
}
|
|
|
|
func checkPathName(pathName string) {
|
|
if len(pathName) == 0 {
|
|
fmt.Printf("Missing path name (use -p PATHNAME)\n")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func checkInFileName(inFileName string) {
|
|
if len(inFileName) == 0 {
|
|
fmt.Printf("Missing input file name (use -i FILENAME)\n")
|
|
os.Exit(1)
|
|
}
|
|
}
|