Apple-2-Tools
/
diskm8
mirror of https://github.com/paleotronic/diskm8.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
diskm8/disk/diskimagepd.go

1898 lines
42 KiB
Go
Raw Blame History

package disk
import (
"errors"
"regexp"
"strings"
"time"
)
type VDH struct {
Data []byte
blockid int
blockoffset int
}
func (fd *VDH) CreateTime() time.Time {
b := fd.Data[0x1C:0x20]
return prodosStampBytesToTime(b)
}
func (fd *VDH) SetCreateTime(t time.Time) {
b := timeToProdosStampBytes(t)
for i, v := range b {
fd.Data[0x1C+i] = v
}
}
func (fd *VDH) SetData(data []byte, blockid, blockoffset int) {
fd.blockid = blockid
fd.blockoffset = blockoffset
if fd.Data == nil && len(data) == 39 {
fd.Data = data
//Println("VDH: ")
//Dump(data)
}
for i, v := range data {
fd.Data[i] = v
}
}
func (fd *VDH) SetName(name string) {
name = strings.ToUpper(name)
if len(name) > 15 {
name = name[:15]
}
l := len(name)
for i, v := range []byte(name) {
fd.Data[1+i] = v
}
fd.Data[0] = (fd.Data[0] & 0xf0) | byte(l)
}
func (fd *VDH) SetStorageType(t ProDOSStorageType) {
fd.Data[0] = (fd.Data[0] & 0x0f) | (byte(t) << 4)
}
func (fd *VDH) GetNameLength() int {
return int(fd.Data[0] & 0xf)
}
func (fd *VDH) SetNameLength(l int) {
fd.Data[0] = (fd.Data[0] & 0xf0) | byte(l&0x0f)
}
func (fd *VDH) GetStorageType() ProDOSStorageType {
return ProDOSStorageType((fd.Data[0]) >> 4)
}
func (fd *VDH) GetDirName() string {
return fd.GetVolumeName()
}
func (fd *VDH) SetVolumeName(s string) {
if len(s) > 15 {
s = s[:15]
}
l := len(s)
for i := 0; i < 15; i++ {
if i < l {
fd.Data[1+i] = byte(s[i])
} else {
fd.Data[1+i] = 0x00
}
}
fd.SetNameLength(l)
}
func (fd *VDH) GetVolumeName() string {
l := fd.GetNameLength()
b := fd.Data[1 : 1+l]
s := ""
for _, v := range b {
s += string(rune(PokeToAscii(uint(v), false)))
}
return strings.Trim(s, " ")
}
func (fd *VDH) GetVersion() int {
return int(fd.Data[28])
}
func (fd *VDH) SetVersion(b int) {
fd.Data[28] = byte(b)
}
func (fd *VDH) GetMinVersion() int {
return int(fd.Data[29])
}
func (fd *VDH) SetMinVersion(b int) {
fd.Data[29] = byte(b)
}
func (fd *VDH) GetAccess() ProDOSAccessMode {
return ProDOSAccessMode(fd.Data[30])
}
func (fd *VDH) SetAccess(m ProDOSAccessMode) {
fd.Data[30] = byte(m)
}
func (fd *VDH) GetEntryLength() int {
return int(fd.Data[31])
}
func (fd *VDH) SetEntryLength(b int) {
fd.Data[31] = byte(b & 0xff)
}
func (fd *VDH) GetEntriesPerBlock() int {
return int(fd.Data[32])
}
func (fd *VDH) SetEntriesPerBlock(b int) {
fd.Data[32] = byte(b & 0xff)
}
func (fd *VDH) GetFileCount() int {
return int(fd.Data[33]) + 256*int(fd.Data[34])
}
func (fd *VDH) SetFileCount(c int) {
fd.Data[33] = byte(c & 0xff)
fd.Data[34] = byte(c / 0x100)
}
func (fd *VDH) GetBitmapPointer() int {
return int(fd.Data[35]) + 256*int(fd.Data[36])
}
func (fd *VDH) GetTotalBlocks() int {
return int(fd.Data[37]) + 256*int(fd.Data[38])
}
func (fd *VDH) SetTotalBlocks(b int) {
fd.Data[37] = byte(b % 256)
fd.Data[38] = byte(b / 256)
}
func (fd *VDH) GetDirParentPointer() int {
return int(fd.Data[35]) + 256*int(fd.Data[35])
}
func (fd *VDH) SetDirParentPointer(b int) {
fd.Data[35] = byte(b & 0xff)
fd.Data[36] = byte(b / 0x100)
}
func (fd *VDH) GetDirParentEntry() int {
return int(fd.Data[37])
}
func (fd *VDH) SetDirParentEntry(b int) {
fd.Data[37] = byte(b & 0xff)
}
func (fd *VDH) GetDirParentEntryLength() int {
return int(fd.Data[38])
}
func (fd *VDH) SetDirParentEntryLength(b int) {
fd.Data[38] = byte(b & 0xff)
}
func (fd *VDH) Publish(dsk *DSKWrapper) error {
bd, err := dsk.PRODOSGetBlock(fd.blockid)
if err != nil {
return err
}
for i, v := range fd.Data {
bd[fd.blockoffset+i] = v
}
//fmt.Printf("Writing dir header at block %d\n", fd.blockid)
//fmt.Printf("Data=%v\n", bd)
return dsk.PRODOSWrite(fd.blockid, bd)
}
func (dsk *DSKWrapper) IsProDOS() (bool, DiskFormat, SectorOrder) {
oldFormat := dsk.Format
oldLayout := dsk.Layout
defer func() {
dsk.Format = oldFormat
dsk.Layout = oldLayout
}()
if len(dsk.Data) == STD_DISK_BYTES {
layouts := []SectorOrder{SectorOrderDOS33, SectorOrderDOS33Alt, SectorOrderProDOS, SectorOrderProDOSLinear}
for _, l := range layouts {
dsk.Layout = l
vdh, err := dsk.PRODOSGetVDH(2)
if err != nil {
return false, oldFormat, oldLayout
}
if vdh.GetTotalBlocks() == 280 && vdh.GetStorageType() == 0xf {
return true, GetDiskFormat(DF_PRODOS), l
}
}
} else if len(dsk.Data) == PRODOS_800KB_DISK_BYTES {
layouts := []SectorOrder{SectorOrderDOS33, SectorOrderDOS33Alt, SectorOrderProDOS}
for _, l := range layouts {
dsk.Layout = l
vdh, err := dsk.PRODOSGetVDH(2)
if err != nil {
return false, oldFormat, oldLayout
}
if vdh.GetTotalBlocks() == 1600 && vdh.GetStorageType() == 0xf {
return true, GetDiskFormat(DF_PRODOS_800KB), l
}
}
}
return false, oldFormat, oldLayout
}
func (dsk *DSKWrapper) PRODOS800GetVolumeBitmap() (ProDOSVolumeBitmap, error) {
var vb ProDOSVolumeBitmap
vdh, err := dsk.PRODOS800GetVDH(2)
if err != nil {
return vb, err
}
b := vdh.GetBitmapPointer()
data, err := dsk.PRODOS800GetBlock(b)
if err != nil {
return vb, err
}
//copy(vb[:], data)
vb = ProDOSVolumeBitmap{
Data: data,
blockid: b,
blockoffset: 0,
}
return vb, nil
}
func (dsk *DSKWrapper) PRODOSGetVolumeBitmap() (ProDOSVolumeBitmap, error) {
var vb ProDOSVolumeBitmap
vdh, err := dsk.PRODOSGetVDH(2)
if err != nil {
return vb, err
}
b := vdh.GetBitmapPointer()
data, err := dsk.PRODOSGetBlock(b)
if err != nil {
return vb, err
}
//copy(vb[:], data)
vb = ProDOSVolumeBitmap{
Data: data,
blockid: b,
blockoffset: 0,
}
return vb, nil
}
type ProDOSVolumeBitmap struct {
Data []byte
blockid int
blockoffset int
}
func (vb ProDOSVolumeBitmap) IsBlockFree(b int) bool {
bidx := b / 8
bit := 7 - (b % 8)
mask := byte(1 << uint(bit))
return (vb.Data[bidx] & mask) == mask
}
func (vb ProDOSVolumeBitmap) SetBlockFree(b int, free bool) {
//log.Printf("Freeing block %d", b)
bidx := b / 8
bit := 7 - (b % 8)
setmask := byte(1 << uint(bit))
clrmask := 0xff ^ setmask
if free {
vb.Data[bidx] = vb.Data[bidx] | setmask
} else {
vb.Data[bidx] = vb.Data[bidx] & clrmask
}
}
// -- Prodos file descriptor
type ProDOSFileDescriptor struct {
Data []byte
blockid int
blockoffset int
entryNum int
}
func (fd *ProDOSFileDescriptor) SetData(data []byte, blockid int, blockoffset int) {
fd.blockid = blockid
fd.blockoffset = blockoffset
if fd.Data == nil && len(data) == 39 {
fd.Data = data
return
}
for i, v := range data {
fd.Data[i] = v
}
}
func (fd *ProDOSFileDescriptor) GetNameLength() int {
return int(fd.Data[0] & 0xf)
}
func (fd *ProDOSFileDescriptor) GetStorageType() ProDOSStorageType {
return ProDOSStorageType((fd.Data[0]) >> 4)
}
func (fd *ProDOSFileDescriptor) Name() string {
l := fd.GetNameLength()
b := fd.Data[1 : 1+l]
s := ""
for _, v := range b {
s += string(rune(PokeToAscii(uint(v), false)))
}
s = strings.ToLower(strings.Trim(s, " "))
switch fd.Type() {
case FileType_PD_APP:
s += ".a"
case FileType_PD_INT:
s += ".i"
case FileType_PD_BIN:
s += ".s"
case FileType_PD_TXT:
s += ".t"
case FileType_PD_SYS:
s += ".s"
}
return s
}
func (fd *ProDOSFileDescriptor) NameUnadorned() string {
l := fd.GetNameLength()
b := fd.Data[1 : 1+l]
s := ""
for _, v := range b {
s += string(rune(PokeToAscii(uint(v), false)))
}
s = strings.ToLower(strings.Trim(s, " "))
return s
}
func (fd *ProDOSFileDescriptor) SetName(name string) {
name = strings.ToUpper(name)
if len(name) > 15 {
name = name[:15]
}
l := len(name)
for i, v := range []byte(name) {
fd.Data[1+i] = v
}
fd.Data[0] = (fd.Data[0] & 0xf0) | byte(l)
}
func (fd *ProDOSFileDescriptor) SetStorageType(t ProDOSStorageType) {
fd.Data[0] = (fd.Data[0] & 0x0f) | (byte(t) << 4)
}
func (fd *ProDOSFileDescriptor) SetAccessMode(t ProDOSAccessMode) {
fd.Data[0x1e] = byte(t)
}
func (fd *ProDOSFileDescriptor) AccessMode() ProDOSAccessMode {
return ProDOSAccessMode(fd.Data[0x1e])
}
func (fd *ProDOSFileDescriptor) SetLocked(b bool) {
accessMode := fd.AccessMode()
if b {
accessMode = accessMode & (AccessType_Changed | AccessType_Readable)
} else {
accessMode = accessMode | AccessType_Destroy | AccessType_Writable | AccessType_Rename
}
fd.SetAccessMode(accessMode)
}
func (fd *ProDOSFileDescriptor) IsLocked() bool {
a := fd.AccessMode()
return a&(AccessType_Destroy|AccessType_Rename|AccessType_Writable) == 0
}
func prodosStampBytesToTime(in []byte) time.Time {
dbits := (int(in[0x01]) << 8) | int(in[0x00])
day := dbits & 31
month := (dbits >> 5) & 15
year := (dbits >> 9) & 127
tbits := (int(in[0x03]) << 8) | int(in[0x02])
mins := tbits & 63
hours := (tbits >> 8)
if year < 70 {
year += 100
}
year += 1900
return time.Date(year, time.Month(month), day, hours, mins, 0, 0, time.Local)
}
func timeToProdosStampBytes(t time.Time) []byte {
year, month, day, hour, minute := t.Year(), int(t.Month()), t.Day(), t.Hour(), t.Minute()
year = year - 1900
if year > 99 {
year -= 100
}
dbits := (year << 9) | (month << 5) | day
tbits := (hour << 8) | minute
return []byte{
byte(dbits & 0xff),
byte(dbits >> 8),
byte(tbits & 0xff),
byte(tbits >> 8),
}
}
func (fd *ProDOSFileDescriptor) CreateTime() time.Time {
b := fd.Data[0x18:0x1C]
return prodosStampBytesToTime(b)
}
func (fd *ProDOSFileDescriptor) SetCreateTime(t time.Time) {
b := timeToProdosStampBytes(t)
for i, v := range b {
fd.Data[0x18+i] = v
}
}
func (fd *ProDOSFileDescriptor) ModTime() time.Time {
b := fd.Data[0x21:0x25]
return prodosStampBytesToTime(b)
}
func (fd *ProDOSFileDescriptor) SetModTime(t time.Time) {
b := timeToProdosStampBytes(t)
for i, v := range b {
fd.Data[0x21+i] = v
}
}
func (fd *ProDOSFileDescriptor) GetVersion() int {
return int(fd.Data[0x1c])
}
func (fd *ProDOSFileDescriptor) SetVersion(b int) {
fd.Data[0x1c] = byte(b)
}
func (fd *ProDOSFileDescriptor) GetMinVersion() int {
return int(fd.Data[0x1d])
}
func (fd *ProDOSFileDescriptor) SetMinVersion(b int) {
fd.Data[0x1d] = byte(b)
}
type ProDOSAccessMode byte
const (
AccessType_Destroy ProDOSAccessMode = 0x80
AccessType_Rename ProDOSAccessMode = 0x40
AccessType_Changed ProDOSAccessMode = 0x20
AccessType_Writable ProDOSAccessMode = 0x02
AccessType_Readable ProDOSAccessMode = 0x01
//
AccessType_Default ProDOSAccessMode = AccessType_Readable | AccessType_Writable | AccessType_Rename | AccessType_Destroy
)
type ProDOSStorageType byte
const (
StorageType_Inactive ProDOSStorageType = 0x0
StorageType_Seedling ProDOSStorageType = 0x1
StorageType_Sapling ProDOSStorageType = 0x2
StorageType_Tree ProDOSStorageType = 0x3
StorageType_SubDir_File ProDOSStorageType = 0xd
StorageType_SubDir_Header ProDOSStorageType = 0xe
StorageType_Volume_Header ProDOSStorageType = 0xf
)
type ProDOSFileType byte
const (
FileType_PD_None ProDOSFileType = 0x00
FileType_PD_TXT ProDOSFileType = 0x04
FileType_PD_Directory ProDOSFileType = 0x0f
FileType_PD_BIN ProDOSFileType = 0x06
FileType_PD_INT ProDOSFileType = 0xfa
FileType_PD_INT_Var ProDOSFileType = 0xfb
FileType_PD_APP ProDOSFileType = 0xfc
FileType_PD_APP_Var ProDOSFileType = 0xfd
FileType_PD_Reloc ProDOSFileType = 0xfe
FileType_PD_SYS ProDOSFileType = 0xff
)
var ProDOSTypeMap = map[ProDOSFileType][2]string{
0x00: [2]string{"UNK", "Unknown"},
0x01: [2]string{"BAD", "Bad Block"},
0x02: [2]string{"PCD", "Pascal Code"},
0x03: [2]string{"PTX", "Pascal Text"},
0x04: [2]string{"TXT", "ASCII Text"},
0x05: [2]string{"PDA", "Pascal Data"},
0x06: [2]string{"BIN", "Binary File"},
0x07: [2]string{"FNT", "Apple III Font"},
0x08: [2]string{"FOT", "HiRes/Double HiRes Graphics"},
0x09: [2]string{"BA3", "Apple III Basic Program"},
0x0A: [2]string{"DA3", "Apple III Basic Data"},
0x0B: [2]string{"WPF", "Generic Word Processing"},
0x0C: [2]string{"SOS", "SOS System File"},
0x0F: [2]string{"DIR", "ProDOS Directory"},
0x10: [2]string{"RPD", "RPS Data"},
0x11: [2]string{"RPI", "RPS Index"},
0x12: [2]string{"AFD", "AppleFile Discard"},
0x13: [2]string{"AFM", "AppleFile Model"},
0x14: [2]string{"AFR", "AppleFile Report"},
0x15: [2]string{"SCL", "Screen Library"},
0x16: [2]string{"PFS", "PFS Document"},
0x19: [2]string{"ADB", "AppleWorks Database"},
0x1A: [2]string{"AWP", "AppleWorks Word Processing"},
0x1B: [2]string{"ASP", "AppleWorks Spreadsheet"},
0x80: [2]string{"GES", "System File"},
0x81: [2]string{"GEA", "Desk Accessory"},
0x82: [2]string{"GEO", "Application"},
0x83: [2]string{"GED", "Document"},
0x84: [2]string{"GEF", "Font"},
0x85: [2]string{"GEP", "Printer Driver"},
0x86: [2]string{"GEI", "Input Driver"},
0x87: [2]string{"GEX", "Auxiliary Driver"},
0x89: [2]string{"GEV", "Swap File"},
0x8B: [2]string{"GEC", "Clock Driver"},
0x8C: [2]string{"GEK", "Interface Card Driver"},
0x8D: [2]string{"GEW", "Formatting Data"},
0xA0: [2]string{"WP", " WordPerfect"},
0xAB: [2]string{"GSB", "Apple IIgs BASIC Program"},
0xAC: [2]string{"TDF", "Apple IIgs BASIC TDF"},
0xAD: [2]string{"BDF", "Apple IIgs BASIC Data"},
0x60: [2]string{"PRE", "PC Pre-Boot"},
0x6B: [2]string{"BIO", "PC BIOS"},
0x66: [2]string{"NCF", "ProDOS File Navigator Command File"},
0x6D: [2]string{"DVR", "PC Driver"},
0x6E: [2]string{"PRE", "PC Pre-Boot"},
0x6F: [2]string{"HDV", "PC Hard Disk Image"},
0x50: [2]string{"GWP", "Apple IIgs Word Processing"},
0x51: [2]string{"GSS", "Apple IIgs Spreadsheet"},
0x52: [2]string{"GDB", "Apple IIgs Database"},
0x53: [2]string{"DRW", "Object Oriented Graphics"},
0x54: [2]string{"GDP", "Apple IIgs Desktop Publishing"},
0x55: [2]string{"HMD", "HyperMedia"},
0x56: [2]string{"EDU", "Educational Program Data"},
0x57: [2]string{"STN", "Stationery"},
0x58: [2]string{"HLP", "Help File"},
0x59: [2]string{"COM", "Communications"},
0x5A: [2]string{"CFG", "Configuration"},
0x5B: [2]string{"ANM", "Animation"},
0x5C: [2]string{"MUM", "Multimedia"},
0x5D: [2]string{"ENT", "Entertainment"},
0x5E: [2]string{"DVU", "Development Utility"},
0x41: [2]string{"OCR", "Optical Character Recognition"},
0x42: [2]string{"FTD", "File Type Definitions"},
0x20: [2]string{"TDM", "Desktop Manager File"},
0x21: [2]string{"IPS", "Instant Pascal Source"},
0x22: [2]string{"UPV", "UCSD Pascal Volume"},
0x29: [2]string{"3SD", "SOS Directory"},
0x2A: [2]string{"8SC", "Source Code"},
0x2B: [2]string{"8OB", "Object Code"},
0x2C: [2]string{"8IC", "Interpreted Code"},
0x2D: [2]string{"8LD", "Language Data"},
0x2E: [2]string{"P8C", "ProDOS 8 Code Module"},
0xB0: [2]string{"SRC", "Apple IIgs Source Code"},
0xB1: [2]string{"OBJ", "Apple IIgs Object Code"},
0xB2: [2]string{"LIB", "Apple IIgs Library"},
0xB3: [2]string{"S16", "Apple IIgs Application Program"},
0xB4: [2]string{"RTL", "Apple IIgs Runtime Library"},
0xB5: [2]string{"EXE", "Apple IIgs Shell Script"},
0xB6: [2]string{"PIF", "Apple IIgs Permanent INIT"},
0xB7: [2]string{"TIF", "Apple IIgs Temporary INIT"},
0xB8: [2]string{"NDA", "Apple IIgs New Desk Accessory"},
0xB9: [2]string{"CDA", "Apple IIgs Classic Desk Accessory"},
0xBA: [2]string{"TOL", "Apple IIgs Tool"},
0xBB: [2]string{"DRV", "Apple IIgs Device Driver"},
0xBC: [2]string{"LDF", "Apple IIgs Generic Load File"},
0xBD: [2]string{"FST", "Apple IIgs File System Translator"},
0xBF: [2]string{"DOC", "Apple IIgs Document "},
0xC0: [2]string{"PNT", "Apple IIgs Packed Super HiRes"},
0xC1: [2]string{"PIC", "Apple IIgs Super HiRes"},
0xC2: [2]string{"ANI", "PaintWorks Animation"},
0xC3: [2]string{"PAL", "PaintWorks Palette"},
0xC5: [2]string{"OOG", "Object-Oriented Graphics"},
0xC6: [2]string{"SCR", "Script"},
0xC7: [2]string{"CDV", "Apple IIgs Control Panel"},
0xC8: [2]string{"FON", "Apple IIgs Font"},
0xC9: [2]string{"FND", "Apple IIgs Finder Data"},
0xCA: [2]string{"ICN", "Apple IIgs Icon "},
0xD5: [2]string{"MUS", "Music"},
0xD6: [2]string{"INS", "Instrument"},
0xD7: [2]string{"MDI", "MIDI"},
0xD8: [2]string{"SND", "Apple IIgs Audio"},
0xDB: [2]string{"DBM", "DB Master Document"},
0xE0: [2]string{"LBR", "Archive"},
0xE2: [2]string{"ATK", "AppleTalk Data"},
0xEE: [2]string{"R16", "EDASM 816 Relocatable Code"},
0xEF: [2]string{"PAR", "Pascal Area"},
0xF0: [2]string{"CMD", "ProDOS Command File"},
0xF1: [2]string{"OVL", "User Defined 1"},
0xF2: [2]string{"UD2", "User Defined 2"},
0xF3: [2]string{"UD3", "User Defined 3"},
0xF4: [2]string{"UD4", "User Defined 4"},
0xF5: [2]string{"BAT", "User Defined 5"},
0xF6: [2]string{"UD6", "User Defined 6"},
0xF7: [2]string{"UD7", "User Defined 7"},
0xF8: [2]string{"PRG", "User Defined 8"},
0xF9: [2]string{"P16", "ProDOS-16 System File"},
0xFA: [2]string{"INT", "Integer BASIC Program"},
0xFB: [2]string{"IVR", "Integer BASIC Variables"},
0xFC: [2]string{"BAS", "Applesoft BASIC Program"},
0xFD: [2]string{"VAR", "Applesoft BASIC Variables"},
0xFE: [2]string{"REL", "EDASM Relocatable Code"},
0xFF: [2]string{"SYS", "ProDOS-8 System File"},
}
func (t ProDOSFileType) String() string {
info, ok := ProDOSTypeMap[t]
if ok {
return info[1]
}
return "Unknown"
}
func (ft ProDOSFileType) Ext() string {
info, ok := ProDOSTypeMap[ft]
if ok {
return info[0]
}
return "BIN"
}
func ProDOSFileTypeFromExt(ext string) ProDOSFileType {
for ft, info := range ProDOSTypeMap {
if strings.ToUpper(ext) == info[0] {
return ft
}
}
return 0x06
}
func (t ProDOSFileType) Valid() bool {
if t == FileType_PD_None {
return false
}
_, ok := ProDOSTypeMap[t]
return ok
}
func (fd *ProDOSFileDescriptor) Type() ProDOSFileType {
return ProDOSFileType(fd.Data[16])
}
func (fd *ProDOSFileDescriptor) SetType(t ProDOSFileType) {
fd.Data[16] = byte(t)
}
func (fd *ProDOSFileDescriptor) IndexBlock() int {
return int(fd.Data[17]) + 256*int(fd.Data[18])
}
func (fd *ProDOSFileDescriptor) SetIndexBlock(b int) {
fd.Data[17] = byte(b & 0xff)
fd.Data[18] = byte(b / 256)
}
func (fd *ProDOSFileDescriptor) TotalBlocks() int {
return int(fd.Data[19]) + 256*int(fd.Data[20])
}
func (fd *ProDOSFileDescriptor) SetTotalBlocks(b int) {
fd.Data[19] = byte(b & 0xff)
fd.Data[20] = byte(b / 256)
}
func (fd *ProDOSFileDescriptor) AuxType() int {
return int(fd.Data[31]) + 256*int(fd.Data[32])
}
func (fd *ProDOSFileDescriptor) SetAuxType(b int) {
fd.Data[31] = byte(b & 0xff)
fd.Data[32] = byte(b / 256)
}
func (fd *ProDOSFileDescriptor) TotalSectors() int {
return fd.TotalBlocks() / 2
}
func (fd *ProDOSFileDescriptor) Size() int {
return int(fd.Data[21]) + 256*int(fd.Data[22]) + 65536*int(fd.Data[23])
}
func (fd *ProDOSFileDescriptor) SetSize(v int) {
fd.Data[21] = byte(v & 0xff)
fd.Data[22] = byte((v >> 8) & 0xff)
fd.Data[23] = byte((v >> 16) & 0xff)
}
func (fd *ProDOSFileDescriptor) SetHeaderPointer(v int) {
fd.Data[0x25] = byte(v & 0xff)
fd.Data[0x26] = byte((v >> 8) & 0xff)
}
func (fd *ProDOSFileDescriptor) HeaderPointer() int {
return int(fd.Data[0x25]) + 256*int(fd.Data[0x26])
}
func (d *DSKWrapper) PRODOS800GetBlock(block int) ([]byte, error) {
t, s1, s2 := d.PRODOS800GetBlockSectors(block)
e := d.Seek(t, s1)
if e != nil {
return []byte(nil), e
}
data := make([]byte, 0)
c1 := d.Read()
data = append(data, c1...)
e = d.Seek(t, s2)
if e != nil {
return []byte(nil), e
}
c2 := d.Read()
data = append(data, c2...)
return data, nil
}
func (d *DSKWrapper) PRODOSGetBlock(block int) ([]byte, error) {
t, s1, s2 := d.PRODOSGetBlockSectors(block)
e := d.Seek(t, s1)
if e != nil {
return []byte(nil), e
}
data := make([]byte, 0)
c1 := d.Read()
data = append(data, c1...)
e = d.Seek(t, s2)
if e != nil {
return []byte(nil), e
}
c2 := d.Read()
data = append(data, c2...)
return data, nil
}
func (d *DSKWrapper) PRODOS800GetVDH(b int) (*VDH, error) {
data, e := d.PRODOS800GetBlock(b)
if e != nil {
return nil, e
}
vdh := &VDH{}
vdh.SetData(data[4:43], b, 4)
return vdh, nil
}
func (d *DSKWrapper) PRODOSGetVDH(b int) (*VDH, error) {
data, e := d.PRODOSGetBlock(b)
if e != nil {
return nil, e
}
vdh := &VDH{}
vdh.SetData(data[4:43], b, 4)
return vdh, nil
}
func (d *DSKWrapper) PRODOSSetVDH(b int, vdh *VDH) error {
data, e := d.PRODOSGetBlock(b)
if e != nil {
return e
}
for i, v := range vdh.Data {
data[4+i] = v
}
return d.PRODOSWrite(b, data)
}
func (d *DSKWrapper) PRODOSGetCatalogPathed(start int, path string, pattern string) (*VDH, []ProDOSFileDescriptor, error) {
path = strings.Trim(path, "/")
//fmt.Printf("PRODOSGetCatalogPathed(%d, \"%s\", \"%s\" )\n", start, path, pattern)
//start := 2 // where we start our descent
if path != "" {
parts := strings.Split(strings.Trim(path, "/"), "/")
subdir := parts[0]
parts = parts[1:]
// find subdirectories
vdh, files, e := d.PRODOSGetCatalog(start, subdir)
if e != nil {
return vdh, files, e
}
if len(files) != 1 {
return vdh, files, e
}
if files[0].Type() != FileType_PD_Directory {
return vdh, files, errors.New("Not a directory")
}
// ok, we found the directory...
if len(parts) > 0 {
// more subdirs
//fmt.Printf(">> Entering prodos subdir [%s]\n", files[0].Name())
newpathstr := strings.Join(parts, "/")
return d.PRODOSGetCatalogPathed(files[0].IndexBlock(), newpathstr, pattern)
} else {
// get directory based on this block
//fmt.Printf("-- Entering prodos subdir [%s]\n", files[0].Name())
return d.PRODOSGetCatalog(files[0].IndexBlock(), pattern)
}
} else {
return d.PRODOSGetCatalog(start, pattern)
}
}
func (d *DSKWrapper) PRODOSGetCatalog(startblock int, pattern string) (*VDH, []ProDOSFileDescriptor, error) {
//fmt.Printf("GetCatalogProDOS(%d, %s)\n", startblock, pattern)
var err error
var re *regexp.Regexp
var patterntmp string
if pattern != "" {
patterntmp = strings.Replace(pattern, ".", "[.]", -1)
patterntmp = strings.Replace(patterntmp, "*", ".*", -1)
patterntmp = "(?i)^" + patterntmp + "$"
re = regexp.MustCompile(patterntmp)
}
var files []ProDOSFileDescriptor
var e error
var vtoc *VDH
if d.Format.ID == DF_PRODOS_800KB {
vtoc, e = d.PRODOS800GetVDH(startblock)
} else {
vtoc, e = d.PRODOSGetVDH(startblock)
}
if e != nil {
return vtoc, files, e
}
activeentries := 0
filecount := vtoc.GetFileCount()
blockentries := 2
entriesperblock := vtoc.GetEntriesPerBlock()
refnum := startblock
var data []byte
if d.Format.ID == DF_PRODOS_800KB {
data, _ = d.PRODOS800GetBlock(refnum)
} else {
data, _ = d.PRODOSGetBlock(refnum)
}
nextblock := int(data[2]) + 256*int(data[3])
//fmt.Printf("ActiveCount = %d\n", filecount)
entrypointer := 4 + PRODOS_ENTRY_SIZE
for activeentries < filecount {
if data[entrypointer] != 0x00 {
// Valid entry
chunk := data[entrypointer : entrypointer+PRODOS_ENTRY_SIZE]
fd := ProDOSFileDescriptor{}
fd.SetData(chunk, refnum, entrypointer)
if fd.Type().Valid() {
var skipname bool = false
if re != nil {
//fmt.Printf("Checking [%s] against regex /%s/\n", fd.Name(), patterntmp)
skipname = !re.MatchString(fd.Name())
}
if fd.GetStorageType() != StorageType_Inactive && !skipname {
files = append(files, fd)
}
}
activeentries++
}
if activeentries < filecount {
if blockentries == entriesperblock {
refnum = nextblock
if d.Format.ID == DF_PRODOS_800KB {
data, err = d.PRODOS800GetBlock(refnum)
} else {
data, err = d.PRODOSGetBlock(refnum)
}
if err != nil {
break
}
nextblock = int(data[2]) + 256*int(data[3])
blockentries = 0x01
entrypointer = 0x04
} else {
entrypointer += PRODOS_ENTRY_SIZE
blockentries++
}
}
}
return vtoc, files, nil
}
func (d *DSKWrapper) PRODOSReadFileSectors(fd ProDOSFileDescriptor, maxblocks int) ([]byte, error) {
var data, index, chunk []byte
var e error
switch fd.GetStorageType() {
case StorageType_Seedling:
/* single block pointed to */
if d.Format.ID == DF_PRODOS_800KB {
data, _ = d.PRODOS800GetBlock(fd.IndexBlock())
} else {
data, _ = d.PRODOSGetBlock(fd.IndexBlock())
}
count := fd.Size()
if count > len(data) {
count = len(data)
}
return data[:count], e
case StorageType_Sapling:
if d.Format.ID == DF_PRODOS_800KB {
index, _ = d.PRODOS800GetBlock(fd.IndexBlock())
} else {
index, _ = d.PRODOSGetBlock(fd.IndexBlock())
}
data := make([]byte, 0)
bptr := 0
remaining := fd.Size() - len(data)
for len(data) < fd.Size() && bptr+256 < len(index) {
blocknum := int(index[bptr]) + 256*int(index[bptr+256])
//fmt.Printf("File block %d (%d %d)\n", blocknum, int(index[bptr]), int(index[bptr+1]))
if d.Format.ID == DF_PRODOS_800KB {
chunk, e = d.PRODOS800GetBlock(blocknum)
} else {
chunk, e = d.PRODOSGetBlock(blocknum)
}
if e != nil {
return data, e
}
count := 512
if remaining < count {
count = remaining
}
data = append(data, chunk[:count]...)
bptr += 1
remaining = fd.Size() - len(data)
}
return data, e
case StorageType_Tree:
return []byte(nil), errors.New("Unimplemented yet... soz :(")
}
return []byte(nil), nil
}
func (d *DSKWrapper) PRODOSReadFile(fd ProDOSFileDescriptor) (int, int, []byte, error) {
data, e := d.PRODOSReadFileSectors(fd, -1)
if e != nil {
return 0, 0, data, e
}
switch fd.Type() {
case FileType_PD_INT:
return fd.Size(), fd.AuxType(), IntegerDetoks(data), nil
case FileType_PD_APP:
return fd.Size(), fd.AuxType(), ApplesoftDetoks(data), nil
case FileType_PD_TXT:
return fd.Size(), fd.AuxType(), data, nil
case FileType_PD_BIN:
return fd.Size(), fd.AuxType(), data, nil
default:
return fd.Size(), fd.AuxType(), data, nil
}
}
func (d *DSKWrapper) PRODOSReadFileRaw(fd ProDOSFileDescriptor) (int, int, []byte, error) {
data, e := d.PRODOSReadFileSectors(fd, -1)
if e != nil {
return 0, 0, data, e
}
switch fd.Type() {
case FileType_PD_INT:
return fd.Size(), fd.AuxType(), data, nil
case FileType_PD_APP:
return fd.Size(), fd.AuxType(), data, nil
case FileType_PD_TXT:
return fd.Size(), fd.AuxType(), data, nil
case FileType_PD_BIN:
return fd.Size(), fd.AuxType(), data, nil
default:
return fd.Size(), fd.AuxType(), data, nil
}
}
func (d *DSKWrapper) PRODOSChecksumBlock(b int) string {
bl, _ := d.PRODOSGetBlock(b)
return Checksum(bl)
}
func (d *DSKWrapper) PRODOS800ChecksumBlock(b int) string {
bl, _ := d.PRODOS800GetBlock(b)
return Checksum(bl)
}
func (d *DSKWrapper) PRODOSGetBlockSectors(block int) (int, int, int) {
bpt := d.Format.USPT() / 2
track := block / bpt
bo := block % bpt
if d.Layout == SectorOrderProDOSLinear || len(d.Data) >= PRODOS_800KB_DISK_BYTES {
return track, bo * 2, bo*2 + 1
}
switch bo {
case 0:
return track, 0x0, 0xe
case 1:
return track, 0xd, 0xc
case 2:
return track, 0xb, 0xa
case 3:
return track, 0x9, 0x8
case 4:
return track, 0x7, 0x6
case 5:
return track, 0x5, 0x4
case 6:
return track, 0x3, 0x2
case 7:
return track, 0x1, 0xf
}
return track, 0x0, 0xe
}
func (d *DSKWrapper) PRODOS800GetBlockSectors(block int) (int, int, int) {
dblBlock := block * 2
spt := 40
track := dblBlock / spt
s1 := dblBlock % spt
s2 := (dblBlock + 1) % spt
return track, s1, s2
}
// PRODOSGetDirBlocks returns a list of blocks for the current directory level
func (dsk *DSKWrapper) PRODOSGetDirBlocks(start int) (*VDH, []int, [][]byte, error) {
blocks := make([]int, 0)
chunks := make([][]byte, 0)
vdh, err := dsk.PRODOSGetVDH(start)
if err != nil {
return vdh, blocks, chunks, err
}
// okay lets trail the directory
blocks = append(blocks, start)
data, _ := dsk.PRODOSGetBlock(start)
chunks = append(chunks, data)
nextBlock := int(data[0x02]) + 256*int(data[0x03])
for nextBlock != 0 {
blocks = append(blocks, nextBlock)
data, _ := dsk.PRODOSGetBlock(nextBlock)
chunks = append(chunks, data)
nextBlock = int(data[0x02]) + 256*int(data[0x03])
}
return vdh, blocks, chunks, nil
}
// PRODOSFindDirBlocks locates the blocks for a given directory (if it exists!)
func (dsk *DSKWrapper) PRODOSFindDirBlocks(start int, path string) (*VDH, []int, [][]byte, error) {
path = strings.Trim(path, "/")
if path == "" {
return dsk.PRODOSGetDirBlocks(start)
}
segments := strings.Split(path, "/")
target := segments[0]
segments = segments[1:]
vdh, files, err := dsk.PRODOSGetCatalog(start, "")
if err != nil {
return vdh, nil, nil, err
}
for _, f := range files {
if f.Type() != FileType_PD_Directory {
continue
}
if strings.ToLower(target) == strings.ToLower(f.NameUnadorned()) {
// matched path
newpath := strings.Join(segments, "/")
return dsk.PRODOSFindDirBlocks(f.IndexBlock(), newpath)
}
}
return vdh, nil, nil, errors.New("Path not found")
}
// PRODOSGetFirstFreeEntry for a given path, will find the first free file descriptor
// it will expand the directory if needed to create a free block
func (dsk *DSKWrapper) PRODOSGetFirstFreeEntry(path string, name string, grow bool) (*ProDOSFileDescriptor, error) {
vdh, blockList, blockData, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return nil, err
}
entries := 0
// if we are here, we found the right directory...
for idx, data := range blockData {
count := 0
if idx == 0 {
count = 1
entries = 1
}
for count < vdh.GetEntriesPerBlock() {
offset := 4 + count*PRODOS_ENTRY_SIZE
chunk := data[offset : offset+PRODOS_ENTRY_SIZE]
fd := &ProDOSFileDescriptor{}
fd.SetData(chunk, blockList[idx], offset)
fd.entryNum = entries
//Printf("--> Check entry: %s, %v, %v\n", fd.NameUnadorned(), fd.CreateTime(), fd.ModTime())
if fd.GetStorageType() != 0x00 && strings.ToLower(fd.NameUnadorned()) == strings.ToLower(name) {
return fd, nil
} else if fd.GetStorageType() == 0x00 {
//fmt.Printf("found at entry %d in block %d\n", entries, blockList[idx])
return fd, nil
}
count += 1
entries++
}
}
if !grow {
return nil, errors.New("No free slot: told not to grow directory")
}
// If we got here, we need to create a new block
freeBlocks, err := dsk.PRODOSGetFreeBlocks(1, vdh.GetTotalBlocks())
if err != nil {
return nil, errors.New("Could not extend directory")
}
data, err := dsk.PRODOSGetBlock(freeBlocks[0])
prevBlock := blockList[len(blockList)-1]
data[0x00] = byte(prevBlock & 0xff)
data[0x01] = byte(prevBlock / 0x100)
offset := 4
chunk := data[offset : offset+PRODOS_ENTRY_SIZE]
fd := &ProDOSFileDescriptor{}
fd.entryNum = entries
fd.SetData(chunk, freeBlocks[0], offset)
dsk.PRODOSMarkBlocks(freeBlocks, false)
return fd, nil
}
func (dsk *DSKWrapper) PRODOSMarkBlocks(list []int, free bool) error {
vbm, err := dsk.PRODOSGetVolumeBitmap()
if err != nil {
return err
}
for _, b := range list {
vbm.SetBlockFree(b, free)
}
//fmt.Printf("Writing Volume bitmap to block %d\n", vbm.blockid)
return dsk.PRODOSWrite(vbm.blockid, vbm.Data)
}
func (dsk *DSKWrapper) PRODOSGetFreeBlocks(count int, totalBlocks int) ([]int, error) {
vbm, err := dsk.PRODOSGetVolumeBitmap()
if err != nil {
return nil, err
}
b := 0
blocks := make([]int, 0)
for b < totalBlocks && len(blocks) < count {
if vbm.IsBlockFree(b) {
blocks = append(blocks, b)
}
b++
}
if len(blocks) == count {
return blocks, nil
}
return blocks, errors.New("Not enough blocks")
}
func (dsk *DSKWrapper) PRODOSDeleteFile(path string, name string) error {
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err != nil {
return err
}
if fd.GetStorageType() == 0x00 {
return errors.New("Not found")
}
// At this stage we have a match
access := fd.AccessMode()
if access&AccessType_Destroy == 0 {
return errors.New("Permission denied")
}
if access&AccessType_Writable == 0 {
return errors.New("Read-only file")
}
// Make sure its either a sapling or a seedling
st := fd.GetStorageType()
if st != StorageType_Sapling && st != StorageType_Seedling && st != StorageType_SubDir_File {
return errors.New("Special file deletion not implemented: yet.")
} else if st == StorageType_SubDir_File {
return dsk.PRODOSDeleteDirectory(path, name)
}
var removeBlocks []int
switch st {
case StorageType_Seedling:
removeBlocks = append(removeBlocks, fd.IndexBlock())
case StorageType_Sapling:
removeBlocks = append(removeBlocks, fd.IndexBlock())
ib, err := dsk.PRODOSGetBlock(removeBlocks[0])
if err != nil {
return err
}
maxBlocks := 1600
if len(dsk.Data) == STD_DISK_BYTES {
maxBlocks = 280
}
i := 0
b := int(ib[i]) + 256*int(ib[256+i])
for i < 256 && b != 0 && b <= maxBlocks {
removeBlocks = append(removeBlocks, b)
b = int(ib[i]) + 256*int(ib[256+i])
i++
}
}
err = dsk.PRODOSMarkBlocks(removeBlocks, true)
if err != nil {
return err
}
// // get the VDH -- we need this later
vdh, _, _, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return err
}
// now delete the fileentry
fd.SetStorageType(StorageType_Inactive)
err = fd.Publish(dsk)
if err != nil {
return err
}
// update filecount
vdh.SetFileCount(vdh.GetFileCount() - 1)
return vdh.Publish(dsk)
}
func (dsk *DSKWrapper) PRODOSWriteFile(path string, name string, kind ProDOSFileType, data []byte, auxtype int) error {
name = strings.ToUpper(name)
nst := StorageType_Seedling
blocksNeeded := len(data)/512 + 1
totalBlocks := blocksNeeded
if blocksNeeded > 1 {
nst = StorageType_Sapling
totalBlocks++ // extra block for blocklist
} else if blocksNeeded > 256 {
return errors.New("Not implemented: Tree write")
}
var origTime time.Time
var origAccess ProDOSAccessMode
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err == nil {
origTime = fd.CreateTime() // we need this later
origAccess = fd.AccessMode()
err = dsk.PRODOSDeleteFile(path, name)
if err != nil {
return err
}
} else {
fd, err = dsk.PRODOSGetFirstFreeEntry(path, name, true)
if err != nil {
return err
}
}
vdh, err := dsk.PRODOSGetVDH(2)
if err != nil {
return err
}
freeBlocks, err := dsk.PRODOSGetFreeBlocks(totalBlocks, vdh.GetTotalBlocks())
if err != nil {
return err
}
// Okay got enough blocks
switch nst {
case StorageType_Sapling:
err = dsk.PRODOSWriteSaplingBlocks(freeBlocks[0], freeBlocks[1:], data)
if err != nil {
return err
}
case StorageType_Seedling:
//fmt.Printf("Write Seedling %d bytes data to block %d\n", len(data), freeBlocks[0])
err = dsk.PRODOSWrite(freeBlocks[0], data)
if err != nil {
return err
}
}
// Get the current directories directory header
dvdh, blocks, _, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return err
}
// common details - note we preserve access mode and time when overwriting the same file
fd.SetAuxType(auxtype)
fd.SetName(name)
fd.SetType(kind)
fd.SetTotalBlocks(totalBlocks)
fd.SetIndexBlock(freeBlocks[0])
fd.SetSize(len(data))
fd.SetStorageType(nst)
if origAccess == 0x00 {
fd.SetAccessMode(AccessType_Default)
} else {
fd.SetAccessMode(origAccess)
}
if origTime.IsZero() {
fd.SetCreateTime(time.Now())
} else {
fd.SetCreateTime(origTime)
}
fd.SetModTime(time.Now())
fd.SetHeaderPointer(blocks[0])
fd.Publish(dsk)
dvdh.SetFileCount(dvdh.GetFileCount() + 1)
dvdh.Publish(dsk)
err = dsk.PRODOSMarkBlocks(freeBlocks, false)
if err != nil {
return err
}
return nil
}
func (fd *ProDOSFileDescriptor) Publish(dsk *DSKWrapper) error {
//fmt.Printf("Writing FD data back to block %d, offset %d\n", fd.blockid, fd.blockoffset)
bd, err := dsk.PRODOSGetBlock(fd.blockid)
if err != nil {
return err
}
for i, v := range fd.Data {
bd[fd.blockoffset+i] = v
}
// for i, _ := range bd {
// bd[i] = byte(0xff ^ (i % 2))
// }
//Dump(bd)
return dsk.PRODOSWrite(fd.blockid, bd)
}
func (dsk *DSKWrapper) PRODOSWrite(b int, data []byte) error {
//log.Printf("====> Request to write block %.4x", b)
for len(data) < 512 {
data = append(data, 0x00)
}
t, s1, s2 := dsk.PRODOSGetBlockSectors(b)
err := dsk.Seek(t, s1)
if err != nil {
return err
}
dsk.Write(data[:256])
err = dsk.Seek(t, s2)
if err != nil {
return err
}
dsk.Write(data[256:])
return nil
}
func (dsk *DSKWrapper) PRODOSWriteSaplingBlocks(indexBlock int, dataBlocks []int, data []byte) error {
if len(dataBlocks) > 256 || len(data) > 0x20000 {
return errors.New("Too many data blocks")
}
ib := make([]byte, 512)
for i, blocknum := range dataBlocks {
// index the block
ib[0+i] = byte(blocknum & 0xff)
ib[256+i] = byte(blocknum / 0x100)
// data offset...
ptr := 512 * i
end := ptr + 512
if end > len(data) {
end = len(data)
}
chunk := data[ptr:end]
for len(chunk) < 512 {
chunk = append(chunk, 0x00)
}
err := dsk.PRODOSWrite(blocknum, chunk)
if err != nil {
return err
}
}
return dsk.PRODOSWrite(indexBlock, ib)
}
// PRODOSCreateDirectory tries to create a subdirectory...
func (dsk *DSKWrapper) PRODOSCreateDirectory(path string, name string) error {
vdh, err := dsk.PRODOSGetVDH(2)
if err != nil {
return err
}
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err == nil {
return errors.New("Item exists")
}
fd, err = dsk.PRODOSGetFirstFreeEntry(path, name, true)
if err != nil {
return err
}
// got file descriptor
if fd.GetStorageType() != 0 {
if fd.Type() == FileType_PD_Directory {
return errors.New("Directory already exists")
}
return errors.New("Type mismatch")
}
// Get the current directories directory header
dvdh, blocks, _, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return err
}
// find a freeBlock for the directory
freeBlocks, err := dsk.PRODOSGetFreeBlocks(1, vdh.GetTotalBlocks())
if err != nil {
return err
}
// got a file descriptor
fd.SetStorageType(StorageType_SubDir_File)
fd.SetAccessMode(AccessType_Default | AccessType_Changed)
fd.SetCreateTime(time.Now())
fd.SetModTime(time.Now())
fd.SetName(name)
fd.SetType(FileType_PD_Directory)
fd.SetIndexBlock(freeBlocks[0]) // <------- block for the directory header
fd.SetTotalBlocks(1)
fd.SetSize(512)
fd.SetHeaderPointer(blocks[0])
fd.SetMinVersion(0x00)
fd.SetVersion(0x23)
err = dsk.PRODOSInitDirectoryBlock(freeBlocks[0], blocks[0], dvdh.GetEntriesPerBlock(), dvdh.GetEntryLength(), fd.entryNum, name)
if err != nil {
return err
}
err = dsk.PRODOSMarkBlocks(freeBlocks, false)
if err != nil {
return err
}
dvdh.SetFileCount(vdh.GetFileCount() + 1)
dvdh.Publish(dsk)
if err != nil {
return err
}
return fd.Publish(dsk)
}
func (dsk *DSKWrapper) PRODOSInitDirectoryBlock(targetBlock int, parentBlock int, entriesPerBlock int, entrySize int, entryNum int, name string) error {
block := make([]byte, 512)
dh := &VDH{
Data: block[4 : 4+PRODOS_ENTRY_SIZE],
blockid: targetBlock,
blockoffset: 4,
}
// Must be set (beneath Apple ProDOS)
dh.Data[0x10] = 0x75
dh.SetStorageType(StorageType_SubDir_Header)
dh.SetName(name)
dh.SetCreateTime(time.Now())
dh.SetAccess(AccessType_Default)
dh.SetEntriesPerBlock(entriesPerBlock)
dh.SetEntryLength(entrySize)
dh.SetFileCount(0)
dh.SetDirParentPointer(parentBlock)
dh.SetDirParentEntry(entryNum)
dh.SetDirParentEntryLength(entrySize)
dh.SetMinVersion(0x00)
dh.SetVersion(0x23)
return dsk.PRODOSWrite(targetBlock, block)
}
func (dsk *DSKWrapper) PRODOSDeleteDirectory(path string, name string) error {
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err != nil {
return err
}
// got file descriptor, is it empty
if fd.GetStorageType() == 0x00 {
return errors.New("Path not found")
}
if fd.Type() != FileType_PD_Directory {
return errors.New("Not a directory")
}
// Get the current directories directory header
_, files, err := dsk.PRODOSGetCatalog(fd.IndexBlock(), "*")
if err != nil {
return err
}
// Remove any files in subdirectory
for _, subfile := range files {
if subfile.GetStorageType() == StorageType_SubDir_File {
// FOLDER, RECURSE
err = dsk.PRODOSDeleteDirectory(path+"/"+name, subfile.NameUnadorned())
if err != nil {
return err
}
} else if subfile.GetStorageType() == StorageType_Tree {
// TREE FILE -- UNSUPPORTED FOR NOW
return errors.New("Tree file handling not supported currently")
} else {
err = dsk.PRODOSDeleteFile(path+"/"+name, subfile.NameUnadorned())
if err != nil {
return err
}
}
}
// Check again and make sure it is empty
_, files, err = dsk.PRODOSGetCatalog(fd.IndexBlock(), "*")
if err != nil {
return err
}
if len(files) > 0 {
return errors.New("Could not delete all subfiles")
}
// Get blocks that make up the directory
_, dirBlocks, _, err := dsk.PRODOSFindDirBlocks(2, path+"/"+name)
if err != nil {
return err
}
// Free all the things!
err = dsk.PRODOSMarkBlocks(dirBlocks, true)
if err != nil {
return err
}
// free file entry
fd.SetStorageType(StorageType_Inactive)
err = fd.Publish(dsk)
if err != nil {
return err
}
// reduce count by 1 at top level
tvdh, _, _, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return err
}
tvdh.SetFileCount(tvdh.GetFileCount() - 1)
return tvdh.Publish(dsk)
}
func (dsk *DSKWrapper) PRODOSSetLocked(path, name string, lock bool) error {
// We cheat here a bit and use the get first free entry call with
// autogrow turned off.
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err != nil {
return err
}
fd.SetLocked(lock)
return fd.Publish(dsk)
}
// PRODOSGetNamedEntry for a given path, will find the file descriptor with name
func (dsk *DSKWrapper) PRODOSGetNamedEntry(path string, name string) (*ProDOSFileDescriptor, error) {
//fmt.Printf(">>> Path = %s\n", path)
vdh, blockList, blockData, err := dsk.PRODOSFindDirBlocks(2, path)
if err != nil {
return nil, err
}
entries := 0
// if we are here, we found the right directory...
for idx, data := range blockData {
count := 0
if idx == 0 {
count = 1
entries = 1
}
for count < vdh.GetEntriesPerBlock() {
offset := 4 + count*PRODOS_ENTRY_SIZE
chunk := data[offset : offset+PRODOS_ENTRY_SIZE]
fd := &ProDOSFileDescriptor{}
fd.SetData(chunk, blockList[idx], offset)
fd.entryNum = entries
//fmt.Printf(">>> Comparing %s to %s\n", strings.ToLower(fd.NameUnadorned()), strings.ToLower(name))
if fd.GetStorageType() != 0x00 && strings.ToLower(fd.NameUnadorned()) == strings.ToLower(name) {
return fd, nil
}
count += 1
entries++
}
}
return nil, errors.New("Not found")
}
func (dsk *DSKWrapper) PRODOSRenameFile(path, name, newname string) error {
fd, err := dsk.PRODOSGetNamedEntry(path, name)
if err != nil {
return err
}
_, err = dsk.PRODOSGetNamedEntry(path, newname)
if err == nil {
return errors.New("New name already exists")
}
// can rename here
fd.SetName(newname)
return fd.Publish(dsk)
}
Reference in New Issue View Git Blame Copy Permalink