mirror of https://github.com/zellyn/diskii.git
Working on dos 3.3 data structures
This commit is contained in:
Zellyn Hunter
parent
81fca862de
commit
9ac6ab5962
|
|
@ -0,0 +1,228 @@
|
|||
// Copyright © 2016 Zellyn Hunter <zellyn@gmail.com>
|
||||
|
||||
// Package dos33 contains routines for working with the on-disk structures of DOS 3.3.
|
||||
package dos33
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
type FreeSectorMap [4]byte // Bit map of free sectors in a track
|
||||
|
||||
// VTOC is the struct used to hold the DOS 3.3 VTOC structure.
|
||||
// See page 4-2 of Beneath Apple DOS.
|
||||
type VTOC struct {
|
||||
Unused1 byte // Not used
|
||||
CatalogTrack byte // Track number of first catalog sector
|
||||
CatalogSector byte // Sector number of first catalog sector
|
||||
DOSRelease byte // Release number of DOS used to INIT this diskette
|
||||
Unused2 [2]byte // Not used
|
||||
Volume byte // Diskette volume number (1-254)
|
||||
Unused3 [32]byte // Not used
|
||||
// Maximum number of track/secotr pairs which will fit in one file
|
||||
// track/sector list sector (122 for 256 byte sectors)
|
||||
TrackSectorListMaxSize byte
|
||||
Unused4 [8]byte // Not used
|
||||
LastTrack byte // Last track where sectors were allocated
|
||||
TrackDirection int8 // Direction of track allocation (+1 or -1)
|
||||
Unused5 [2]byte
|
||||
NumTracks byte // Number of tracks per diskette (normally 35)
|
||||
NumSectors byte // Number of sectors per track (13 or 16)
|
||||
BytesPerSector uint16 // Number of bytes per sector (LO/HI format)
|
||||
FreeSectors [50]FreeSectorMap
|
||||
}
|
||||
|
||||
// MarshalBinary marshals the VTOC sector to bytes. Error is always nil.
|
||||
func (v VTOC) MarshalBinary() (data []byte, err error) {
|
||||
buf := make([]byte, 256)
|
||||
buf[0x00] = v.Unused1
|
||||
buf[0x01] = v.CatalogTrack
|
||||
buf[0x02] = v.CatalogSector
|
||||
buf[0x03] = v.DOSRelease
|
||||
copyBytes(buf[0x04:0x06], v.Unused2[:])
|
||||
buf[0x06] = v.Volume
|
||||
copyBytes(buf[0x07:0x27], v.Unused3[:])
|
||||
buf[0x27] = v.TrackSectorListMaxSize
|
||||
copyBytes(buf[0x28:0x30], v.Unused4[:])
|
||||
buf[0x30] = v.LastTrack
|
||||
buf[0x31] = byte(v.TrackDirection)
|
||||
copyBytes(buf[0x32:0x34], v.Unused5[:])
|
||||
buf[0x34] = v.NumTracks
|
||||
buf[0x35] = v.NumSectors
|
||||
binary.LittleEndian.PutUint16(buf[0x36:0x38], v.BytesPerSector)
|
||||
for i, m := range v.FreeSectors {
|
||||
copyBytes(buf[0x38+4*i:0x38+4*i+4], m[:])
|
||||
}
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
// copyBytes is just like the builtin copy, but just for byte slices,
|
||||
// and it checks that dst and src have the same length.
|
||||
func copyBytes(dst, src []byte) int {
|
||||
if len(dst) != len(src) {
|
||||
panic(fmt.Sprintf("copyBytes called with differing lengths %d and %d", len(dst), len(src)))
|
||||
}
|
||||
return copy(dst, src)
|
||||
}
|
||||
|
||||
// UnmarshalBinary unmarshals the VTOC sector from bytes. Input is
|
||||
// expected to be exactly 256 bytes.
|
||||
func (v *VTOC) UnmarshalBinary(data []byte) error {
|
||||
if len(data) != 256 {
|
||||
return fmt.Errorf("VTOC.UnmarshalBinary expects exactly 256 bytes; got %d", len(data))
|
||||
}
|
||||
|
||||
v.Unused1 = data[0x00]
|
||||
v.CatalogTrack = data[0x01]
|
||||
v.CatalogSector = data[0x02]
|
||||
v.DOSRelease = data[0x03]
|
||||
copyBytes(v.Unused2[:], data[0x04:0x06])
|
||||
v.Volume = data[0x06]
|
||||
copyBytes(v.Unused3[:], data[0x07:0x27])
|
||||
v.TrackSectorListMaxSize = data[0x27]
|
||||
copyBytes(v.Unused4[:], data[0x28:0x30])
|
||||
v.LastTrack = data[0x30]
|
||||
v.TrackDirection = int8(data[0x31])
|
||||
copyBytes(v.Unused5[:], data[0x32:0x34])
|
||||
v.NumTracks = data[0x34]
|
||||
v.NumSectors = data[0x35]
|
||||
v.BytesPerSector = binary.LittleEndian.Uint16(data[0x36:0x38])
|
||||
for i := range v.FreeSectors {
|
||||
copyBytes(v.FreeSectors[i][:], data[0x38+4*i:0x38+4*i+4])
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func DefaultVTOC() VTOC {
|
||||
v := VTOC{
|
||||
CatalogTrack: 0x11,
|
||||
CatalogSector: 0x0f,
|
||||
DOSRelease: 0x03,
|
||||
Volume: 0x01,
|
||||
TrackSectorListMaxSize: 122,
|
||||
LastTrack: 0x00, // TODO(zellyn): what should this be?
|
||||
TrackDirection: 1,
|
||||
NumTracks: 0x23,
|
||||
NumSectors: 0x10,
|
||||
BytesPerSector: 0x100,
|
||||
}
|
||||
for i := range v.FreeSectors {
|
||||
v.FreeSectors[i] = FreeSectorMap{}
|
||||
if i < 35 {
|
||||
v.FreeSectors[i] = FreeSectorMap([4]byte{0xff, 0xff, 0x00, 0x00})
|
||||
}
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// CatalogSector is the struct used to hold the DOS 3.3 Catalog
|
||||
// sector.
|
||||
type CatalogSector struct {
|
||||
Unused1 byte // Not used
|
||||
NextTrack byte // Track number of next catalog sector (usually 11 hex)
|
||||
NextSector byte // Sector number of next catalog sector
|
||||
Unused2 [8]byte // Not used
|
||||
FileDescs [7]FileDesc // File descriptive entries
|
||||
}
|
||||
|
||||
// MarshalBinary marshals the CatalogSector to bytes. Error is always nil.
|
||||
func (cs CatalogSector) MarshalBinary() (data []byte, err error) {
|
||||
buf := make([]byte, 256)
|
||||
buf[0x00] = cs.Unused1
|
||||
buf[0x01] = cs.NextTrack
|
||||
buf[0x02] = cs.NextSector
|
||||
copyBytes(buf[0x03:0x0b], cs.Unused2[:])
|
||||
for i, fd := range cs.FileDescs {
|
||||
fdBytes, _ := fd.MarshalBinary()
|
||||
copyBytes(buf[0x0b+35*i:0x0b+35*(i+1)], fdBytes)
|
||||
}
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
// UnmarshalBinary unmarshals the CatalogSector from bytes. Input is
|
||||
// expected to be exactly 256 bytes.
|
||||
func (cs *CatalogSector) UnmarshalBinary(data []byte) error {
|
||||
if len(data) != 256 {
|
||||
return fmt.Errorf("CatalogSector.UnmarshalBinary expects exactly 256 bytes; got %d", len(data))
|
||||
}
|
||||
|
||||
cs.Unused1 = data[0x00]
|
||||
cs.NextTrack = data[0x01]
|
||||
cs.NextSector = data[0x02]
|
||||
copyBytes(cs.Unused2[:], data[0x03:0x0b])
|
||||
|
||||
for i := range cs.FileDescs {
|
||||
if err := cs.FileDescs[i].UnmarshalBinary(data[0x0b+35*i : 0x0b+35*(i+1)]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type Filetype byte
|
||||
|
||||
const (
|
||||
// Hex 80+file type - file is locked
|
||||
// Hex 00+file type - file is not locked
|
||||
FiletypeLocked Filetype = 0x80
|
||||
|
||||
FileTypeText Filetype = 0x00 // Text file
|
||||
FileTypeInteger Filetype = 0x01 // INTEGER BASIC file
|
||||
FileTypeApplesoft Filetype = 0x02 // APPLESOFT BASIC file
|
||||
FileTypeBinary Filetype = 0x04 // BINARY file
|
||||
FileTypeS Filetype = 0x08 // S type file
|
||||
FileTypeRelocatable Filetype = 0x10 // RELOCATABLE object module file
|
||||
FileTypeA Filetype = 0x20 // A type file
|
||||
FileTypeB Filetype = 0x40 // B type file
|
||||
)
|
||||
|
||||
// FileDesc is the struct used to represent the DOS 3.3 File
|
||||
// Descriptive entry.
|
||||
type FileDesc struct {
|
||||
// Track of first track/sector list sector. If this is a deleted
|
||||
// file, this byte contains a hex FF and the original track number
|
||||
// is copied to the last byte of the file name field (BYTE 20). If
|
||||
// this byte contains a hex 00, the entry is assumed to never have
|
||||
// been used and is available for use. (This means track 0 can never
|
||||
// be used for data even if the DOS image is "wiped" from the
|
||||
// diskette.)
|
||||
TrackSectorListTrack byte
|
||||
TrackSectorListSector byte // Sector of first track/sector list sector
|
||||
Filetype Filetype // File type and flags
|
||||
Filename [30]byte // File name (30 characters) Length of file in
|
||||
// sectors (LO/HI format). The CATALOG command will only format the
|
||||
// LO byte of this length giving 1-255 but a full 65,535 may be
|
||||
// stored here.
|
||||
SectorCount uint16
|
||||
}
|
||||
|
||||
// MarshalBinary marshals the FileDesc to bytes. Error is always nil.
|
||||
func (fd FileDesc) MarshalBinary() (data []byte, err error) {
|
||||
buf := make([]byte, 35)
|
||||
buf[0x00] = fd.TrackSectorListTrack
|
||||
buf[0x01] = fd.TrackSectorListSector
|
||||
buf[0x02] = byte(fd.Filetype)
|
||||
copyBytes(buf[0x03:0x21], fd.Filename[:])
|
||||
binary.LittleEndian.PutUint16(buf[0x21:0x23], fd.SectorCount)
|
||||
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
// UnmarshalBinary unmarshals the FileDesc from bytes. Input is
|
||||
// expected to be exactly 35 bytes.
|
||||
func (fd *FileDesc) UnmarshalBinary(data []byte) error {
|
||||
if len(data) != 35 {
|
||||
return fmt.Errorf("FileDesc.UnmarshalBinary expects exactly 35 bytes; got %d", len(data))
|
||||
}
|
||||
|
||||
fd.TrackSectorListTrack = data[0x00]
|
||||
fd.TrackSectorListSector = data[0x01]
|
||||
fd.Filetype = Filetype(data[0x02])
|
||||
copyBytes(data[0x03:0x21], fd.Filename[:])
|
||||
fd.SectorCount = binary.LittleEndian.Uint16(data[0x21:0x23])
|
||||
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
package dos33
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestVTOCMarshalRoundtrip checks a simple roundtrip of VTOC data.
|
||||
func TestVTOCMarshalRoundtrip(t *testing.T) {
|
||||
buf := make([]byte, 256)
|
||||
rand.Read(buf)
|
||||
vtoc1 := &VTOC{}
|
||||
if err := vtoc1.UnmarshalBinary(buf); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buf2, _ := vtoc1.MarshalBinary()
|
||||
if !reflect.DeepEqual(buf, buf2) {
|
||||
t.Errorf("Buffers differ: %v != %v", buf, buf2)
|
||||
}
|
||||
vtoc2 := &VTOC{}
|
||||
if err := vtoc2.UnmarshalBinary(buf2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if *vtoc1 != *vtoc2 {
|
||||
t.Errorf("Structs differ: %v != %v", vtoc1, vtoc2)
|
||||
}
|
||||
}
|
||||
|
||||
// TestCatalogSectorMarshalRoundtrip checks a simple roundtrip of CatalogSector data.
|
||||
func TestCatalogSectorMarshalRoundtrip(t *testing.T) {
|
||||
buf := make([]byte, 256)
|
||||
rand.Read(buf)
|
||||
cs1 := &CatalogSector{}
|
||||
if err := cs1.UnmarshalBinary(buf); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
buf2, _ := cs1.MarshalBinary()
|
||||
if !reflect.DeepEqual(buf, buf2) {
|
||||
t.Errorf("Buffers differ: %v != %v", buf, buf2)
|
||||
}
|
||||
cs2 := &CatalogSector{}
|
||||
if err := cs2.UnmarshalBinary(buf2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if *cs1 != *cs2 {
|
||||
t.Errorf("Structs differ: %v != %v", cs1, cs2)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue