A go library for reading and creating ISO9660 images

Use unsigned integers for the ExtentLength field of directory entries.

I have a ISO file with a very large file in it (2.8GB), I had trouble reading that file with other tools so it could be that the ISO itself is not confromant or that other tools have this same bug. The ECMA standard is not clear on the signedness of the size field IMO. However I do not see the value of signed numbers for file length.

I found that this project already supports Go modules. But sadly, the tags doesn't follow Semantic Versioning, which means that all tags of this project will be ignored by Go modules and replaced by pseudo-versions, go get acts weirdly when tags are not in that form. It would be great to have the tagged release be named in the format vX.X.X format so that go mod can read it.

$go get github.com/kdomanski/[email protected]
go get github.com/kdomanski/[email protected]: no matching versions for query "v0.2"
$go get github.com/kdomanski/iso9660
go: downloading github.com/kdomanski/iso9660 v0.0.0-20200713230927-fa56c38dc741
go: github.com/kdomanski/iso9660 upgrade => v0.0.0-20200713230927-fa56c38dc741

Else the mod file shows something like github.com/kdomanski/iso9660 v0.0.0-20200713230927-fa56c38dc741 which is not very readable and difficult to upgrade. It’s hard to verify which version is in use. This is not conducive to version control.

So, I propose this project to follow Semantic Versioning in future versions. For example, v1.0.1, v2.0.0, v3.1.0-alpha, v3.1.0-beta.2etc, so that other project can use tag in go.mod.

Hi kdomanski,

thanks for writing this useful library. I tried to use it in combination with cloud-init, but there files are named user-data, and meta-data. '-' is not in the valid set for dCharacters, which is perfectly fine, because it simply is not a valid char according to the iso9660 spec. On the other hand it is also known that many platforms are pretty relaxed when it comes to actual implementations. Adding '-' to the dCharacters worked fine on Linux.

Would you accept a patch that adds a SetdCharacters() to ImageWriter?

I am trying to add multiple files in the sourceFolders by using the walk function for each folder. However, it only adds one single file for some reason.

package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"

	"github.com/kdomanski/iso9660"
)

func main() {
	writer, err := iso9660.NewWriter()
	if err != nil {
		log.Fatalf("failed to create writer: %s", err)
	}
	defer writer.Cleanup()

	isoFile, err := os.OpenFile("C:/output.iso", os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
	if err != nil {
		log.Fatalf("failed to create file: %s", err)
	}
	defer isoFile.Close()

	sourcePath := "F:\\"

	folders := []string{"F:\\test1", "F:\\test2"}

	for _, folderName := range folders {
		folderPath := strings.Join([]string{sourcePath, folderName}, "/")

		walk_err := filepath.Walk(folderPath, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				log.Fatalf("walk: %s", err)
				return err
			}
			if info.IsDir() {
				return nil
			}
			outputPath := strings.TrimPrefix(path, sourcePath) // remove the source drive name
			fmt.Printf("Adding file: %s\n", outputPath)

			fileToAdd, err := os.Open(path)
			if err != nil {
				log.Fatalf("failed to open file: %s", err)
			}
			defer fileToAdd.Close()

			err = writer.AddFile(fileToAdd, outputPath)
			if err != nil {
				log.Fatalf("failed to add file: %s", err)
			}
			return nil
		})
		if walk_err != nil {
			log.Fatalf("%s", walk_err)
		}
	}

	err = writer.WriteTo(isoFile, "Test")
	if err != nil {
		log.Fatalf("failed to write ISO image: %s", err)
	}
}

AddLocalFile is for adding existing files in the filesystem to an ISO. It first tries to hardlink the file to the staging area which can provide speed-up. If hardlinking is not possible, it opens the specified file and calls AddFile().

Even if hardlinking is never possible, it saves a few lines of codes in many places because you don't need to handle the opening/closing of files yourself.

https://github.com/kdomanski/iso9660/blob/880de9cb649c5731170a2f808b11ef1392954864/image_reader.go#L104

runtime error: index out of range [1] with length 1

maybe

	if len(splitFileIdentifier) == 0 {
		return splitFileIdentifier[0]
	}

Before:

$ go run readme.go
2019/12/07 16:56:52 failed to write ISO image: write myFile.txt: bad file descriptor
exit status 1

After:

$ go run readme.go
$ ls -al output.iso
-rw-r--r--@ 1 oozie  staff  0 Dec  7 16:56 output.iso

package main

import (
    "log"
    "os"

	"github.com/kdomanski/iso9660"
)

func main() {
	writer, err := iso9660.NewWriter()
	if err != nil {
	  log.Fatalf("failed to create writer: %s", err)
	}
	defer writer.Cleanup()

	f, err := os.Open("myFile.txt")
	if err != nil {
	  log.Fatalf("failed to open file: %s", err)
	}
	defer f.Close()
  
	err = writer.AddFile(f, "MYFILE.TXT") // work
	if err != nil {
	  log.Fatalf("failed to add file: %s", err)
	}

	err = writer.AddFile(f, "random_folder_name/MYFILE.TXT") // doesn't work
	if err != nil {
	  log.Fatalf("failed to add file: %s", err)
	}
  
	err = writer.AddLocalDirectory("fixtures/test.iso_source", "fixtures/test.iso_source") // doesn't work
	if err != nil {
	  log.Fatalf("failed to add file: %s", err)
	}

	outputFile, err := os.OpenFile("output.iso", os.O_WRONLY | os.O_TRUNC | os.O_CREATE, 0644)
	if err != nil {
	  log.Fatalf("failed to create file: %s", err)
	}
  
	err = writer.WriteTo(outputFile, "testvol")
	if err != nil {
	  log.Fatalf("failed to write ISO image: %s", err)
	}
  
	err = outputFile.Close()
	if err != nil {
	  log.Fatalf("failed to close output file: %s", err)
	}
}

As anyone has been able to create a folder within the .iso file, mount the .iso, and access that folder using Windows?

Currently, the package creates a temporary folder and copies the files into it to create the image. This can be avoided by using an in-memory creation.

This doesn't seem possible given https://github.com/kdomanski/iso9660/blob/880de9cb649c5731170a2f808b11ef1392954864/image_writer.go#L520-L524

I might be missing something though ... If not, is this something you would consider as an enhancement?

Good day Hope you are doing well.

For now: Joliet and Rock Ridge extensions are not supported. Do you plan to write additional methods for supporting them?

I would love to see El Torito being supported. El Torito images are valid ISO9660 images with the addition of being able to be written to USB drives (dd) for example.

links:

https://wiki.osdev.org/El-Torito

https://en.wikipedia.org/wiki/El_Torito_(CD-ROM_standard)

https://github.com/diskfs/go-diskfs/blob/1f72a0e0bb68b80c9659e81940962171e9dc9aed/filesystem/iso9660/eltorito.go

Thanks for creating this library!