SquashFS does not set the right filesize for directory inode

[Xynnn007]

Due to SquashFS Spec https://dr-emann.github.io/squashfs/squashfs.html#_directory_inodes Section 5.2, the Directory Inode should have its file size 3 bytes larger than the real listing.

SquashFS implementation does not follow this well. Some bugs would come when using go-diskfs to generate a squashfs image with a file in it, but reading it using a different tool rather than go-diskfs like backhand in Rust.

Let me put an example for this then.

[Xynnn007]

Use the go file to create squashfs image

package main

import (
	"errors"
	"fmt"
	"os"

	"github.com/diskfs/go-diskfs"
	"github.com/diskfs/go-diskfs/disk"
	"github.com/diskfs/go-diskfs/filesystem"
	"github.com/diskfs/go-diskfs/filesystem/squashfs"
)

func main() {
	CreateFilesystem := func(d *disk.Disk, spec disk.FilesystemSpec) (filesystem.FileSystem, error) {
		// find out where the partition starts and ends, or if it is the entire disk
		var (
			size, start int64
		)

		switch {
		case spec.Partition == 0:
			size = d.Size
			start = 0
		case d.Table == nil:
			return nil, fmt.Errorf("cannot create filesystem on a partition without a partition table")
		default:
			partitions := d.Table.GetPartitions()
			// API indexes from 1, but slice from 0
			part := spec.Partition - 1
			if spec.Partition > len(partitions) {
				return nil, fmt.Errorf("cannot create filesystem on partition %d greater than maximum partition %d", spec.Partition, len(partitions))
			}
			size = partitions[part].GetSize()
			start = partitions[part].GetStart()
		}

		switch spec.FSType {
		case filesystem.TypeSquashfs:
			return squashfs.Create(d.Backend, size, start, d.LogicalBlocksize)
		default:
			return nil, errors.New("unknown filesystem type requested")
		}
	}

	// Create squashfs image file
	var diskSize int64 = 10 * 1024 * 1024 // 10 MB
	initdataImagePath := "/tmp/data.img"
	mydisk, err := diskfs.Create(initdataImagePath, diskSize, 131072)
	if err != nil {
		panic(err)
	}

	fspec := disk.FilesystemSpec{Partition: 0, FSType: filesystem.TypeSquashfs, VolumeLabel: "label"}
	fs, err := CreateFilesystem(mydisk, fspec)
	if err != nil {
		panic(err)
	}

	err = fs.Mkdir("/")
	if err != nil {
		panic(err)
	}
	err = fs.Mkdir("/123")
	if err != nil {
		panic(err)
	}

	err = fs.Mkdir("/foo")
	if err != nil {
		panic(err)
	}

	err = fs.Mkdir("/")
	if err != nil {
		panic(err)
	}

	rw, err := fs.OpenFile("example.txt", os.O_CREATE|os.O_RDWR)
	if err != nil {
		panic(err)
	}

	_, err = rw.Write([]byte("Hello, SquashFS!"))
	if err != nil {
		panic(err)
	}

	sqs, ok := fs.(*squashfs.FileSystem)
	if !ok {
		panic("not a squashfs filesystem")
	}
	err = sqs.Finalize(squashfs.FinalizeOptions{})
	if err != nil {
		panic(err)
	}
}

Using the following rust program to read

src/main.rs

use std::io::BufReader;

use backhand::FilesystemReader;

fn main() {
    let initdata_devfile = std::fs::File::open("/tmp/data.img").unwrap();
    let buf_reader = BufReader::new(initdata_devfile);
    let read_filesystem = FilesystemReader::from_reader(buf_reader).unwrap();
    for node in read_filesystem.files() {
        println!("path: {:?}", node.fullpath.as_path());
    }
}

Cargo.toml

[package]
name = "test-squashfs"
version = "0.1.0"
edition = "2021"

[dependencies]
backhand = "0.20.0"

The terminal will only say

path: /

[deitch]

Ah, and it would not be a problem reading, because there it just takes the data as it finds it. Rather nice catch.