Merge pull request #3 from oceanplexian/feat/joliet-support

Add Joliet supplementary volume descriptor support

Author: davidnewhall

fixtures/test_joliet.iso

@@ -1,11 +1,13 @@
 package iso9660
 
 import (
+	"encoding/binary"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 	"time"
+	"unicode/utf16"
 )
 
 // Image is a wrapper around an image file that allows reading its ISO9660 data
@@ -51,9 +53,18 @@ func (i *Image) readVolumes() error {
 	return nil
 }
 
-// RootDir returns the File structure corresponding to the root directory
-// of the first primary volume
+// RootDir returns the File structure corresponding to the root directory.
+// It prefers a Joliet supplementary volume descriptor (which provides full
+// Unicode filenames) over the primary volume descriptor.
 func (i *Image) RootDir() (*File, error) {
+	// Check for Joliet supplementary VD first.
+	for _, vd := range i.volumeDescriptors {
+		if vd.isJoliet() {
+			return &File{de: vd.Primary.RootDirectoryEntry, ra: i.ra, children: nil, isRootDir: true, joliet: true}, nil
+		}
+	}
+
+	// Fall back to primary VD.
 	for _, vd := range i.volumeDescriptors {
 		if vd.Type() == volumeTypePrimary {
 			return &File{de: vd.Primary.RootDirectoryEntry, ra: i.ra, children: nil, isRootDir: true}, nil
@@ -85,6 +96,7 @@ type File struct {
 	children  []*File
 	isRootDir bool
 	susp      *SUSPMetadata
+	joliet    bool
 	// extents holds all extents for multi-extent files (ECMA-119 9.1.6).
 	// For single-extent files this is nil and de.ExtentLocation/ExtentLength are used directly.
 	extents []extent
@@ -141,6 +153,15 @@ func (f *File) Name() string {
 		}
 	}
 
+	// Joliet names are already decoded to UTF-8; just strip any trailing ";1".
+	if f.joliet {
+		name := f.de.Identifier
+		if idx := strings.LastIndex(name, ";"); idx >= 0 {
+			name = name[:idx]
+		}
+		return name
+	}
+
 	if f.IsDir() {
 		return f.de.Identifier
 	}
@@ -224,6 +245,11 @@ func (f *File) GetAllChildren() ([]*File, error) {
 				return nil, err
 			}
 
+			// Decode Joliet UTF-16BE identifiers to UTF-8.
+			if f.joliet && len(newDE.Identifier) > 1 {
+				newDE.Identifier = decodeJolietIdentifier([]byte(newDE.Identifier))
+			}
+
 			// Is this a root directory '.' record?
 			if f.isRootDir && newDE.Identifier == string([]byte{0}) {
 				newDE.SystemUseEntries, _ = splitSystemUseEntries(newDE.SystemUse, f.ra)
@@ -273,6 +299,7 @@ func (f *File) GetAllChildren() ([]*File, error) {
 				de:       newDE,
 				children: nil,
 				susp:     f.susp.Clone(),
+				joliet:   f.joliet,
 			}
 
 			// If we accumulated multi-extent records, finalize them now.
@@ -350,3 +377,17 @@ func (f *File) Reader() io.Reader {
 	baseOffset := int64(f.de.ExtentLocation) * int64(sectorSize)
 	return io.NewSectionReader(f.ra, baseOffset, int64(f.de.ExtentLength))
 }
+
+// decodeJolietIdentifier decodes a UTF-16BE encoded Joliet identifier to UTF-8.
+func decodeJolietIdentifier(raw []byte) string {
+	if len(raw)%2 != 0 {
+		return string(raw)
+	}
+
+	u16 := make([]uint16, len(raw)/2)
+	for i := range u16 {
+		u16[i] = binary.BigEndian.Uint16(raw[2*i : 2*i+2])
+	}
+
+	return string(utf16.Decode(u16))
+}

image_reader.go

@@ -120,6 +120,64 @@ func TestImage(t *testing.T) {
 	assert.Error(t, os.ErrNotExist, err)
 }
 
+func TestImageReaderJoliet(t *testing.T) {
+	f, err := os.Open("fixtures/test_joliet.iso")
+	assert.NoError(t, err)
+	defer f.Close() // nolint: errcheck
+
+	image, err := OpenImage(f)
+	assert.NoError(t, err)
+
+	// Should have primary + supplementary (Joliet) + terminator VDs
+	hasJoliet := false
+	for _, vd := range image.volumeDescriptors {
+		if vd.isJoliet() {
+			hasJoliet = true
+			break
+		}
+	}
+	assert.True(t, hasJoliet, "expected Joliet supplementary VD")
+
+	// RootDir should prefer Joliet
+	rootDir, err := image.RootDir()
+	assert.NoError(t, err)
+	assert.True(t, rootDir.IsDir())
+	assert.True(t, rootDir.joliet, "root should be from Joliet VD")
+
+	children, err := rootDir.GetChildren()
+	assert.NoError(t, err)
+
+	// Collect child names
+	names := make([]string, len(children))
+	for i, c := range children {
+		names[i] = c.Name()
+	}
+
+	// Should have full Joliet names, not 8.3 truncated
+	assert.Contains(t, names, "Long Filename With Spaces.txt")
+	assert.Contains(t, names, "short.txt")
+	assert.Contains(t, names, "subdir")
+
+	// Verify subdirectory traversal works with Joliet
+	for _, child := range children {
+		if child.Name() == "subdir" {
+			assert.True(t, child.IsDir())
+			assert.True(t, child.joliet, "child dir should inherit joliet flag")
+
+			subChildren, err := child.GetChildren()
+			assert.NoError(t, err)
+			assert.Len(t, subChildren, 1)
+			assert.Equal(t, "Another Long Name.dat", subChildren[0].Name())
+			assert.True(t, subChildren[0].joliet)
+
+			// Verify file content is readable
+			data, err := io.ReadAll(subChildren[0].Reader())
+			assert.NoError(t, err)
+			assert.Equal(t, "Nested file\n", string(data))
+		}
+	}
+}
+
 func TestImageReaderSUSP(t *testing.T) {
 	f, err := os.Open("fixtures/test_rockridge.iso")
 	assert.NoError(t, err)

image_reader_test.go

@@ -387,9 +387,10 @@ func (bvd *BootVolumeDescriptorBody) UnmarshalBinary(data []byte) error {
 }
 
 type volumeDescriptor struct {
-	Header  volumeDescriptorHeader
-	Boot    *BootVolumeDescriptorBody
-	Primary *PrimaryVolumeDescriptorBody
+	Header           volumeDescriptorHeader
+	Boot             *BootVolumeDescriptorBody
+	Primary          *PrimaryVolumeDescriptorBody
+	EscapeSequences  []byte
 }
 
 var _ encoding.BinaryUnmarshaler = &volumeDescriptor{}
@@ -399,6 +400,17 @@ func (vd volumeDescriptor) Type() byte {
 	return vd.Header.Type
 }
 
+// isJoliet returns true if this is a Joliet supplementary volume descriptor.
+// Joliet is identified by escape sequences %/@, %/C, or %/E in bytes 88-120.
+func (vd volumeDescriptor) isJoliet() bool {
+	if vd.Header.Type != volumeTypeSupplementary || len(vd.EscapeSequences) == 0 {
+		return false
+	}
+
+	seq := string(vd.EscapeSequences)
+	return strings.Contains(seq, "%/@") || strings.Contains(seq, "%/C") || strings.Contains(seq, "%/E")
+}
+
 // UnmarshalBinary decodes a volumeDescriptor from binary form
 func (vd *volumeDescriptor) UnmarshalBinary(data []byte) error {
 	if uint32(len(data)) < sectorSize {
@@ -426,6 +438,10 @@ func (vd *volumeDescriptor) UnmarshalBinary(data []byte) error {
 		return errors.New("partition volumes are not yet supported")
 	case volumeTypePrimary, volumeTypeSupplementary:
 		vd.Primary = &PrimaryVolumeDescriptorBody{}
+		if vd.Header.Type == volumeTypeSupplementary {
+			vd.EscapeSequences = make([]byte, 32)
+			copy(vd.EscapeSequences, data[88:120])
+		}
 		return vd.Primary.UnmarshalBinary(data)
 	case volumeTypeTerminator:
 		return nil