Ba̪fB.!V<2Ff
%:꼤o8.qިUgEX OI? (6*HEc-ΤTOi~tN3BMVy&~l'?zt& O˒A⾧i6sb N{t 0kS[dbwBbYDy~ugVq Iv Ap"
x>}75݄Q$o}# Me /^>{ f; J6T*T]5}h2YV 5 ` Mb-#ҁA _Dơ5 zTwݰM>N<:s"?x H. P({⁝~J8ޠfqx{@8w7 #nM7h.
V:REd_@eD?lqEN08D?x#ż s-H9IJ XcInAl?/fŖΐR:|MYOTldcҊVOJ
!Жb䋁7xk
, }_r$IjZߔ MY(
\X$hruۗShSB30e
Go9OO cp j¬'-.? ÍRS5Q9o+T.Hև
#dgi∪% .龋u?z Sq
%bz٬5m/rWM d|"ݘ *XDe h*3))bP(P7'+m.UibK'o1^qJ = o[o~4^s.C&l ;%
%Px;V,k[@lSUf{.Mݕ@ehؗGoKM ^pVaQfY+ᐁ!(v_>c'zg[F %mpotv TX !&S+Mٍ2dM府*BJ
gTii ~rBZ:Փ.9/cW *L|#hME"Pnf uTf K2kRF5܃V)]wa70_=W}]/ 6az
4s.ο+.Z B}3IڎUO] Tfr(:fU g';XN{/o
`vC؋+1ze%jxކxcfy YȤd)횭~;
36}% VN6\O/o.k@^Z)~d?j7)x4FMiۻ=ҳH^aK.ޖ)J1=|CA;ID4W7bf>n
Yh"rk{{ܠO;
]yeI#kxqoZ$He&7:yۉ -Vؑ0ު'yt: uVq| qO*OkkyeYkD zm~Nm< Bq58˳<ft e)o-ʗ$G3l'!Q]'/ dIxim~/*WE* ]abyqئq(R\0WGK띀MdY |زo,}x\꛳P3HWNz[1&ݢZ%6؈Z&o̘ h7^ ĜZ=f"Oԓ"լF@uXF FA\[:\V#o.iO<ÇZ_} " )z5L`KZ5Ïf φsvC}%-.omxobڶ l yE^-hMi/
K/-ou'>:,2b楴g`W]c~7$>KbN|,+Фu.EFI` will boot)
* `ext4` filesystem
* `Joliet` extensions to `iso9660`
* `Rock Ridge` sparse file support - supports the flag, but not yet reading or writing
* `squashfs` sparse file support - currently treats sparse files as regular files
* `qcow` disk format
07070100000303000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000003C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/disk 07070100000304000081A4000000000000000000000001645E367C00002048000000000000000000000000000000000000004400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/disk/disk.go // Package disk provides utilities for working directly with a disk
//
// Most of the provided functions are intelligent wrappers around implementations of
// github.com/diskfs/go-diskfs/partition and github.com/diskfs/go-diskfs/filesystem
package disk
import (
"errors"
"fmt"
"io"
"os"
log "github.com/sirupsen/logrus"
"github.com/diskfs/go-diskfs/filesystem"
"github.com/diskfs/go-diskfs/filesystem/fat32"
"github.com/diskfs/go-diskfs/filesystem/iso9660"
"github.com/diskfs/go-diskfs/filesystem/squashfs"
"github.com/diskfs/go-diskfs/partition"
)
// Disk is a reference to a single disk block device or image that has been Create() or Open()
type Disk struct {
File *os.File
Info os.FileInfo
Type Type
Size int64
LogicalBlocksize int64
PhysicalBlocksize int64
Table partition.Table
Writable bool
DefaultBlocks bool
}
// Type represents the type of disk this is
type Type int
const (
// File is a file-based disk image
File Type = iota
// Device is an OS-managed block device
Device
)
var (
errIncorrectOpenMode = errors.New("disk file or device not open for write")
)
// GetPartitionTable retrieves a PartitionTable for a Disk
//
// If the table is able to be retrieved from the disk, it is saved in the instance.
//
// returns an error if the Disk is invalid or does not exist, or the partition table is unknown
func (d *Disk) GetPartitionTable() (partition.Table, error) {
t, err := partition.Read(d.File, int(d.LogicalBlocksize), int(d.PhysicalBlocksize))
if err != nil {
return nil, err
}
d.Table = t
return t, nil
}
// Partition applies a partition.Table implementation to a Disk
//
// The Table can have zero, one or more Partitions, each of which is unique to its
// implementation. E.g. MBR partitions in mbr.Table look different from GPT partitions in gpt.Table
//
// Actual writing of the table is delegated to the individual implementation
func (d *Disk) Partition(table partition.Table) error {
if !d.Writable {
return errIncorrectOpenMode
}
// fill in the uuid
err := table.Write(d.File, d.Size)
if err != nil {
return fmt.Errorf("failed to write partition table: %v", err)
}
d.Table = table
// the partition table needs to be re-read only if
// the disk file is an actual block device
if d.Type == Device {
err = d.ReReadPartitionTable()
if err != nil {
return fmt.Errorf("unable to re-read the partition table. Kernel still uses old partition table: %v", err)
}
}
return nil
}
// WritePartitionContents writes the contents of an io.Reader to a given partition
//
// if successful, returns the number of bytes written
//
// returns an error if there was an error writing to the disk, reading from the reader, the table
// is invalid, or the partition is invalid
func (d *Disk) WritePartitionContents(part int, reader io.Reader) (int64, error) {
if !d.Writable {
return -1, errIncorrectOpenMode
}
if d.Table == nil {
return -1, fmt.Errorf("cannot write contents of a partition on a disk without a partition table")
}
if part < 0 {
return -1, fmt.Errorf("cannot write contents of a partition without specifying a partition")
}
partitions := d.Table.GetPartitions()
// API indexes from 1, but slice from 0
if part > len(partitions) {
return -1, fmt.Errorf("cannot write contents of partition %d which is greater than max partition %d", part, len(partitions))
}
written, err := partitions[part-1].WriteContents(d.File, reader)
return int64(written), err
}
// ReadPartitionContents reads the contents of a partition to an io.Writer
//
// if successful, returns the number of bytes read
//
// returns an error if there was an error reading from the disk, writing to the writer, the table
// is invalid, or the partition is invalid
func (d *Disk) ReadPartitionContents(part int, writer io.Writer) (int64, error) {
if d.Table == nil {
return -1, fmt.Errorf("cannot read contents of a partition on a disk without a partition table")
}
if part < 0 {
return -1, fmt.Errorf("cannot read contents of a partition without specifying a partition")
}
partitions := d.Table.GetPartitions()
// API indexes from 1, but slice from 0
if part > len(partitions) {
return -1, fmt.Errorf("cannot read contents of partition %d which is greater than max partition %d", part, len(partitions))
}
return partitions[part-1].ReadContents(d.File, writer)
}
// FilesystemSpec represents the specification of a filesystem to be created
type FilesystemSpec struct {
Partition int
FSType filesystem.Type
VolumeLabel string
WorkDir string
}
// CreateFilesystem creates a filesystem on a disk image, the equivalent of mkfs.
//
// Required:
// - desired partition number, or 0 to create the filesystem on the entire block device or
// disk image,
// - the filesystem type from github.com/diskfs/go-diskfs/filesystem
//
// Optional:
// - volume label for those filesystems that support it; under Linux this shows
// in '/dev/disks/by-label/'
//
// if successful, returns a filesystem-implementing structure for the given filesystem type
//
// returns error if there was an error creating the filesystem, or the partition table is invalid and did not
// request the entire disk.
func (d *Disk) CreateFilesystem(spec 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 !d.Writable:
return nil, errIncorrectOpenMode
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.TypeFat32:
return fat32.Create(d.File, size, start, d.LogicalBlocksize, spec.VolumeLabel)
case filesystem.TypeISO9660:
return iso9660.Create(d.File, size, start, d.LogicalBlocksize, spec.WorkDir)
case filesystem.TypeSquashfs:
return nil, errors.New("squashfs is a read-only filesystem")
default:
return nil, errors.New("unknown filesystem type requested")
}
}
// GetFilesystem gets the filesystem that already exists on a disk image
//
// pass the desired partition number, or 0 to create the filesystem on the entire block device / disk image,
//
// if successful, returns a filesystem-implementing structure for the given filesystem type
//
// returns error if there was an error reading the filesystem, or the partition table is invalid and did not
// request the entire disk.
func (d *Disk) GetFilesystem(part int) (filesystem.FileSystem, error) {
// find out where the partition starts and ends, or if it is the entire disk
var (
size, start int64
err error
)
switch {
case part == 0:
size = d.Size
start = 0
case d.Table == nil:
return nil, fmt.Errorf("cannot read filesystem on a partition without a partition table")
default:
partitions := d.Table.GetPartitions()
// API indexes from 1, but slice from 0
if part > len(partitions) {
return nil, fmt.Errorf("cannot get filesystem on partition %d greater than maximum partition %d", part, len(partitions))
}
size = partitions[part-1].GetSize()
start = partitions[part-1].GetStart()
}
// just try each type
log.Debug("trying fat32")
fat32FS, err := fat32.Read(d.File, size, start, d.LogicalBlocksize)
if err == nil {
return fat32FS, nil
}
log.Debugf("fat32 failed: %v", err)
pbs := d.PhysicalBlocksize
if d.DefaultBlocks {
pbs = 0
}
log.Debugf("trying iso9660 with physical block size %d", pbs)
iso9660FS, err := iso9660.Read(d.File, size, start, pbs)
if err == nil {
return iso9660FS, nil
}
log.Debugf("iso9660 failed: %v", err)
squashFS, err := squashfs.Read(d.File, size, start, d.LogicalBlocksize)
if err == nil {
return squashFS, nil
}
return nil, fmt.Errorf("unknown filesystem on partition %d", part)
}
07070100000305000081A4000000000000000000000001645E367C00000265000000000000000000000000000000000000004900000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/disk/disk_unix.go //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
package disk
import (
"fmt"
"golang.org/x/sys/unix"
)
const (
blkrrpart = 0x125f
)
// ReReadPartitionTable forces the kernel to re-read the partition table
// on the disk.
//
// It is done via an ioctl call with request as BLKRRPART.
func (d *Disk) ReReadPartitionTable() error {
fd := d.File.Fd()
_, err := unix.IoctlGetInt(int(fd), blkrrpart)
if err != nil {
return fmt.Errorf("unable to re-read partition table: %v", err)
}
return nil
}
07070100000306000081A4000000000000000000000001645E367C000000F5000000000000000000000000000000000000004C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/disk/disk_windows.go package disk
// ReReadPartitionTable is used to re-read the partition table
// on the disk.
//
// In windows machine, force re-read is not done. The method returns nil when
// invoked
func (d *Disk) ReReadPartitionTable() error {
return nil
}
07070100000307000081A4000000000000000000000001645E367C00002805000000000000000000000000000000000000004100000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/diskfs.go // Package diskfs implements methods for creating and manipulating disks and filesystems
//
// methods for creating and manipulating disks and filesystems, whether block devices
// in /dev or direct disk images. This does **not**
// mount any disks or filesystems, neither directly locally nor via a VM. Instead, it manipulates the
// bytes directly.
//
// This is not intended as a replacement for operating system filesystem and disk drivers. Instead,
// it is intended to make it easy to work with partitions, partition tables and filesystems directly
// without requiring operating system mounts.
//
// Some examples:
//
// 1. Create a disk image of size 10MB with a FAT32 filesystem spanning the entire disk.
//
// import diskfs "github.com/diskfs/go-diskfs"
// size := 10*1024*1024 // 10 MB
//
// diskImg := "/tmp/disk.img"
// disk := diskfs.Create(diskImg, size, diskfs.Raw, diskfs.SectorSizeDefault)
//
// fs, err := disk.CreateFilesystem(0, diskfs.TypeFat32)
//
// 2. Create a disk of size 20MB with an MBR partition table, a single partition beginning at block 2048 (1MB),
// of size 10MB filled with a FAT32 filesystem.
//
// import diskfs "github.com/diskfs/go-diskfs"
//
// diskSize := 10*1024*1024 // 10 MB
//
// diskImg := "/tmp/disk.img"
// disk := diskfs.Create(diskImg, size, diskfs.Raw, diskfs.SectorSizeDefault)
//
// table := &mbr.Table{
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// Partitions: []*mbr.Partition{
// {
// Bootable: false,
// Type: Linux,
// Start: 2048,
// Size: 20480,
// },
// },
// }
//
// fs, err := disk.CreateFilesystem(1, diskfs.TypeFat32)
//
// 3. Create a disk of size 20MB with a GPT partition table, a single partition beginning at block 2048 (1MB),
// of size 10MB, and fill with the contents from the 10MB file "/root/contents.dat"
//
// import diskfs "github.com/diskfs/go-diskfs"
//
// diskSize := 10*1024*1024 // 10 MB
//
// diskImg := "/tmp/disk.img"
// disk := diskfs.Create(diskImg, size, diskfs.Raw, diskfs.SectorSizeDefault)
//
// table := &gpt.Table{
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// Partitions: []*gpt.Partition{
// {
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// ProtectiveMBR: true,
// },
// },
// }
//
// f, err := os.Open("/root/contents.dat")
// written, err := disk.WritePartitionContents(1, f)
//
// 4. Create a disk of size 20MB with an MBR partition table, a single partition beginning at block 2048 (1MB),
// of size 10MB filled with a FAT32 filesystem, and create some directories and files in that filesystem.
//
// import diskfs "github.com/diskfs/go-diskfs"
//
// diskSize := 10*1024*1024 // 10 MB
//
// diskImg := "/tmp/disk.img"
// disk := diskfs.Create(diskImg, size, diskfs.Raw, diskfs.SectorSizeDefault)
//
// table := &mbr.Table{
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// Partitions: []*mbr.Partition{
// {
// Bootable: false,
// Type: Linux,
// Start: 2048,
// Size: 20480,
// },
// },
// }
//
// fs, err := disk.CreateFilesystem(1, diskfs.TypeFat32)
// err := fs.Mkdir("/FOO/BAR")
// rw, err := fs.OpenFile("/FOO/BAR/AFILE.EXE", os.O_CREATE|os.O_RDRWR)
// b := make([]byte, 1024, 1024)
// rand.Read(b)
// err := rw.Write(b)
package diskfs
import (
"errors"
"fmt"
"io"
"os"
log "github.com/sirupsen/logrus"
"github.com/diskfs/go-diskfs/disk"
)
// when we use a disk image with a GPT, we cannot get the logical sector size from the disk via the kernel
//
// so we use the default sector size of 512, per Rod Smith
const (
defaultBlocksize int = 512
// firstblock = 2048
// blksszGet = 0x1268
// blkpbszGet = 0x127b
)
// Format represents the format of the disk
type Format int
const (
// Raw disk format for basic raw disk
Raw Format = iota
)
// OpenModeOption represents file open modes
type OpenModeOption int
const (
// ReadOnly open file in read only mode
ReadOnly OpenModeOption = iota
// ReadWriteExclusive open file in read-write exclusive mode
ReadWriteExclusive
)
// OpenModeOption.String()
func (m OpenModeOption) String() string {
switch m {
case ReadOnly:
return "read-only"
case ReadWriteExclusive:
return "read-write exclusive"
default:
return "unknown"
}
}
var openModeOptions = map[OpenModeOption]int{
ReadOnly: os.O_RDONLY,
ReadWriteExclusive: os.O_RDWR | os.O_EXCL,
}
// SectorSize represents the sector size to use
type SectorSize int
const (
// SectorSizeDefault default behavior, defaulting to defaultBlocksize
SectorSizeDefault SectorSize = 0
// SectorSize512 override sector size to 512
SectorSize512 SectorSize = 512
// SectorSize4k override sector size to 4k
SectorSize4k SectorSize = 4096
)
func writableMode(mode OpenModeOption) bool {
m, ok := openModeOptions[mode]
if ok {
if m&os.O_RDWR != 0 || m&os.O_WRONLY != 0 {
return true
}
}
return false
}
func initDisk(f *os.File, openMode OpenModeOption, sectorSize SectorSize) (*disk.Disk, error) {
var (
diskType disk.Type
size int64
lblksize = int64(defaultBlocksize)
pblksize = int64(defaultBlocksize)
defaultBlocks = true
)
log.Debug("initDisk(): start")
if sectorSize != SectorSizeDefault {
lblksize = int64(sectorSize)
pblksize = int64(sectorSize)
}
// get device information
devInfo, err := f.Stat()
if err != nil {
return nil, fmt.Errorf("could not get info for device %s: %v", f.Name(), err)
}
mode := devInfo.Mode()
switch {
case mode.IsRegular():
log.Debug("initDisk(): regular file")
diskType = disk.File
size = devInfo.Size()
if size <= 0 {
return nil, fmt.Errorf("could not get file size for device %s", f.Name())
}
case mode&os.ModeDevice != 0:
log.Debug("initDisk(): block device")
diskType = disk.Device
file, err := os.Open(f.Name())
if err != nil {
return nil, fmt.Errorf("error opening block device %s: %s", f.Name(), err)
}
defer file.Close()
size, err = file.Seek(0, io.SeekEnd)
if err != nil {
return nil, fmt.Errorf("error seeking to end of block device %s: %s", f.Name(), err)
}
lblksize, pblksize, err = getSectorSizes(f)
log.Debugf("initDisk(): logical block size %d, physical block size %d", lblksize, pblksize)
defaultBlocks = false
if err != nil {
return nil, fmt.Errorf("unable to get block sizes for device %s: %v", f.Name(), err)
}
default:
return nil, fmt.Errorf("device %s is neither a block device nor a regular file", f.Name())
}
// how many good blocks do we have?
// var goodBlocks, orphanedBlocks int
// goodBlocks = size / lblksize
writable := writableMode(openMode)
ret := &disk.Disk{
File: f,
Info: devInfo,
Type: diskType,
Size: size,
LogicalBlocksize: lblksize,
PhysicalBlocksize: pblksize,
Writable: writable,
DefaultBlocks: defaultBlocks,
}
// try to initialize the partition table.
// we ignore errors, because it is perfectly fine to open a disk
// and use it before it has a partition table. This is solely
// a convenience.
if table, err := ret.GetPartitionTable(); err == nil && table != nil {
ret.Table = table
}
return ret, nil
}
func checkDevice(device string) error {
if device == "" {
return errors.New("must pass device name")
}
if _, err := os.Stat(device); os.IsNotExist(err) {
return fmt.Errorf("provided device %s does not exist", device)
}
return nil
}
type openOpts struct {
mode OpenModeOption
sectorSize SectorSize
}
func openOptsDefaults() *openOpts {
return &openOpts{
mode: ReadWriteExclusive,
sectorSize: SectorSizeDefault,
}
}
// OpenOpt func that process Open options
type OpenOpt func(o *openOpts) error
// WithOpenMode sets the opening mode to the requested mode of type OpenModeOption.
// Default is ReadWriteExclusive, i.e. os.O_RDWR | os.O_EXCL
func WithOpenMode(mode OpenModeOption) OpenOpt {
return func(o *openOpts) error {
o.mode = mode
return nil
}
}
// WithSectorSize opens the disk file or block device with the provided sector size.
// Defaults to the physical block size.
func WithSectorSize(sectorSize SectorSize) OpenOpt {
return func(o *openOpts) error {
o.sectorSize = sectorSize
return nil
}
}
// Open a Disk from a path to a device in read-write exclusive mode
// Should pass a path to a block device e.g. /dev/sda or a path to a file /tmp/foo.img
// The provided device must exist at the time you call Open().
// Use OpenOpt to control options, such as sector size or open mode.
func Open(device string, opts ...OpenOpt) (*disk.Disk, error) {
err := checkDevice(device)
if err != nil {
return nil, err
}
opt := openOptsDefaults()
for _, o := range opts {
if err := o(opt); err != nil {
return nil, err
}
}
m, ok := openModeOptions[opt.mode]
if !ok {
return nil, errors.New("unsupported file open mode")
}
f, err := os.OpenFile(device, m, 0o600)
if err != nil {
return nil, fmt.Errorf("could not open device %s exclusively for writing", device)
}
// return our disk
return initDisk(f, ReadWriteExclusive, opt.sectorSize)
}
// Create a Disk from a path to a device
// Should pass a path to a block device e.g. /dev/sda or a path to a file /tmp/foo.img
// The provided device must not exist at the time you call Create()
func Create(device string, size int64, format Format, sectorSize SectorSize) (*disk.Disk, error) {
if device == "" {
return nil, errors.New("must pass device name")
}
if size <= 0 {
return nil, errors.New("must pass valid device size to create")
}
f, err := os.OpenFile(device, os.O_RDWR|os.O_EXCL|os.O_CREATE, 0o666)
if err != nil {
return nil, fmt.Errorf("could not create device %s: %v", device, errors.Unwrap(err))
}
err = os.Truncate(device, size)
if err != nil {
return nil, fmt.Errorf("could not expand device %s to size %d: %v", device, size, errors.Unwrap(err))
}
// return our disk
return initDisk(f, ReadWriteExclusive, sectorSize)
}
07070100000308000081A4000000000000000000000001645E367C000003FB000000000000000000000000000000000000004800000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/diskfs_darwin.go package diskfs
import (
"fmt"
"os"
"golang.org/x/sys/unix"
)
// this constants should be part of "golang.org/x/sys/unix", but aren't, yet
const (
DKIOCGETBLOCKSIZE = 0x40046418
DKIOCGETPHYSICALBLOCKSIZE = 0x4004644D
DKIOCGETBLOCKCOUNT = 0x40086419
)
// getSectorSizes get the logical and physical sector sizes for a block device
func getSectorSizes(f *os.File) (logicalSectorSize, physicalSectorSize int64, err error) {
//nolint:gocritic // we keep this for reference to the underlying syscall
/*
ioctl(fd, BLKPBSZGET, &physicalsectsize);
*/
fd := f.Fd()
logicalSectorSizeInt, err := unix.IoctlGetInt(int(fd), DKIOCGETBLOCKSIZE)
if err != nil {
return 0, 0, fmt.Errorf("unable to get device logical sector size: %v", err)
}
physicalSectorSizeInt, err := unix.IoctlGetInt(int(fd), DKIOCGETPHYSICALBLOCKSIZE)
if err != nil {
return 0, 0, fmt.Errorf("unable to get device physical sector size: %v", err)
}
return int64(logicalSectorSizeInt), int64(physicalSectorSizeInt), nil
}
07070100000309000081A4000000000000000000000001645E367C00000387000000000000000000000000000000000000004600000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/diskfs_unix.go //go:build linux || solaris || aix || freebsd || illumos || netbsd || openbsd || plan9
// +build linux solaris aix freebsd illumos netbsd openbsd plan9
package diskfs
import (
"fmt"
"os"
"golang.org/x/sys/unix"
)
// getSectorSizes get the logical and physical sector sizes for a block device
func getSectorSizes(f *os.File) (logicalSectorSize, physicalSectorSize int64, err error) {
//
// equivalent syscall to
// ioctl(fd, BLKPBSZGET, &physicalsectsize);
fd := f.Fd()
logicalSectorSizeInt, err := unix.IoctlGetInt(int(fd), unix.BLKSSZGET)
if err != nil {
return 0, 0, fmt.Errorf("unable to get device logical sector size: %v", err)
}
physicalSectorSizeInt, err := unix.IoctlGetInt(int(fd), unix.BLKPBSZGET)
if err != nil {
return 0, 0, fmt.Errorf("unable to get device physical sector size: %v", err)
}
return int64(logicalSectorSizeInt), int64(physicalSectorSizeInt), nil
}
0707010000030A000081A4000000000000000000000001645E367C000000F8000000000000000000000000000000000000004900000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/diskfs_windows.go package diskfs
import (
"errors"
"os"
)
// getSectorSizes get the logical and physical sector sizes for a block device
func getSectorSizes(f *os.File) (int64, int64, error) {
return 0, 0, errors.New("block devices not supported on windows")
}
0707010000030B000041ED000000000000000000000005645E367C00000000000000000000000000000000000000000000004200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem 0707010000030C000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004800000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32 0707010000030D000081A4000000000000000000000001645E367C00000B0B000000000000000000000000000000000000005500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/directory.go package fat32
import (
"time"
)
// Directory represents a single directory in a FAT32 filesystem
type Directory struct {
directoryEntry
entries []*directoryEntry
}
// dirEntriesFromBytes loads the directory entries from the raw bytes
func (d *Directory) entriesFromBytes(b []byte) error {
entries, err := parseDirEntries(b)
if err != nil {
return err
}
d.entries = entries
return nil
}
// entriesToBytes convert our entries to raw bytes
func (d *Directory) entriesToBytes(bytesPerCluster int) ([]byte, error) {
b := make([]byte, 0)
for _, de := range d.entries {
b2, err := de.toBytes()
if err != nil {
return nil, err
}
b = append(b, b2...)
}
remainder := len(b) % bytesPerCluster
extra := bytesPerCluster - remainder
zeroes := make([]byte, extra)
b = append(b, zeroes...)
return b, nil
}
// createEntry creates an entry in the given directory, and returns the handle to it
func (d *Directory) createEntry(name string, cluster uint32, dir bool) (*directoryEntry, error) {
// is it a long filename or a short filename?
var isLFN bool
// TODO: convertLfnSfn does not calculate if the short name conflicts and thus shoukld increment the last character
// that should happen here, once we can look in the directory entry
shortName, extension, isLFN, _ := convertLfnSfn(name)
lfn := ""
if isLFN {
lfn = name
}
// allocate a slot for the new filename in the existing directory
entry := directoryEntry{
filenameLong: lfn,
longFilenameSlots: -1, // indicate that we do not know how many slots, which will force a recalculation
filenameShort: shortName,
fileExtension: extension,
fileSize: uint32(0),
clusterLocation: cluster,
filesystem: d.filesystem,
createTime: time.Now(),
modifyTime: time.Now(),
accessTime: time.Now(),
isSubdirectory: dir,
isNew: true,
}
entry.longFilenameSlots = calculateSlots(entry.filenameLong)
d.entries = append(d.entries, &entry)
return &entry, nil
}
// createVolumeLabel create a volume label entry in the given directory, and return the handle to it
func (d *Directory) createVolumeLabel(name string) (*directoryEntry, error) {
// allocate a slot for the new filename in the existing directory
entry := directoryEntry{
filenameLong: "",
longFilenameSlots: -1, // indicate that we do not know how many slots, which will force a recalculation
filenameShort: name[:8],
fileExtension: name[8:11],
fileSize: uint32(0),
clusterLocation: 0,
filesystem: d.filesystem,
createTime: time.Now(),
modifyTime: time.Now(),
accessTime: time.Now(),
isSubdirectory: false,
isNew: true,
isVolumeLabel: true,
}
d.entries = append(d.entries, &entry)
return &entry, nil
}
0707010000030E000081A4000000000000000000000001645E367C000039CB000000000000000000000000000000000000005A00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/directoryentry.go package fat32
import (
"encoding/binary"
"fmt"
"regexp"
"strings"
"time"
)
// AccessRights is the byte mask representing access rights to a FAT file
type accessRights uint16
// AccessRightsUnlimited represents unrestricted access
const (
accessRightsUnlimited accessRights = 0x0000
charsPerSlot int = 13
)
// valid shortname characters - [A-F][0-9][$%'-_@~`!(){}^#&]
var validShortNameCharacters = map[byte]bool{
0x21: true, // !
0x23: true, // #
0x24: true, // $
0x25: true, // %
0x26: true, // &
0x27: true, // '
0x28: true, // (
0x29: true, // )
0x2d: true, // -
0x30: true, // 0
0x31: true, // 1
0x32: true, // 2
0x33: true, // 3
0x34: true, // 4
0x35: true, // 5
0x36: true, // 6
0x37: true, // 7
0x38: true, // 8
0x39: true, // 9
0x40: true, // @
0x41: true, // A
0x42: true, // B
0x43: true, // C
0x44: true, // D
0x45: true, // E
0x46: true, // F
0x47: true, // G
0x48: true, // H
0x49: true, // I
0x4a: true, // J
0x4b: true, // K
0x4c: true, // L
0x4d: true, // M
0x4e: true, // N
0x4f: true, // O
0x50: true, // P
0x51: true, // Q
0x52: true, // R
0x53: true, // S
0x54: true, // T
0x55: true, // U
0x56: true, // V
0x57: true, // W
0x58: true, // X
0x59: true, // Y
0x5a: true, // Z
0x5e: true, // ^
0x5f: true, // _
0x60: true, // `
0x7b: true, // {
0x7d: true, // }
0x7e: true, // ~
}
// directoryEntry is a single directory entry
//
//nolint:structcheck // we are willing to leave unused elements here so that we can know their reference
type directoryEntry struct {
filenameShort string
fileExtension string
filenameLong string
isReadOnly bool
isHidden bool
isSystem bool
isVolumeLabel bool
isSubdirectory bool
isArchiveDirty bool
isDevice bool
lowercaseShortname bool
lowercaseExtension bool
createTime time.Time
modifyTime time.Time
accessTime time.Time
acccessRights accessRights
clusterLocation uint32
fileSize uint32
filesystem *FileSystem
longFilenameSlots int
isNew bool
}
func (de *directoryEntry) toBytes() ([]byte, error) {
b := make([]byte, 0, bytesPerSlot)
// do we have a long filename?
if de.filenameLong != "" {
lfnBytes, err := longFilenameBytes(de.filenameLong, de.filenameShort, de.fileExtension)
if err != nil {
return nil, fmt.Errorf("could not convert long filename to directory entries: %v", err)
}
b = append(b, lfnBytes...)
}
// this is for the regular 8.3 entry
dosBytes := make([]byte, bytesPerSlot)
createDate, createTime := timeToDateTime(de.createTime)
modifyDate, modifyTime := timeToDateTime(de.modifyTime)
accessDate, _ := timeToDateTime(de.accessTime)
binary.LittleEndian.PutUint16(dosBytes[14:16], createTime)
binary.LittleEndian.PutUint16(dosBytes[16:18], createDate)
binary.LittleEndian.PutUint16(dosBytes[18:20], accessDate)
binary.LittleEndian.PutUint16(dosBytes[22:24], modifyTime)
binary.LittleEndian.PutUint16(dosBytes[24:26], modifyDate)
// convert the short filename and extension to ascii bytes
shortName, err := stringToASCIIBytes(fmt.Sprintf("% -8s", de.filenameShort))
if err != nil {
return nil, fmt.Errorf("error converting short filename to bytes: %v", err)
}
// convert the short filename and extension to ascii bytes
extension, err := stringToASCIIBytes(fmt.Sprintf("% -3s", de.fileExtension))
if err != nil {
return nil, fmt.Errorf("error converting file extension to bytes: %v", err)
}
copy(dosBytes[0:8], shortName)
copy(dosBytes[8:11], extension)
binary.LittleEndian.PutUint32(dosBytes[28:32], de.fileSize)
clusterLocation := make([]byte, 4)
binary.LittleEndian.PutUint32(clusterLocation, de.clusterLocation)
dosBytes[26] = clusterLocation[0]
dosBytes[27] = clusterLocation[1]
dosBytes[20] = clusterLocation[2]
dosBytes[21] = clusterLocation[3]
// set the flags
if de.isVolumeLabel {
dosBytes[11] |= 0x08
}
if de.isSubdirectory {
dosBytes[11] |= 0x10
}
if de.isArchiveDirty {
dosBytes[11] |= 0x20
}
if de.lowercaseExtension {
dosBytes[12] |= 0x04
}
if de.lowercaseShortname {
dosBytes[12] |= 0x08
}
b = append(b, dosBytes...)
return b, nil
}
// parseDirEntries takes all of the bytes in a special file (i.e. a directory)
// and gets all of the DirectoryEntry for that directory
// this is, essentially, the equivalent of `ls -l` or if you prefer `dir`
func parseDirEntries(b []byte) ([]*directoryEntry, error) {
dirEntries := make([]*directoryEntry, 0, 20)
// parse the data into Fat32DirectoryEntry
lfn := ""
// this should be used to count the LFN entries and that they make sense
// lfnCount := 0
byteLoop:
for i := 0; i < len(b); i += 32 {
// is this the beginning of all empty entries?
switch b[i+0] {
case 0:
// need to break "byteLoop" else break will break the switches
break byteLoop
case 0xe5:
continue
}
// is this an LFN entry?
if b[i+11] == 0x0f {
// check if this is the last logical / first physical and how many there are
if b[i]&0x40 == 0x40 {
lfn = ""
}
// parse the long filename
tmpLfn, err := longFilenameEntryFromBytes(b[i : i+32])
// an error is impossible since we pass exactly 32, but we leave the handler here anyways
if err != nil {
return nil, fmt.Errorf("error parsing long filename at position %d: %v", i, err)
}
lfn = tmpLfn + lfn
continue
}
// not LFN, so parse regularly
createTime := binary.LittleEndian.Uint16(b[i+14 : i+16])
createDate := binary.LittleEndian.Uint16(b[i+16 : i+18])
accessDate := binary.LittleEndian.Uint16(b[i+18 : i+20])
modifyTime := binary.LittleEndian.Uint16(b[i+22 : i+24])
modifyDate := binary.LittleEndian.Uint16(b[i+24 : i+26])
re := regexp.MustCompile(" +$")
sfn := re.ReplaceAllString(string(b[i:i+8]), "")
extension := re.ReplaceAllString(string(b[i+8:i+11]), "")
isSubdirectory := b[i+11]&0x10 == 0x10
isArchiveDirty := b[i+11]&0x20 == 0x20
isVolumeLabel := b[i+11]&0x08 == 0x08
lowercaseShortname := b[i+12]&0x08 == 0x08
lowercaseExtension := b[i+12]&0x04 == 0x04
entry := directoryEntry{
filenameLong: lfn,
longFilenameSlots: calculateSlots(lfn),
filenameShort: sfn,
fileExtension: extension,
fileSize: binary.LittleEndian.Uint32(b[i+28 : i+32]),
clusterLocation: binary.LittleEndian.Uint32(append(b[i+26:i+28], b[i+20:i+22]...)),
createTime: dateTimeToTime(createDate, createTime),
modifyTime: dateTimeToTime(modifyDate, modifyTime),
accessTime: dateTimeToTime(accessDate, 0),
isSubdirectory: isSubdirectory,
isArchiveDirty: isArchiveDirty,
isVolumeLabel: isVolumeLabel,
lowercaseShortname: lowercaseShortname,
lowercaseExtension: lowercaseExtension,
}
lfn = ""
dirEntries = append(dirEntries, &entry)
}
return dirEntries, nil
}
func dateTimeToTime(d, t uint16) time.Time {
year := int(d>>9) + 1980
month := time.Month((d >> 5) & 0x0f)
date := int(d & 0x1f)
second := int((t & 0x1f) * 2)
minute := int((t >> 5) & 0x3f)
hour := int(t >> 11)
return time.Date(year, month, date, hour, minute, second, 0, time.UTC)
}
func timeToDateTime(t time.Time) (datePart, timePart uint16) {
year := t.Year()
month := int(t.Month())
day := t.Day()
second := t.Second()
minute := t.Minute()
hour := t.Hour()
retDate := (year-1980)<<9 + (month << 5) + day
retTime := hour<<11 + minute<<5 + (second / 2)
return uint16(retDate), uint16(retTime)
}
func longFilenameBytes(s, shortName, extension string) ([]byte, error) {
// we need the checksum of the short name
checksum, err := lfnChecksum(shortName, extension)
if err != nil {
return nil, fmt.Errorf("could not calculate checksum for 8.3 filename: %v", err)
}
// should be multiple of exactly 32 bytes
slots := calculateSlots(s)
// convert our string into runes
r := []rune(s)
b2SlotLength := maxCharsLongFilename * 2
maxChars := slots * maxCharsLongFilename
b2 := make([]byte, 0, maxChars*2)
// convert the rune slice into a byte slice with 2 bytes per rune
// vfat long filenames support UCS-2 *only*
// so it is *very* important we do not try to parse them otherwise
for i := 0; i < maxChars; i++ {
// do we have a rune at this point?
var tmpb []byte
switch {
case i == len(r):
tmpb = []byte{0x00, 0x00}
case i > len(r):
tmpb = []byte{0xff, 0xff}
default:
val := uint16(r[i])
// little endian
tmpb = []byte{byte(val & 0x00ff), byte(val >> 8)}
}
b2 = append(b2, tmpb...)
}
// this makes our byte array
maxBytes := slots * bytesPerSlot
b := make([]byte, 0, maxBytes)
// now just place the bytes in the right places
for count := slots; count > 0; count-- {
// how far from the start of the byte slice?
offset := (count - 1) * b2SlotLength
// enter the right bytes in the right places
tmpb := make([]byte, 0, 32)
// first byte is our index
tmpb = append(tmpb, byte(count))
// next 10 bytes are 5 chars of data
tmpb = append(tmpb, b2[offset:offset+10]...)
// next is a single byte indicating LFN, followed by single byte 0x00
//nolint:gocritic // gocritic complains about the ability to combine 2 appends into one; we want to be more explicit here
tmpb = append(tmpb, 0x0f, 0x00)
// next is checksum
tmpb = append(tmpb, checksum)
// next 12 bytes are 6 chars of data
tmpb = append(tmpb, b2[offset+10:offset+22]...)
// next are 2 bytes of 0x00
tmpb = append(tmpb, 0x00, 0x00)
// next are 4 bytes, last 2 chars of LFN
tmpb = append(tmpb, b2[offset+22:offset+26]...)
b = append(b, tmpb...)
}
// the first byte should have bit 6 set
b[0] |= 0x40
return b, nil
}
// longFilenameEntryFromBytes takes a single slice of 32 bytes and extracts the long filename component from it
func longFilenameEntryFromBytes(b []byte) (string, error) {
// should be exactly 32 bytes
bLen := len(b)
if bLen != 32 {
return "", fmt.Errorf("longFilenameEntryFromBytes only can parse byte of length 32, not %d", bLen)
}
b2 := make([]byte, 0, maxCharsLongFilename*2)
// strip out the unused ones
b2 = append(b2, b[1:11]...)
b2 = append(b2, b[14:26]...)
b2 = append(b2, b[28:32]...)
// parse the bytes of the long filename
// vfat long filenames support UCS-2 *only*
// so it is *very* important we do not try to parse them otherwise
r := make([]rune, 0, maxCharsLongFilename)
// now we can iterate
for i := 0; i < maxCharsLongFilename; i++ {
// little endian
val := uint16(b2[2*i+1])<<8 + uint16(b2[2*i])
// stop at all 0
if val == 0 {
break
}
r = append(r, rune(val))
}
return string(r), nil
}
// takes the short form of the name and checksums it
// the period between the 8 characters and the 3 character extension is dropped
// any unused chars are replaced by space ASCII 0x20
func lfnChecksum(name, extension string) (byte, error) {
nameBytes, err := stringToValidASCIIBytes(name)
if err != nil {
return 0x00, fmt.Errorf("invalid shortname character in filename: %s", name)
}
extensionBytes, err := stringToValidASCIIBytes(extension)
if err != nil {
return 0x00, fmt.Errorf("invalid shortname character in extension: %s", extension)
}
// now make sure we don't have too many - and fill in blanks
length := len(nameBytes)
if length > 8 {
return 0x00, fmt.Errorf("short name for file is longer than allowed 8 bytes: %s", name)
}
for i := 8; i > length; i-- {
nameBytes = append(nameBytes, 0x20)
}
length = len(extensionBytes)
if length > 3 {
return 0x00, fmt.Errorf("extension for file is longer than allowed 3 bytes: %s", extension)
}
for i := 3; i > length; i-- {
extensionBytes = append(extensionBytes, 0x20)
}
b := make([]byte, len(nameBytes))
copy(b, nameBytes)
b = append(b, extensionBytes...)
// calculate the checksum
var sum byte = 0x00
for i := 11; i > 0; i-- {
sum = ((sum & 0x01) << 7) + (sum >> 1) + b[11-i]
}
return sum, nil
}
// convert a string to ascii bytes, but only accept valid 8.3 bytes
func stringToValidASCIIBytes(s string) ([]byte, error) {
b, err := stringToASCIIBytes(s)
if err != nil {
return b, err
}
// now make sure every byte is valid
for _, b2 := range b {
// only valid chars - 0-9, A-Z, _, ~
if validShortNameCharacters[b2] {
continue
}
return nil, fmt.Errorf("invalid 8.3 character")
}
return b, nil
}
// convert a string to a byte array, if all characters are valid ascii
func stringToASCIIBytes(s string) ([]byte, error) {
length := len(s)
b := make([]byte, length)
// convert the name into 11 bytes
r := []rune(s)
// take the first 8 characters
for i := 0; i < length; i++ {
val := int(r[i])
// we only can handle values less than max byte = 255
if val > 255 {
return nil, fmt.Errorf("non-ASCII character in name: %s", s)
}
b[i] = byte(val)
}
return b, nil
}
// calculate how many vfat slots a long filename takes up
// this does NOT include the slot for the true DOS 8.3 entry
func calculateSlots(s string) int {
sLen := len(s)
slots := sLen / charsPerSlot
if sLen%charsPerSlot != 0 {
slots++
}
return slots
}
// convert LFN to short name
// returns shortName, extension, isLFN, isTruncated
//
// isLFN : was there an LFN that had to be converted
// isTruncated : was the shortname longer than 8 chars and had to be converted?
func convertLfnSfn(name string) (shortName, extension string, isLFN, isTruncated bool) {
// get last period in name
lastDot := strings.LastIndex(name, ".")
// now convert it
var rawShortName, rawExtension string
rawShortName = name
// get the extension
if lastDot > -1 {
rawExtension = name[lastDot+1:]
// too long?
if len(rawExtension) > 3 {
rawExtension = rawExtension[0:3]
isLFN = true
}
// convert the extension
extension = uCaseValid(rawExtension)
}
if extension != rawExtension {
isLFN = true
}
// convert the short name
if lastDot > -1 {
rawShortName = name[:lastDot]
}
shortName = uCaseValid(rawShortName)
if rawShortName != shortName {
isLFN = true
}
// convert shortName to 8 chars
if len(shortName) > 8 {
isLFN = true
isTruncated = true
shortName = shortName[:6] + "~" + "1"
}
return shortName, extension, isLFN, isTruncated
}
// converts a string into upper-case with only valid characters
func uCaseValid(name string) string {
// easiest way to do this is to go through the name one char at a time
r := []rune(name)
r2 := make([]rune, 0, len(r))
for _, val := range r {
switch {
case validShortNameCharacters[byte(val)]:
r2 = append(r2, val)
case (0x61 <= val && val <= 0x7a):
// lower-case characters should be upper-cased
r2 = append(r2, val-32)
case val == ' ' || val == '.':
// remove spaces and periods
continue
default:
// replace the rest with _
r2 = append(r2, '_')
}
}
return string(r2)
}
0707010000030F000081A4000000000000000000000001645E367C0000014F000000000000000000000000000000000000004F00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/doc.go // Package fat32 provides utilities to interact with, manipulate and create a FAT32 filesystem on a block device or
// a disk image.
//
// references:
//
// https://en.wikipedia.org/wiki/Design_of_the_FAT_file_system
// https://www.cs.fsu.edu/~cop4610t/assignments/project3/spec/fatspec.pdf
// https://wiki.osdev.org/FAT
package fat32
07070100000310000081A4000000000000000000000001645E367C0000094A000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/dos20bpb.go package fat32
import (
"encoding/binary"
"errors"
"fmt"
)
// Dos20BPB is a DOS 2.0 BIOS Parameter Block structure
type dos20BPB struct {
bytesPerSector SectorSize // BytesPerSector is bytes in each sector - always should be 512
sectorsPerCluster uint8 // SectorsPerCluster is number of sectors per cluster
reservedSectors uint16 // ReservedSectors is number of reserved sectors
fatCount uint8 // FatCount is total number of FAT tables in the filesystem
rootDirectoryEntries uint16 // RootDirectoryEntries is maximum number of FAT12 or FAT16 root directory entries; must be 0 for FAT32
totalSectors uint16 // TotalSectors is total number of sectors in the filesystem
mediaType uint8 // MediaType is the type of media, mostly unused
sectorsPerFat uint16 // SectorsPerFat is number of sectors per each table
}
// Dos20BPBFromBytes reads the DOS 2.0 BIOS Parameter Block from a slice of exactly 13 bytes
func dos20BPBFromBytes(b []byte) (*dos20BPB, error) {
if b == nil || len(b) != 13 {
return nil, errors.New("cannot read DOS 2.0 BPB from invalid byte slice, must be precisely 13 bytes ")
}
bpb := dos20BPB{}
// make sure we have a valid sector size
sectorSize := binary.LittleEndian.Uint16(b[0:2])
if sectorSize != uint16(SectorSize512) {
return nil, fmt.Errorf("invalid sector size %d provided in DOS 2.0 BPB. Must be %d", sectorSize, SectorSize512)
}
bpb.bytesPerSector = SectorSize512
bpb.sectorsPerCluster = b[2]
bpb.reservedSectors = binary.LittleEndian.Uint16(b[3:5])
bpb.fatCount = b[5]
bpb.rootDirectoryEntries = binary.LittleEndian.Uint16(b[6:8])
bpb.totalSectors = binary.LittleEndian.Uint16(b[8:10])
bpb.mediaType = b[10]
bpb.sectorsPerFat = binary.LittleEndian.Uint16(b[11:13])
return &bpb, nil
}
// ToBytes returns the bytes for a DOS 2.0 BIOS Parameter Block, ready to be written to disk
func (bpb *dos20BPB) toBytes() []byte {
b := make([]byte, 13)
binary.LittleEndian.PutUint16(b[0:2], uint16(bpb.bytesPerSector))
b[2] = bpb.sectorsPerCluster
binary.LittleEndian.PutUint16(b[3:5], bpb.reservedSectors)
b[5] = bpb.fatCount
binary.LittleEndian.PutUint16(b[6:8], bpb.rootDirectoryEntries)
binary.LittleEndian.PutUint16(b[8:10], bpb.totalSectors)
b[10] = bpb.mediaType
binary.LittleEndian.PutUint16(b[11:13], bpb.sectorsPerFat)
return b
}
07070100000311000081A4000000000000000000000001645E367C00000A9E000000000000000000000000000000000000005500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/dos331bpb.go package fat32
import (
"encoding/binary"
"errors"
"fmt"
)
// dos331BPB is the DOS 3.31 BIOS Parameter Block
type dos331BPB struct {
dos20BPB *dos20BPB // Dos20BPB holds the embedded DOS 2.0 BPB
sectorsPerTrack uint16 // SectorsPerTrack is number of sectors per track. May be unused when LBA-only access is in place, but should store some value for safety.
heads uint16 // Heads is the number of heads. May be unused when LBA-only access is in place, but should store some value for safety. Maximum 255.
hiddenSectors uint32 // HiddenSectors is the number of hidden sectors preceding the partition that contains the FAT volume. Should be 0 on non-partitioned media.
totalSectors uint32 // TotalSectors is the total sectors if too many to fit into the DOS 2.0 BPB TotalSectors. In practice, if the DOS 2.0 TotalSectors is 0 and this is non-zero, use this one. For partitioned media, this and the DOS 2.0 BPB entry may be zero, and should retrieve information from each partition. For FAT32 systems, both also can be zero, even on non-partitioned, and use FileSystemType in DOS 7.1 EBPB as a 64-bit TotalSectors instead.
}
func (bpb *dos331BPB) equal(a *dos331BPB) bool {
if (bpb == nil && a != nil) || (a == nil && bpb != nil) {
return false
}
if bpb == nil && a == nil {
return true
}
return *bpb.dos20BPB == *a.dos20BPB &&
bpb.sectorsPerTrack == a.sectorsPerTrack &&
bpb.heads == a.heads &&
bpb.hiddenSectors == a.hiddenSectors &&
bpb.totalSectors == a.totalSectors
}
// dos331BPBFromBytes reads the DOS 3.31 BIOS Parameter Block from a slice of exactly 25 bytes
func dos331BPBFromBytes(b []byte) (*dos331BPB, error) {
if b == nil || len(b) != 25 {
return nil, errors.New("cannot read DOS 3.31 BPB from invalid byte slice, must be precisely 25 bytes ")
}
bpb := dos331BPB{}
dos20bpb, err := dos20BPBFromBytes(b[0:13])
if err != nil {
return nil, fmt.Errorf("error reading embedded DOS 2.0 BPB: %v", err)
}
bpb.dos20BPB = dos20bpb
bpb.sectorsPerTrack = binary.LittleEndian.Uint16(b[13:15])
bpb.heads = binary.LittleEndian.Uint16(b[15:17])
bpb.hiddenSectors = binary.LittleEndian.Uint32(b[17:21])
bpb.totalSectors = binary.LittleEndian.Uint32(b[21:25])
return &bpb, nil
}
// ToBytes returns the bytes for a DOS 3.31 BIOS Parameter Block, ready to be written to disk
func (bpb *dos331BPB) toBytes() []byte {
b := make([]byte, 25)
dos20Bytes := bpb.dos20BPB.toBytes()
copy(b[0:13], dos20Bytes)
binary.LittleEndian.PutUint16(b[13:15], bpb.sectorsPerTrack)
binary.LittleEndian.PutUint16(b[15:17], bpb.heads)
binary.LittleEndian.PutUint32(b[17:21], bpb.hiddenSectors)
binary.LittleEndian.PutUint32(b[21:25], bpb.totalSectors)
return b
}
07070100000312000081A4000000000000000000000001645E367C00001CA8000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/dos71bpb.go package fat32
import (
"encoding/binary"
"errors"
"fmt"
"regexp"
)
const (
// ShortDos71EBPB indicates that a DOS 7.1 EBPB is of the short 60-byte format
shortDos71EBPB uint8 = 0x28
// LongDos71EBPB indicates that a DOS 7.1 EBPB is of the long 79-byte format
longDos71EBPB uint8 = 0x29
)
const (
// FileSystemTypeFAT32 is the fixed string representation for the FAT32 filesystem type
fileSystemTypeFAT32 string = "FAT32 "
)
// FatVersion is the version of the FAT filesystem
type fatVersion uint16
const (
// FatVersion0 represents version 0 of FAT, the only acceptable version
fatVersion0 fatVersion = 0
)
const (
// FirstRemovableDrive is first removable drive
FirstRemovableDrive uint8 = 0x00
// FirstFixedDrive is first fixed drive
FirstFixedDrive uint8 = 0x80
)
// Dos71EBPB is the DOS 7.1 Extended BIOS Parameter Block
type dos71EBPB struct {
dos331BPB *dos331BPB // Dos331BPB holds the embedded DOS 3.31 BIOS Parameter BLock
sectorsPerFat uint32 // SectorsPerFat is number of sectors per each table
mirrorFlags uint16 // MirrorFlags determines how FAT mirroring is done. If bit 7 is set, use bits 3-0 to determine active number of FATs (zero-based); if bit 7 is clear, use normal FAT mirroring
version fatVersion // Version is the version of the FAT, must be 0
rootDirectoryCluster uint32 // RootDirectoryCluster is the cluster containing the filesystem root directory, normally 2
fsInformationSector uint16 // FSInformationSector holds the sector which contains the primary DOS 7.1 Filesystem Information Cluster
backupBootSector uint16 // BackupBootSector holds the sector which contains the backup boot sector and following FSIS sectors
bootFileName [12]byte // BootFileName is reserved and should be all 0x00
driveNumber uint8 // DriveNumber is the code for the relative position and type of this drive in the system
reservedFlags uint8 // ReservedFlags are flags used by the operating system and/or BIOS for various purposes, e.g. Windows NT CHKDSK status, OS/2 desired drive letter, etc.
extendedBootSignature uint8 // ExtendedBootSignature contains the flag as to whether this is a short (60-byte) or long (79-byte) DOS 7.1 EBPB
volumeSerialNumber uint32 // VolumeSerialNumber usually generated by some form of date and time
volumeLabel string // VolumeLabel, an arbitrary 11-byte string
fileSystemType string // FileSystemType is the 8-byte string holding the name of the file system type
}
func (bpb *dos71EBPB) equal(a *dos71EBPB) bool {
if (bpb == nil && a != nil) || (a == nil && bpb != nil) {
return false
}
if bpb == nil && a == nil {
return true
}
return bpb.dos331BPB.equal(a.dos331BPB) &&
bpb.sectorsPerFat == a.sectorsPerFat &&
bpb.mirrorFlags == a.mirrorFlags &&
bpb.version == a.version &&
bpb.rootDirectoryCluster == a.rootDirectoryCluster &&
bpb.fsInformationSector == a.fsInformationSector &&
bpb.backupBootSector == a.backupBootSector &&
bpb.bootFileName == a.bootFileName &&
bpb.driveNumber == a.driveNumber &&
bpb.reservedFlags == a.reservedFlags &&
bpb.extendedBootSignature == a.extendedBootSignature &&
bpb.volumeSerialNumber == a.volumeSerialNumber &&
bpb.volumeLabel == a.volumeLabel &&
bpb.fileSystemType == a.fileSystemType
}
// Dos71EBPBFromBytes reads the FAT32 Extended BIOS Parameter Block from a slice of bytes
// these bytes are assumed to start at the beginning of the BPB, but can stretech for any length
// this is because the calling function should know where the EBPB starts, but not necessarily where it ends
func dos71EBPBFromBytes(b []byte) (*dos71EBPB, int, error) {
if b == nil || (len(b) != 60 && len(b) != 79) {
return nil, 0, errors.New("cannot read DOS 7.1 EBPB from invalid byte slice, must be precisely 60 or 79 bytes ")
}
bpb := dos71EBPB{}
size := 0
// extract the embedded DOS 3.31 BPB
dos331bpb, err := dos331BPBFromBytes(b[0:25])
if err != nil {
return nil, 0, fmt.Errorf("could not read embedded DOS 3.31 BPB: %v", err)
}
bpb.dos331BPB = dos331bpb
bpb.sectorsPerFat = binary.LittleEndian.Uint32(b[25:29])
bpb.mirrorFlags = binary.LittleEndian.Uint16(b[29:31])
version := binary.LittleEndian.Uint16(b[31:33])
if version != uint16(fatVersion0) {
return nil, size, fmt.Errorf("invalid FAT32 version found: %v", version)
}
bpb.version = fatVersion0
bpb.rootDirectoryCluster = binary.LittleEndian.Uint32(b[33:37])
bpb.fsInformationSector = binary.LittleEndian.Uint16(b[37:39])
bpb.backupBootSector = binary.LittleEndian.Uint16(b[39:41])
bootFileName := b[41:53]
copy(bpb.bootFileName[:], bootFileName)
bpb.driveNumber = b[53]
bpb.reservedFlags = b[54]
extendedSignature := b[55]
bpb.extendedBootSignature = extendedSignature
// is this a longer or shorter one
bpb.volumeSerialNumber = binary.BigEndian.Uint32(b[56:60])
switch extendedSignature {
case shortDos71EBPB:
size = 60
case longDos71EBPB:
size = 79
// remove padding from each
re := regexp.MustCompile(" +$")
bpb.volumeLabel = re.ReplaceAllString(string(b[60:71]), "")
bpb.fileSystemType = re.ReplaceAllString(string(b[71:79]), "")
default:
return nil, size, fmt.Errorf("unknown DOS 7.1 EBPB Signature: %v", extendedSignature)
}
return &bpb, size, nil
}
// ToBytes returns the Extended BIOS Parameter Block in a slice of bytes directly ready to
// write to disk
func (bpb *dos71EBPB) toBytes() ([]byte, error) {
var b []byte
// how many bytes is it? for extended, add the extended-specific stuff
switch bpb.extendedBootSignature {
case shortDos71EBPB:
b = make([]byte, 60)
case longDos71EBPB:
b = make([]byte, 79)
// do we have a valid volume label?
label := bpb.volumeLabel
if len(label) > 11 {
return nil, fmt.Errorf("invalid volume label: too long at %d characters, maximum is %d", len(label), 11)
}
labelR := []rune(label)
if len(label) != len(labelR) {
return nil, fmt.Errorf("invalid volume label: non-ascii characters")
}
// pad with 0x20 = " "
copy(b[60:71], fmt.Sprintf("%-11s", label))
// do we have a valid filesystem type?
fstype := bpb.fileSystemType
if len(fstype) > 8 {
return nil, fmt.Errorf("invalid filesystem type: too long at %d characters, maximum is %d", len(fstype), 8)
}
fstypeR := []rune(fstype)
if len(fstype) != len(fstypeR) {
return nil, fmt.Errorf("invalid filesystem type: non-ascii characters")
}
// pad with 0x20 = " "
copy(b[71:79], fmt.Sprintf("%-11s", fstype))
default:
return nil, fmt.Errorf("unknown DOS 7.1 EBPB Signature: %v", bpb.extendedBootSignature)
}
// fill in the common parts
dos331Bytes := bpb.dos331BPB.toBytes()
copy(b[0:25], dos331Bytes)
binary.LittleEndian.PutUint32(b[25:29], bpb.sectorsPerFat)
binary.LittleEndian.PutUint16(b[29:31], bpb.mirrorFlags)
binary.LittleEndian.PutUint16(b[31:33], uint16(bpb.version))
binary.LittleEndian.PutUint32(b[33:37], bpb.rootDirectoryCluster)
binary.LittleEndian.PutUint16(b[37:39], bpb.fsInformationSector)
binary.LittleEndian.PutUint16(b[39:41], bpb.backupBootSector)
copy(b[41:53], bpb.bootFileName[:])
b[53] = bpb.driveNumber
b[54] = bpb.reservedFlags
b[55] = bpb.extendedBootSignature
binary.BigEndian.PutUint32(b[56:60], bpb.volumeSerialNumber)
return b, nil
}
07070100000313000081A4000000000000000000000001645E367C000087BF000000000000000000000000000000000000005100000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/fat32.go package fat32
import (
"errors"
"fmt"
"os"
"path"
"sort"
"strings"
"time"
"github.com/diskfs/go-diskfs/filesystem"
"github.com/diskfs/go-diskfs/util"
)
// MsdosMediaType is the (mostly unused) media type. However, we provide and export the known constants for it.
type MsdosMediaType uint8
const (
// Media8InchDrDos for single-sided 250KB DR-DOS disks
Media8InchDrDos MsdosMediaType = 0xe5
// Media525InchTandy for 5.25 inch floppy disks for Tandy
Media525InchTandy MsdosMediaType = 0xed
// MediaCustomPartitionsDrDos for non-standard custom DR-DOS partitions utilizing non-standard BPB formats
MediaCustomPartitionsDrDos MsdosMediaType = 0xee
// MediaCustomSuperFloppyDrDos for non-standard custom superfloppy disks for DR-DOS
MediaCustomSuperFloppyDrDos MsdosMediaType = 0xef
// Media35Inch for standard 1.44MB and 2.88MB 3.5 inch floppy disks
Media35Inch MsdosMediaType = 0xf0
// MediaDoubleDensityAltos for double-density floppy disks for Altos only
MediaDoubleDensityAltos MsdosMediaType = 0xf4
// MediaFixedDiskAltos for fixed disk 1.95MB for Altos only
MediaFixedDiskAltos MsdosMediaType = 0xf5
// MediaFixedDisk for standard fixed disks - can be used for any partitioned fixed or removable media where the geometry is defined in the BPB
MediaFixedDisk MsdosMediaType = 0xf8
)
// SectorSize indicates what the sector size in bytes is
type SectorSize uint16
const (
// SectorSize512 is a sector size of 512 bytes, used as the logical size for all FAT filesystems
SectorSize512 SectorSize = 512
bytesPerSlot int = 32
maxCharsLongFilename int = 13
)
//nolint:deadcode,varcheck,unused // we need these references in the future
const (
minClusterSize int = 128
maxClusterSize int = 65529
)
// FileSystem implememnts the FileSystem interface
type FileSystem struct {
bootSector msDosBootSector
fsis FSInformationSector
table table
dataStart uint32
bytesPerCluster int
size int64
start int64
file util.File
}
// Equal compare if two filesystems are equal
func (fs *FileSystem) Equal(a *FileSystem) bool {
localMatch := fs.file == a.file && fs.dataStart == a.dataStart && fs.bytesPerCluster == a.bytesPerCluster
tableMatch := fs.table.equal(&a.table)
bsMatch := fs.bootSector.equal(&a.bootSector)
fsisMatch := fs.fsis == a.fsis
return localMatch && tableMatch && bsMatch && fsisMatch
}
// Create creates a FAT32 filesystem in a given file or device
//
// requires the util.File where to create the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File to create the filesystem,
// and blocksize is is the logical blocksize to use for creating the filesystem
//
// note that you are *not* required to create the filesystem on the entire disk. You could have a disk of size
// 20GB, and create a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for creating filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 512 bytes. If it is any number other than 0
// or 512, it will return an error.
func Create(f util.File, size, start, blocksize int64, volumeLabel string) (*FileSystem, error) {
// blocksize must be <=0 or exactly SectorSize512 or error
if blocksize != int64(SectorSize512) && blocksize > 0 {
return nil, fmt.Errorf("blocksize for FAT32 must be either 512 bytes or 0, not %d", blocksize)
}
if size > Fat32MaxSize {
return nil, fmt.Errorf("requested size is larger than maximum allowed FAT32, requested %d, maximum %d", size, Fat32MaxSize)
}
if size < blocksize*4 {
return nil, fmt.Errorf("requested size is smaller than minimum allowed FAT32, requested %d minimum %d", size, blocksize*4)
}
// FAT filesystems use time-of-day of creation as a volume ID
now := time.Now()
// because we like the fudges other people did for uniqueness
volid := uint32(now.Unix()<<20 | (now.UnixNano() / 1000000))
fsisPrimarySector := uint16(1)
backupBootSector := uint16(6)
/*
size calculations
we have the total size of the disk from `size uint64`
we have the blocksize fixed at SectorSize512
so we can calculate diskSectors = size/512
we know the number of reserved sectors is 32
so the number of non-reserved sectors: data + FAT = diskSectos - 32
now we need to figure out cluster size. The allowed number of:
sectors per cluster: 1, 2, 4, 8, 16, 32, 64, 128
bytes per cluster: 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536
since FAT32 uses the least significant 28 bits of a 4-byte entry (uint32) as pointers to a cluster,
the maximum cluster pointer address of a FAT32 entry is 268,435,456. However, several
entries are reserved, notably 0x0FFFFFF7-0x0FFFFFFF flag bad cluster to end of file,
0x0000000 flags an empty cluster, and 0x0000001 is not used, so we only have
a potential 268,435,444 pointer entries
the maximum size of a disk for FAT32 is 16 sectors per cluster = 8KB/cluster * 268435444 = ~2TB
Follow Microsoft's `format` commad as per http://www.win.tue.nl/~aeb/linux/fs/fat/fatgen103.pdf p. 20.
Thanks to github.com/dosfstools/dosfstools for the link
Filesystem size / cluster size
<= 260M / 1 sector = 512 bytes
<= 8G / 8 sector = 4096 bytes
<= 16G / 32 sector = 16384 bytes
<= 32G / 64 sector = 32768 bytes
> 32G / 128 sector = 65536 bytes
*/
var sectorsPerCluster uint8
switch {
case size <= 260*MB:
sectorsPerCluster = 1
case size <= 8*GB:
sectorsPerCluster = 8
case size <= 16*GB:
sectorsPerCluster = 32
case size <= 32*GB:
sectorsPerCluster = 64
case size <= Fat32MaxSize:
sectorsPerCluster = 128
}
// stick with uint32 and round down
totalSectors := uint32(size / int64(SectorSize512))
reservedSectors := uint16(32)
dataSectors := totalSectors - uint32(reservedSectors)
totalClusters := dataSectors / uint32(sectorsPerCluster)
// FAT uses 4 bytes per cluster pointer
// so a 512 byte sector can store 512/4 = 128 pointer entries
// therefore sectors per FAT = totalClusters / 128
sectorsPerFat := uint16(totalClusters / 128)
// what is our FAT ID / Media Type?
mediaType := uint8(MediaFixedDisk)
fatIDbase := uint32(0x0f << 24)
fatID := fatIDbase + 0xffff00 + uint32(mediaType)
// we need an Extended BIOS Parameter Block
dos20bpb := dos20BPB{
sectorsPerCluster: sectorsPerCluster,
reservedSectors: reservedSectors,
fatCount: 2,
totalSectors: 0,
mediaType: mediaType,
bytesPerSector: SectorSize512,
rootDirectoryEntries: 0,
sectorsPerFat: 0,
}
// some fake logic for heads, since everything is LBA access anyways
dos331bpb := dos331BPB{
dos20BPB: &dos20bpb,
totalSectors: totalSectors,
heads: 1,
sectorsPerTrack: 1,
hiddenSectors: 0,
}
ebpb := dos71EBPB{
dos331BPB: &dos331bpb,
version: fatVersion0,
rootDirectoryCluster: 2,
fsInformationSector: fsisPrimarySector,
backupBootSector: backupBootSector,
bootFileName: [12]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
extendedBootSignature: longDos71EBPB,
volumeSerialNumber: volid,
volumeLabel: "NO NAME ",
fileSystemType: fileSystemTypeFAT32,
mirrorFlags: 0,
reservedFlags: 0,
driveNumber: 128,
sectorsPerFat: uint32(sectorsPerFat),
}
// we need a new boot sector
bs := msDosBootSector{
oemName: "godiskfs",
jumpInstruction: [3]byte{0xeb, 0x58, 0x90},
bootCode: []byte{},
biosParameterBlock: &ebpb,
}
// create and allocate FAT32 FSInformationSector
fsis := FSInformationSector{
lastAllocatedCluster: 0xffffffff,
freeDataClustersCount: 0xffffffff,
}
// create and allocate the FAT tables
eocMarker := uint32(0x0fffffff)
unusedMarker := uint32(0x00000000)
fatPrimaryStart := reservedSectors * uint16(SectorSize512)
fatSize := uint32(sectorsPerFat) * uint32(SectorSize512)
fatSecondaryStart := uint64(fatPrimaryStart) + uint64(fatSize)
maxCluster := fatSize / 4
rootDirCluster := uint32(2)
fat := table{
fatID: fatID,
eocMarker: eocMarker,
unusedMarker: unusedMarker,
size: fatSize,
rootDirCluster: rootDirCluster,
clusters: map[uint32]uint32{
// when we start, there is just one directory with a single cluster
rootDirCluster: eocMarker,
},
maxCluster: maxCluster,
}
// where does our data start?
dataStart := uint32(fatSecondaryStart) + fatSize
// create the filesystem
fs := &FileSystem{
bootSector: bs,
fsis: fsis,
table: fat,
dataStart: dataStart,
bytesPerCluster: int(sectorsPerCluster) * int(SectorSize512),
start: start,
size: size,
file: f,
}
// write the boot sector
if err := fs.writeBootSector(); err != nil {
return nil, fmt.Errorf("failed to write the boot sector: %v", err)
}
// write the fsis
if err := fs.writeFsis(); err != nil {
return nil, fmt.Errorf("failed to write the file system information sector: %v", err)
}
// write the FAT tables
if err := fs.writeFat(); err != nil {
return nil, fmt.Errorf("failed to write the file allocation table: %v", err)
}
// create root directory
// be sure to zero out the root cluster, so we do not pick up phantom
// entries.
clusterStart := fs.start + int64(fs.dataStart)
// length of cluster in bytes
tmpb := make([]byte, fs.bytesPerCluster)
// zero out the root directory cluster
written, err := f.WriteAt(tmpb, clusterStart)
if err != nil {
return nil, fmt.Errorf("failed to zero out root directory: %v", err)
}
if written != len(tmpb) || written != fs.bytesPerCluster {
return nil, fmt.Errorf("incomplete zero out of root directory, wrote %d bytes instead of expected %d for cluster size %d", written, len(tmpb), fs.bytesPerCluster)
}
// create a volumelabel entry in the root directory
rootDir := &Directory{
directoryEntry: directoryEntry{
clusterLocation: fs.table.rootDirCluster,
isSubdirectory: true,
filesystem: fs,
},
}
// write the root directory entries to disk
err = fs.writeDirectoryEntries(rootDir)
if err != nil {
return nil, fmt.Errorf("error writing root directory to disk: %v", err)
}
// set the volume label
err = fs.SetLabel(volumeLabel)
if err != nil {
return nil, fmt.Errorf("failed to set volume label to '%s': %v", volumeLabel, err)
}
return fs, nil
}
// Read reads a filesystem from a given disk.
//
// requires the util.File where to read the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File the filesystem is expected to begin,
// and blocksize is is the logical blocksize to use for creating the filesystem
//
// note that you are *not* required to read a filesystem on the entire disk. You could have a disk of size
// 20GB, and a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for working with filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 512 bytes. If it is any number other than 0
// or 512, it will return an error.
func Read(file util.File, size, start, blocksize int64) (*FileSystem, error) {
// blocksize must be <=0 or exactly SectorSize512 or error
if blocksize != int64(SectorSize512) && blocksize > 0 {
return nil, fmt.Errorf("blocksize for FAT32 must be either 512 bytes or 0, not %d", blocksize)
}
if size > Fat32MaxSize {
return nil, fmt.Errorf("requested size is larger than maximum allowed FAT32 size %d", Fat32MaxSize)
}
if size < blocksize*4 {
return nil, fmt.Errorf("requested size is smaller than minimum allowed FAT32 size %d", blocksize*4)
}
// load the information from the disk
// read first 512 bytes from the file
bsb := make([]byte, SectorSize512)
n, err := file.ReadAt(bsb, start)
if err != nil {
return nil, fmt.Errorf("could not read bytes from file: %v", err)
}
if uint16(n) < uint16(SectorSize512) {
return nil, fmt.Errorf("only could read %d bytes from file", n)
}
bs, err := msDosBootSectorFromBytes(bsb)
if err != nil {
return nil, fmt.Errorf("error reading MS-DOS Boot Sector: %v", err)
}
sectorsPerFat := bs.biosParameterBlock.sectorsPerFat
fatSize := sectorsPerFat * uint32(SectorSize512)
reservedSectors := bs.biosParameterBlock.dos331BPB.dos20BPB.reservedSectors
sectorsPerCluster := bs.biosParameterBlock.dos331BPB.dos20BPB.sectorsPerCluster
fatPrimaryStart := uint64(reservedSectors) * uint64(SectorSize512)
fatSecondaryStart := fatPrimaryStart + uint64(fatSize)
fsisBytes := make([]byte, 512)
read, err := file.ReadAt(fsisBytes, int64(bs.biosParameterBlock.fsInformationSector)*blocksize+start)
if err != nil {
return nil, fmt.Errorf("unable to read bytes for FSInformationSector: %v", err)
}
if read != 512 {
return nil, fmt.Errorf("read %d bytes instead of expected %d for FS Information Sector", read, 512)
}
fsis, err := fsInformationSectorFromBytes(fsisBytes)
if err != nil {
return nil, fmt.Errorf("error reading FileSystem Information Sector: %v", err)
}
b := make([]byte, fatSize)
_, _ = file.ReadAt(b, int64(fatPrimaryStart)+start)
fat := tableFromBytes(b)
_, _ = file.ReadAt(b, int64(fatSecondaryStart)+start)
fat2 := tableFromBytes(b)
if !fat.equal(fat2) {
return nil, errors.New("fat tables did not much")
}
dataStart := uint32(fatSecondaryStart) + fat.size
return &FileSystem{
bootSector: *bs,
fsis: *fsis,
table: *fat,
dataStart: dataStart,
bytesPerCluster: int(sectorsPerCluster) * int(SectorSize512),
start: start,
size: size,
file: file,
}, nil
}
func (fs *FileSystem) writeBootSector() error {
//nolint:gocritic // we do not want to remove this commented code, as it is useful for reference and debugging
/*
err := bs.write(f)
if err != nil {
return nil, fmt.Errorf("error writing MS-DOS Boot Sector: %v", err)
}
*/
b, err := fs.bootSector.toBytes()
if err != nil {
return fmt.Errorf("error converting MS-DOS Boot Sector to bytes: %v", err)
}
// write main boot sector
count, err := fs.file.WriteAt(b, 0+fs.start)
if err != nil {
return fmt.Errorf("error writing MS-DOS Boot Sector to disk: %v", err)
}
if count != int(SectorSize512) {
return fmt.Errorf("wrote %d bytes of MS-DOS Boot Sector to disk instead of expected %d", count, SectorSize512)
}
// write backup boot sector to the file
if fs.bootSector.biosParameterBlock.backupBootSector > 0 {
count, err = fs.file.WriteAt(b, int64(fs.bootSector.biosParameterBlock.backupBootSector)*int64(SectorSize512)+fs.start)
if err != nil {
return fmt.Errorf("error writing MS-DOS Boot Sector to disk: %v", err)
}
if count != int(SectorSize512) {
return fmt.Errorf("wrote %d bytes of MS-DOS Boot Sector to disk instead of expected %d", count, SectorSize512)
}
}
return nil
}
func (fs *FileSystem) writeFsis() error {
fsInformationSector := fs.bootSector.biosParameterBlock.fsInformationSector
backupBootSector := fs.bootSector.biosParameterBlock.backupBootSector
fsisPrimary := int64(fsInformationSector * uint16(SectorSize512))
fsisBytes := fs.fsis.toBytes()
if _, err := fs.file.WriteAt(fsisBytes, fsisPrimary+fs.start); err != nil {
return fmt.Errorf("unable to write primary Fsis: %v", err)
}
if backupBootSector > 0 {
if _, err := fs.file.WriteAt(fsisBytes, int64(backupBootSector+1)*int64(SectorSize512)+fs.start); err != nil {
return fmt.Errorf("unable to write backup Fsis: %v", err)
}
}
return nil
}
func (fs *FileSystem) writeFat() error {
reservedSectors := fs.bootSector.biosParameterBlock.dos331BPB.dos20BPB.reservedSectors
fatPrimaryStart := uint64(reservedSectors) * uint64(SectorSize512)
fatSecondaryStart := fatPrimaryStart + uint64(fs.table.size)
fatBytes := fs.table.bytes()
if _, err := fs.file.WriteAt(fatBytes, int64(fatPrimaryStart)+fs.start); err != nil {
return fmt.Errorf("unable to write primary FAT table: %v", err)
}
if _, err := fs.file.WriteAt(fatBytes, int64(fatSecondaryStart)+fs.start); err != nil {
return fmt.Errorf("unable to write backup FAT table: %v", err)
}
return nil
}
// Type returns the type code for the filesystem. Always returns filesystem.TypeFat32
func (fs *FileSystem) Type() filesystem.Type {
return filesystem.TypeFat32
}
// Mkdir make a directory at the given path. It is equivalent to `mkdir -p`, i.e. idempotent, in that:
//
// * It will make the entire tree path if it does not exist
// * It will not return an error if the path already exists
func (fs *FileSystem) Mkdir(p string) error {
_, _, err := fs.readDirWithMkdir(p, true)
// we are not interesting in returning the entries
return err
}
// ReadDir return the contents of a given directory in a given filesystem.
//
// Returns a slice of os.FileInfo with all of the entries in the directory.
//
// Will return an error if the directory does not exist or is a regular file and not a directory
func (fs *FileSystem) ReadDir(p string) ([]os.FileInfo, error) {
_, entries, err := fs.readDirWithMkdir(p, false)
if err != nil {
return nil, fmt.Errorf("error reading directory %s: %v", p, err)
}
// once we have made it here, looping is done. We have found the final entry
// we need to return all of the file info
count := len(entries)
ret := make([]os.FileInfo, count)
for i, e := range entries {
shortName := e.filenameShort
if e.lowercaseShortname {
shortName = strings.ToLower(shortName)
}
fileExtension := e.fileExtension
if e.lowercaseExtension {
shortName = strings.ToLower(fileExtension)
}
if fileExtension != "" {
shortName = fmt.Sprintf("%s.%s", shortName, fileExtension)
}
ret[i] = FileInfo{
modTime: e.modifyTime,
name: e.filenameLong,
shortName: shortName,
size: int64(e.fileSize),
isDir: e.isSubdirectory,
}
}
return ret, nil
}
// OpenFile returns an io.ReadWriter from which you can read the contents of a file
// or write contents to the file
//
// accepts normal os.OpenFile flags
//
// returns an error if the file does not exist
func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
// get the path
dir := path.Dir(p)
filename := path.Base(p)
// if the dir == filename, then it is just /
if dir == filename {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
// get the directory entries
parentDir, entries, err := fs.readDirWithMkdir(dir, false)
if err != nil {
return nil, fmt.Errorf("could not read directory entries for %s", dir)
}
// we now know that the directory exists, see if the file exists
var targetEntry *directoryEntry
for _, e := range entries {
shortName := e.filenameShort
if e.fileExtension != "" {
shortName += "." + e.fileExtension
}
if e.filenameLong != filename && shortName != filename {
continue
}
// cannot do anything with directories
if e.isSubdirectory {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
// if we got this far, we have found the file
targetEntry = e
}
// see if the file exists
// if the file does not exist, and is not opened for os.O_CREATE, return an error
if targetEntry == nil {
if flag&os.O_CREATE == 0 {
return nil, fmt.Errorf("target file %s does not exist and was not asked to create", p)
}
// else create it
targetEntry, err = fs.mkFile(parentDir, filename)
if err != nil {
return nil, fmt.Errorf("failed to create file %s: %v", p, err)
}
// write the directory entries to disk
err = fs.writeDirectoryEntries(parentDir)
if err != nil {
return nil, fmt.Errorf("error writing directory file %s to disk: %v", p, err)
}
}
offset := int64(0)
// what if we were asked to truncate the file?
if flag&os.O_TRUNC == os.O_TRUNC && targetEntry.fileSize != 0 {
// pretty simple: change the filesize, and then remove all except the first cluster
targetEntry.fileSize = 0
// we should not need to change the parent, because it is all pointers
if err := fs.writeDirectoryEntries(parentDir); err != nil {
return nil, fmt.Errorf("error writing directory file %s to disk: %v", p, err)
}
if _, err := fs.allocateSpace(1, targetEntry.clusterLocation); err != nil {
return nil, fmt.Errorf("unable to resize cluster list: %v", err)
}
}
if flag&os.O_APPEND == os.O_APPEND {
offset = int64(targetEntry.fileSize)
}
return &File{
directoryEntry: targetEntry,
isReadWrite: flag&os.O_RDWR != 0,
isAppend: flag&os.O_APPEND != 0,
offset: offset,
filesystem: fs,
parent: parentDir,
}, nil
}
// Label get the label of the filesystem from the secial file in the root directory.
// The label stored in the boot sector is ignored to mimic Windows behavior which
// only stores and reads the label from the special file in the root directory.
func (fs *FileSystem) Label() string {
// locate the filesystem root directory
_, dirEntries, err := fs.readDirWithMkdir("/", false)
if err != nil {
return ""
}
// locate the label entry, it may not exist
var labelEntry *directoryEntry
for _, entry := range dirEntries {
if entry.isVolumeLabel {
labelEntry = entry
}
}
// if we have no label entry, return
if labelEntry == nil {
return ""
}
// reconstruct the label, does not attempt to sanitize anything
return labelEntry.filenameShort + labelEntry.fileExtension
}
// SetLabel changes the filesystem label
func (fs *FileSystem) SetLabel(volumeLabel string) error {
if volumeLabel == "" {
volumeLabel = "NO NAME"
}
// ensure the volumeLabel is proper sized
volumeLabel = fmt.Sprintf("%-11.11s", volumeLabel)
// set the label in the superblock
bpb := fs.bootSector.biosParameterBlock
if bpb == nil {
return fmt.Errorf("failed to load the boot sector")
}
bpb.volumeLabel = volumeLabel
// write the boot sector
if err := fs.writeBootSector(); err != nil {
return fmt.Errorf("failed to write the boot sector")
}
// locate the filesystem root directory or create it
rootDir, dirEntries, err := fs.readDirWithMkdir("/", false)
if err != nil {
return fmt.Errorf("failed to locate root directory: %v", err)
}
// locate the label entry, it may not exist
var labelEntry *directoryEntry
for _, entry := range dirEntries {
if entry.isVolumeLabel {
labelEntry = entry
}
}
// if have an entry, change the label. Otherwise, create it
if labelEntry != nil {
labelEntry.filenameShort = volumeLabel[:8]
labelEntry.fileExtension = volumeLabel[8:11]
} else {
_, err = fs.mkLabel(rootDir, volumeLabel)
if err != nil {
return fmt.Errorf("failed to create volume label root directory entry '%s': %v", volumeLabel, err)
}
}
// write the root directory entries to disk
err = fs.writeDirectoryEntries(rootDir)
if err != nil {
return fmt.Errorf("failed to save the root directory to disk: %v", err)
}
return nil
}
// read directory entries for a given cluster
func (fs *FileSystem) getClusterList(firstCluster uint32) ([]uint32, error) {
// first, get the chain of clusters
complete := false
cluster := firstCluster
clusters := fs.table.clusters
// do we even have a valid cluster?
if _, ok := clusters[cluster]; !ok {
return nil, fmt.Errorf("invalid start cluster: %d", cluster)
}
clusterList := make([]uint32, 0, 5)
for !complete {
// save the current cluster
clusterList = append(clusterList, cluster)
// get the next cluster
newCluster := clusters[cluster]
// if it is EOC, we are done
switch {
case fs.table.isEoc(newCluster):
complete = true
case cluster < 2:
return nil, fmt.Errorf("invalid cluster chain at %d", cluster)
}
cluster = newCluster
}
return clusterList, nil
}
// read directory entries for a given cluster
func (fs *FileSystem) readDirectory(dir *Directory) ([]*directoryEntry, error) {
clusterList, err := fs.getClusterList(dir.clusterLocation)
if err != nil {
return nil, fmt.Errorf("could not read cluster list: %v", err)
}
// read the data from all of the cluster entries in the list
byteCount := len(clusterList) * fs.bytesPerCluster
b := make([]byte, 0, byteCount)
for _, cluster := range clusterList {
// bytes where the cluster starts
clusterStart := fs.start + int64(fs.dataStart) + int64(cluster-2)*int64(fs.bytesPerCluster)
// length of cluster in bytes
tmpb := make([]byte, fs.bytesPerCluster)
// read the entire cluster
_, _ = fs.file.ReadAt(tmpb, clusterStart)
b = append(b, tmpb...)
}
// get the directory
if err := dir.entriesFromBytes(b); err != nil {
return nil, err
}
return dir.entries, nil
}
// make a subdirectory
func (fs *FileSystem) mkSubdir(parent *Directory, name string) (*directoryEntry, error) {
// get a cluster chain for the file
clusters, err := fs.allocateSpace(1, 0)
if err != nil {
return nil, fmt.Errorf("could not allocate disk space for file %s: %v", name, err)
}
// create a directory entry for the file
return parent.createEntry(name, clusters[0], true)
}
func (fs *FileSystem) writeDirectoryEntries(dir *Directory) error {
// we need to save the entries of theparent
b, err := dir.entriesToBytes(fs.bytesPerCluster)
if err != nil {
return fmt.Errorf("could not create a valid byte stream for a FAT32 Entries: %v", err)
}
// now have to expand with zeros to the a multiple of cluster lengths
// how many clusters do we need, how many do we have?
clusterList, err := fs.getClusterList(dir.clusterLocation)
if err != nil {
return fmt.Errorf("unable to get clusters for directory: %v", err)
}
if len(b) > len(clusterList)*fs.bytesPerCluster {
clusters, err := fs.allocateSpace(uint64(len(b)), clusterList[0])
if err != nil {
return fmt.Errorf("unable to allocate space for directory entries: %v", err)
}
clusterList = clusters
}
// now write everything out to the cluster list
// read the data from all of the cluster entries in the list
for i, cluster := range clusterList {
// bytes where the cluster starts
clusterStart := fs.start + int64(fs.dataStart) + int64(cluster-2)*int64(fs.bytesPerCluster)
bStart := i * fs.bytesPerCluster
written, err := fs.file.WriteAt(b[bStart:bStart+fs.bytesPerCluster], clusterStart)
if err != nil {
return fmt.Errorf("error writing directory entries: %v", err)
}
if written != fs.bytesPerCluster {
return fmt.Errorf("wrote %d bytes to cluster %d instead of expected %d", written, cluster, fs.bytesPerCluster)
}
}
return nil
}
// mkFile make a file in a directory
func (fs *FileSystem) mkFile(parent *Directory, name string) (*directoryEntry, error) {
// get a cluster chain for the file
clusters, err := fs.allocateSpace(1, 0)
if err != nil {
return nil, fmt.Errorf("could not allocate disk space for directory %s: %v", name, err)
}
// create a directory entry for the file
return parent.createEntry(name, clusters[0], false)
}
// mkLabel make a volume label in a directory
func (fs *FileSystem) mkLabel(parent *Directory, name string) (*directoryEntry, error) {
// create a directory entry for the file
return parent.createVolumeLabel(name)
}
// readDirWithMkdir - walks down a directory tree to the last entry
// if it does not exist, it may or may not make it
func (fs *FileSystem) readDirWithMkdir(p string, doMake bool) (*Directory, []*directoryEntry, error) {
paths, err := splitPath(p)
if err != nil {
return nil, nil, err
}
// walk down the directory tree until all paths have been walked or we cannot find something
// start with the root directory
var entries []*directoryEntry
currentDir := &Directory{
directoryEntry: directoryEntry{
clusterLocation: fs.table.rootDirCluster,
isSubdirectory: true,
filesystem: fs,
},
}
entries, err = fs.readDirectory(currentDir)
if err != nil {
return nil, nil, fmt.Errorf("failed to read directory %s", "/")
}
for i, subp := range paths {
// do we have an entry whose name is the same as this name?
found := false
for _, e := range entries {
if e.filenameLong != subp && e.filenameShort != subp && (!e.lowercaseShortname || (e.lowercaseShortname && !strings.EqualFold(e.filenameShort, subp))) {
continue
}
if !e.isSubdirectory {
return nil, nil, fmt.Errorf("cannot create directory at %s since it is a file", "/"+strings.Join(paths[0:i+1], "/"))
}
// the filename matches, and it is a subdirectory, so we can break after saving the cluster
found = true
currentDir = &Directory{
directoryEntry: *e,
}
break
}
// if not, either make it, retrieve its cluster and entries, and loop;
// or error out
if !found {
if doMake {
var subdirEntry *directoryEntry
subdirEntry, err = fs.mkSubdir(currentDir, subp)
if err != nil {
return nil, nil, fmt.Errorf("failed to create subdirectory %s", "/"+strings.Join(paths[0:i+1], "/"))
}
// make a basic entry for the new subdir
parentDirectoryCluster := currentDir.clusterLocation
if parentDirectoryCluster == 2 {
// references to the root directory (cluster 2) must be stored as 0
parentDirectoryCluster = 0
}
dir := &Directory{
directoryEntry: directoryEntry{clusterLocation: subdirEntry.clusterLocation},
entries: []*directoryEntry{
{filenameShort: ".", isSubdirectory: true, clusterLocation: subdirEntry.clusterLocation},
{filenameShort: "..", isSubdirectory: true, clusterLocation: parentDirectoryCluster},
},
}
// write the new directory entries to disk
err = fs.writeDirectoryEntries(dir)
if err != nil {
return nil, nil, fmt.Errorf("error writing new directory entries to disk: %v", err)
}
// write the parent directory entries to disk
err = fs.writeDirectoryEntries(currentDir)
if err != nil {
return nil, nil, fmt.Errorf("error writing directory entries to disk: %v", err)
}
// save where we are to search next
currentDir = &Directory{
directoryEntry: *subdirEntry,
}
} else {
return nil, nil, fmt.Errorf("path %s not found", "/"+strings.Join(paths[0:i+1], "/"))
}
}
// get all of the entries in this directory
entries, err = fs.readDirectory(currentDir)
if err != nil {
return nil, nil, fmt.Errorf("failed to read directory %s", "/"+strings.Join(paths[0:i+1], "/"))
}
}
// once we have made it here, looping is done; we have found the final entry
return currentDir, entries, nil
}
// allocateSpace ensure that a cluster chain exists to handle a file of a given size.
// arguments are file size in bytes and starting cluster of the chain
// if starting is 0, then we are not (re)sizing an existing chain but creating a new one
// returns the indexes of clusters to be used in order. If the new size is smaller than
// the original size, will shrink the chain.
func (fs *FileSystem) allocateSpace(size uint64, previous uint32) ([]uint32, error) {
var (
clusters []uint32
err error
lastAllocatedCluster uint32
)
// 1- calculate how many clusters needed
// 2- see how many clusters already are allocated
// 3- if needed, allocate new clusters and extend the chain in the FAT table
keys := make([]uint32, 0, 20)
allocated := make([]uint32, 0, 20)
// what is the total count of clusters needed?
count := int(size / uint64(fs.bytesPerCluster))
if size%uint64(fs.bytesPerCluster) > 0 {
count++
}
extraClusterCount := count
clusters = make([]uint32, 0, 20)
// are we extending an existing chain, or creating a new one?
if previous >= 2 {
clusters, err = fs.getClusterList(previous)
if err != nil {
return nil, fmt.Errorf("unable to get cluster list: %v", err)
}
originalClusterCount := len(clusters)
extraClusterCount = count - originalClusterCount
// make sure that previous is the last cluster of the previous chain
previous = clusters[len(clusters)-1]
}
// what if we do not need to change anything?
if extraClusterCount == 0 {
return clusters, nil
}
// get a list of allocated clusters, so we can know which ones are unallocated and therefore allocatable
allClusters := fs.table.clusters
maxCluster := fs.table.maxCluster
for k := range allClusters {
keys = append(keys, k)
}
sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
if extraClusterCount > 0 {
for i := uint32(2); i < maxCluster && len(allocated) < extraClusterCount; i++ {
if _, ok := allClusters[i]; !ok {
// these become the same at this point
allocated = append(allocated, i)
}
}
// did we allocate them all?
if len(allocated) < extraClusterCount {
return nil, errors.New("no space left on device")
}
// mark last allocated one as EOC
lastAlloc := len(allocated) - 1
// extend the chain and fill them in
if previous > 0 {
allClusters[previous] = allocated[0]
}
for i := 0; i < lastAlloc; i++ {
allClusters[allocated[i]] = allocated[i+1]
}
allClusters[allocated[lastAlloc]] = fs.table.eocMarker
// update the FSIS
lastAllocatedCluster = allocated[len(allocated)-1]
} else {
var (
lastAlloc int
deallocated []uint32
)
toRemove := abs(extraClusterCount)
lastAlloc = len(clusters) - toRemove - 1
if lastAlloc < 0 {
lastAlloc = 0
}
deallocated = clusters[lastAlloc+1:]
// mark last allocated one as EOC
allClusters[clusters[lastAlloc]] = fs.table.eocMarker
// unmark all of the unused ones
lastAllocatedCluster = fs.fsis.lastAllocatedCluster
for _, cl := range deallocated {
allClusters[cl] = fs.table.unusedMarker
if cl == lastAllocatedCluster {
lastAllocatedCluster--
}
}
}
// update the FSIS
fs.fsis.lastAllocatedCluster = lastAllocatedCluster
if err := fs.writeFsis(); err != nil {
return nil, fmt.Errorf("failed to write the file system information sector: %v", err)
}
// write the FAT tables
if err := fs.writeFat(); err != nil {
return nil, fmt.Errorf("failed to write the file allocation table: %v", err)
}
// return all of the clusters
return append(clusters, allocated...), nil
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
}
07070100000314000081A4000000000000000000000001645E367C000016CE000000000000000000000000000000000000005000000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/file.go package fat32
import (
"fmt"
"io"
"os"
)
// File represents a single file in a FAT32 filesystem
type File struct {
*directoryEntry
isReadWrite bool
isAppend bool
offset int64
parent *Directory
filesystem *FileSystem
}
// Read reads up to len(b) bytes from the File.
// It returns the number of bytes read and any error encountered.
// At end of file, Read returns 0, io.EOF
// reads from the last known offset in the file from last read or write
// and increments the offset by the number of bytes read.
// Use Seek() to set at a particular point
func (fl *File) Read(b []byte) (int, error) {
if fl == nil || fl.filesystem == nil {
return 0, os.ErrClosed
}
// we have the DirectoryEntry, so we can get the starting cluster location
// we then get a list of the clusters, and read the data from all of those clusters
// write the content for the file
totalRead := 0
fs := fl.filesystem
bytesPerCluster := fs.bytesPerCluster
start := int(fs.dataStart)
size := int(fl.fileSize) - int(fl.offset)
maxRead := size
file := fs.file
clusters, err := fs.getClusterList(fl.clusterLocation)
if err != nil {
return totalRead, fmt.Errorf("unable to get list of clusters for file: %v", err)
}
clusterIndex := 0
// if there is nothing left to read, just return EOF
if size <= 0 {
return totalRead, io.EOF
}
// we stop when we hit the lesser of
// 1- len(b)
// 2- file end
if len(b) < maxRead {
maxRead = len(b)
}
// figure out which cluster we start with
if fl.offset > 0 {
clusterIndex = int(fl.offset / int64(bytesPerCluster))
lastCluster := clusters[clusterIndex]
// read any partials, if needed
remainder := fl.offset % int64(bytesPerCluster)
if remainder != 0 {
offset := int64(start) + int64(lastCluster-2)*int64(bytesPerCluster) + remainder
toRead := int64(bytesPerCluster) - remainder
if toRead > int64(len(b)) {
toRead = int64(len(b))
}
_, _ = file.ReadAt(b[0:toRead], offset+fs.start)
totalRead += int(toRead)
clusterIndex++
}
}
for i := clusterIndex; i < len(clusters); i++ {
left := maxRead - totalRead
toRead := bytesPerCluster
if toRead > left {
toRead = left
}
offset := uint32(start) + (clusters[i]-2)*uint32(bytesPerCluster)
_, _ = file.ReadAt(b[totalRead:totalRead+toRead], int64(offset)+fs.start)
totalRead += toRead
if totalRead >= maxRead {
break
}
}
fl.offset += int64(totalRead)
var retErr error
if fl.offset >= int64(fl.fileSize) {
retErr = io.EOF
}
return totalRead, retErr
}
// Write writes len(b) bytes to the File.
// It returns the number of bytes written and an error, if any.
// returns a non-nil error when n != len(b)
// writes to the last known offset in the file from last read or write
// and increments the offset by the number of bytes read.
// Use Seek() to set at a particular point
func (fl *File) Write(p []byte) (int, error) {
if fl == nil || fl.filesystem == nil {
return 0, os.ErrClosed
}
totalWritten := 0
fs := fl.filesystem
// if the file was not opened RDWR, nothing we can do
if !fl.isReadWrite {
return totalWritten, fmt.Errorf("cannot write to file opened read-only")
}
// what is the new file size?
writeSize := len(p)
oldSize := int64(fl.fileSize)
newSize := fl.offset + int64(writeSize)
if newSize < oldSize {
newSize = oldSize
}
// 1- ensure we have space and clusters
clusters, err := fs.allocateSpace(uint64(newSize), fl.clusterLocation)
if err != nil {
return 0x00, fmt.Errorf("unable to allocate clusters for file: %v", err)
}
// update the directory entry size for the file
if oldSize != newSize {
fl.fileSize = uint32(newSize)
}
// write the content for the file
bytesPerCluster := fl.filesystem.bytesPerCluster
file := fl.filesystem.file
start := int(fl.filesystem.dataStart)
clusterIndex := 0
// figure out which cluster we start with
if fl.offset > 0 {
clusterIndex = int(fl.offset) / bytesPerCluster
lastCluster := clusters[clusterIndex]
// write any partials, if needed
remainder := fl.offset % int64(bytesPerCluster)
if remainder != 0 {
offset := int64(start) + int64(lastCluster-2)*int64(bytesPerCluster) + remainder
toWrite := int64(bytesPerCluster) - remainder
// max we can write
if toWrite > int64(len(p)) {
toWrite = int64(len(p))
}
_, err := file.WriteAt(p[0:toWrite], offset+fs.start)
if err != nil {
return totalWritten, fmt.Errorf("unable to write to file: %v", err)
}
totalWritten += int(toWrite)
clusterIndex++
}
}
for i := clusterIndex; i < len(clusters); i++ {
left := len(p) - totalWritten
toWrite := bytesPerCluster
if toWrite > left {
toWrite = left
}
offset := uint32(start) + (clusters[i]-2)*uint32(bytesPerCluster)
_, err := file.WriteAt(p[totalWritten:totalWritten+toWrite], int64(offset)+fs.start)
if err != nil {
return totalWritten, fmt.Errorf("unable to write to file: %v", err)
}
totalWritten += toWrite
}
fl.offset += int64(totalWritten)
// update the parent that we have changed the file size
err = fs.writeDirectoryEntries(fl.parent)
if err != nil {
return 0, fmt.Errorf("error writing directory entries to disk: %v", err)
}
return totalWritten, nil
}
// Seek set the offset to a particular point in the file
func (fl *File) Seek(offset int64, whence int) (int64, error) {
if fl == nil || fl.filesystem == nil {
return 0, os.ErrClosed
}
newOffset := int64(0)
switch whence {
case io.SeekStart:
newOffset = offset
case io.SeekEnd:
newOffset = int64(fl.fileSize) + offset
case io.SeekCurrent:
newOffset = fl.offset + offset
}
if newOffset < 0 {
return fl.offset, fmt.Errorf("cannot set offset %d before start of file", offset)
}
fl.offset = newOffset
return fl.offset, nil
}
// Close close the file
func (fl *File) Close() error {
fl.filesystem = nil
return nil
}
07070100000315000081A4000000000000000000000001645E367C00000457000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/fileinfo.go package fat32
import (
"os"
"time"
)
// FileInfo represents the information for an individual file
// it fulfills os.FileInfo interface
type FileInfo struct {
modTime time.Time
mode os.FileMode
name string
shortName string
size int64
isDir bool
}
// IsDir abbreviation for Mode().IsDir()
func (fi FileInfo) IsDir() bool {
return fi.isDir
}
// ModTime modification time
func (fi FileInfo) ModTime() time.Time {
return fi.modTime
}
// Mode returns file mode
func (fi FileInfo) Mode() os.FileMode {
return fi.mode
}
// Name base name of the file
//
// will return the long name of the file. If none exists, returns the shortname and extension
func (fi FileInfo) Name() string {
if fi.name != "" {
return fi.name
}
return fi.shortName
}
// ShortName just the 8.3 short name of the file
func (fi FileInfo) ShortName() string {
return fi.shortName
}
// Size length in bytes for regular files
func (fi FileInfo) Size() int64 {
return fi.size
}
// Sys underlying data source - not supported yet and so will return nil
func (fi FileInfo) Sys() interface{} {
return nil
}
07070100000316000081A4000000000000000000000001645E367C00000C7B000000000000000000000000000000000000005800000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/fsinfosector.go package fat32
import (
"encoding/binary"
"fmt"
)
// FSInfoSectorSignature is the signature for every FAT32 FSInformationSector
type fsInfoSectorSignature uint32
const (
// FSInfoSectorSignatureStart is the 4 bytes that signify the beginning of a FAT32 FS Information Sector
fsInfoSectorSignatureStart fsInfoSectorSignature = 0x52526141
// FSInfoSectorSignatureMid is the 4 bytes that signify the middle bytes 484-487 of a FAT32 FS Information Sector
fsInfoSectorSignatureMid fsInfoSectorSignature = 0x72724161
// FSInfoSectorSignatureEnd is the 4 bytes that signify the end of a FAT32 FS Information Sector
fsInfoSectorSignatureEnd fsInfoSectorSignature = 0x000055AA
)
const (
// unknownFreeDataClusterCount is the fixed flag for unknown number of free data clusters
//nolint:varcheck,deadcode // keep for future reference
unknownFreeDataClusterCount uint32 = 0xffffffff
// unknownlastAllocatedCluster is the fixed flag for unknown most recently allocated cluster
//nolint:varcheck,deadcode // keep for future reference
unknownlastAllocatedCluster uint32 = 0xffffffff
)
// FSInformationSector is a structure holding the FAT32 filesystem information sector
type FSInformationSector struct {
freeDataClustersCount uint32
lastAllocatedCluster uint32
}
// FSInformationSectorFromBytes create an FSInformationSector struct from bytes
func fsInformationSectorFromBytes(b []byte) (*FSInformationSector, error) {
bLen := len(b)
if bLen != int(SectorSize512) {
return nil, fmt.Errorf("cannot read FAT32 FS Information Sector from %d bytes instead of expected %d", bLen, SectorSize512)
}
fsis := FSInformationSector{}
// validate the signatures
signatureStart := binary.BigEndian.Uint32(b[0:4])
signatureMid := binary.BigEndian.Uint32(b[484:488])
signatureEnd := binary.BigEndian.Uint32(b[508:512])
if signatureStart != uint32(fsInfoSectorSignatureStart) {
return nil, fmt.Errorf("invalid signature at beginning of FAT 32 Filesystem Information Sector: %x", signatureStart)
}
if signatureMid != uint32(fsInfoSectorSignatureMid) {
return nil, fmt.Errorf("invalid signature at middle of FAT 32 Filesystem Information Sector: %x", signatureMid)
}
if signatureEnd != uint32(fsInfoSectorSignatureEnd) {
return nil, fmt.Errorf("invalid signature at end of FAT 32 Filesystem Information Sector: %x", signatureEnd)
}
// validated, so just read the data
fsis.freeDataClustersCount = binary.LittleEndian.Uint32(b[488:492])
fsis.lastAllocatedCluster = binary.LittleEndian.Uint32(b[492:496])
return &fsis, nil
}
// ToBytes returns a FAT32 Filesystem Information Sector ready to be written to disk
func (fsis *FSInformationSector) toBytes() []byte {
b := make([]byte, SectorSize512)
// signatures
binary.BigEndian.PutUint32(b[0:4], uint32(fsInfoSectorSignatureStart))
binary.BigEndian.PutUint32(b[484:488], uint32(fsInfoSectorSignatureMid))
binary.BigEndian.PutUint32(b[508:512], uint32(fsInfoSectorSignatureEnd))
// reserved 0x00
// these are set to 0 by default, so not much to do
// actual data
binary.LittleEndian.PutUint32(b[488:492], fsis.freeDataClustersCount)
binary.LittleEndian.PutUint32(b[492:496], fsis.lastAllocatedCluster)
return b
}
07070100000317000081A4000000000000000000000001645E367C00000CAB000000000000000000000000000000000000005B00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/msdosbootsector.go package fat32
import (
"bytes"
"encoding/binary"
"fmt"
)
// MsDosBootSectorSignature is the required last 2 bytes of the MS-DOS boot sector
const msDosBootSectorSignature uint16 = 0x55aa
// MsDosBootSector is the structure representing an msdos boot structure
type msDosBootSector struct {
jumpInstruction [3]byte // JumpInstruction is the instruction set to jump to for booting
oemName string // OEMName is the 8-byte OEM Name
biosParameterBlock *dos71EBPB // BIOSParameterBlock is the FAT32 Extended BIOS Parameter Block
bootCode []byte // BootCode represents the actual boot code
}
func (m *msDosBootSector) equal(a *msDosBootSector) bool {
if (m == nil && a != nil) || (a == nil && m != nil) {
return false
}
if m == nil && a == nil {
return true
}
return m.biosParameterBlock.equal(a.biosParameterBlock) &&
m.oemName == a.oemName &&
m.jumpInstruction == a.jumpInstruction &&
bytes.Equal(m.bootCode, a.bootCode)
}
// MsDosBootSectorFromBytes create an MsDosBootSector from a byte slice
func msDosBootSectorFromBytes(b []byte) (*msDosBootSector, error) {
if len(b) != int(SectorSize512) {
return nil, fmt.Errorf("cannot parse MS-DOS Boot Sector from %d bytes, must be exactly %d", len(b), SectorSize512)
}
bs := msDosBootSector{}
// extract the jump instruction
copy(bs.jumpInstruction[:], b[0:3])
// extract the OEM name
bs.oemName = string(b[3:11])
// extract the EBPB and its size
bpb, bpbSize, err := dos71EBPBFromBytes(b[11:90])
if err != nil {
return nil, fmt.Errorf("could not read FAT32 BIOS Parameter Block from boot sector: %v", err)
}
bs.biosParameterBlock = bpb
// we have the size of the EBPB, we can figure out the size of the boot code
bootSectorStart := 11 + bpbSize
bootSectorEnd := SectorSize512 - 2
bs.bootCode = b[bootSectorStart:bootSectorEnd]
// validate boot sector signature
if bsSignature := binary.BigEndian.Uint16(b[bootSectorEnd:]); bsSignature != msDosBootSectorSignature {
return nil, fmt.Errorf("invalid signature in last 2 bytes of boot sector: %v", bsSignature)
}
return &bs, nil
}
// ToBytes output a byte slice representing the boot sector
func (m *msDosBootSector) toBytes() ([]byte, error) {
// exactly one sector
b := make([]byte, SectorSize512)
// copy the 3-byte jump instruction
copy(b[0:3], m.jumpInstruction[:])
// make sure OEMName is <= 8 bytes
name := m.oemName
if len(name) > 8 {
return nil, fmt.Errorf("cannot use OEM Name > 8 bytes long: %s", m.oemName)
}
nameR := []rune(name)
if len(nameR) != len(name) {
return nil, fmt.Errorf("invalid OEM Name: non-ascii characters")
}
oemName := fmt.Sprintf("%-8s", m.oemName)
copy(b[3:11], oemName)
// bytes for the EBPB
bpbBytes, err := m.biosParameterBlock.toBytes()
if err != nil {
return nil, fmt.Errorf("error getting FAT32 EBPB: %v", err)
}
copy(b[11:], bpbBytes)
bpbLen := len(bpbBytes)
// bytes for the boot sector
if len(m.bootCode) > int(SectorSize512)-2-(11+bpbLen) {
return nil, fmt.Errorf("boot code too long at %d bytes", len(m.bootCode))
}
copy(b[11+bpbLen:SectorSize512-2], m.bootCode)
// bytes for the signature
binary.BigEndian.PutUint16(b[SectorSize512-2:], msDosBootSectorSignature)
return b, nil
}
07070100000318000081A4000000000000000000000001645E367C000007DB000000000000000000000000000000000000005100000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/table.go package fat32
import (
"encoding/binary"
"reflect"
)
// table a FAT32 table
type table struct {
fatID uint32
eocMarker uint32
unusedMarker uint32
clusters map[uint32]uint32
rootDirCluster uint32
size uint32
maxCluster uint32
}
func (t *table) equal(a *table) bool {
if (t == nil && a != nil) || (t != nil && a == nil) {
return false
}
if t == nil && a == nil {
return true
}
return t.fatID == a.fatID &&
t.eocMarker == a.eocMarker &&
t.rootDirCluster == a.rootDirCluster &&
t.size == a.size &&
t.maxCluster == a.maxCluster &&
reflect.DeepEqual(t.clusters, a.clusters)
}
/*
when reading from disk, remember that *any* of the following is a valid eocMarker:
0x?ffffff8 - 0x?fffffff
*/
func tableFromBytes(b []byte) *table {
t := table{
fatID: binary.LittleEndian.Uint32(b[0:4]),
eocMarker: binary.LittleEndian.Uint32(b[4:8]),
size: uint32(len(b)),
clusters: map[uint32]uint32{},
maxCluster: uint32(len(b) / 4),
rootDirCluster: 2, // always 2 for FAT32
}
// just need to map the clusters in
for i := uint32(2); i < t.maxCluster; i++ {
bStart := i * 4
bEnd := bStart + 4
val := binary.LittleEndian.Uint32(b[bStart:bEnd])
// 0 indicates an empty cluster, so we can ignore
if val != 0 {
t.clusters[i] = val
}
}
return &t
}
// bytes returns a FAT32 table as bytes ready to be written to disk
func (t *table) bytes() []byte {
b := make([]byte, t.size)
// FAT ID and fixed values
binary.LittleEndian.PutUint32(b[0:4], t.fatID)
// End-of-Cluster marker
binary.LittleEndian.PutUint32(b[4:8], t.eocMarker)
// now just clusters
numClusters := t.maxCluster
for i := uint32(2); i < numClusters; i++ {
bStart := i * 4
bEnd := bStart + 4
val := uint32(0)
if cluster, ok := t.clusters[i]; ok {
val = cluster
}
binary.LittleEndian.PutUint32(b[bStart:bEnd], val)
}
return b
}
func (t *table) isEoc(cluster uint32) bool {
return cluster&0xFFFFFF8 == 0xFFFFFF8
}
07070100000319000081A4000000000000000000000001645E367C000003A3000000000000000000000000000000000000005000000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/fat32/util.go package fat32
import (
"errors"
"strings"
)
const (
// KB represents one KB
KB int64 = 1024
// MB represents one MB
MB int64 = 1024 * KB
// GB represents one GB
GB int64 = 1024 * MB
// TB represents one TB
TB int64 = 1024 * GB
// Fat32MaxSize is maximum size of a FAT32 filesystem in bytes
Fat32MaxSize int64 = 2198754099200
)
func universalizePath(p string) (string, error) {
// globalize the separator
ps := strings.ReplaceAll(p, "\\", "/")
if ps[0] != '/' {
return "", errors.New("must use absolute paths")
}
return ps, nil
}
func splitPath(p string) ([]string, error) {
ps, err := universalizePath(p)
if err != nil {
return nil, err
}
// we need to split such that each one ends in "/", except possibly the last one
parts := strings.Split(ps, "/")
// eliminate empty parts
ret := make([]string, 0)
for _, sub := range parts {
if sub != "" {
ret = append(ret, sub)
}
}
return ret, nil
}
0707010000031A000081A4000000000000000000000001645E367C000000A5000000000000000000000000000000000000004A00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/file.go package filesystem
import "io"
// File a reference to a single file on disk
type File interface {
io.ReadWriteSeeker
io.Closer
// io.ReaderAt
// io.WriterAt
}
0707010000031B000081A4000000000000000000000001645E367C000004B7000000000000000000000000000000000000005000000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/filesystem.go // Package filesystem provides interfaces and constants required for filesystem implementations.
// All interesting implementations are in subpackages, e.g. github.com/diskfs/go-diskfs/filesystem/fat32
package filesystem
import (
"os"
)
// FileSystem is a reference to a single filesystem on a disk
type FileSystem interface {
// Type return the type of filesystem
Type() Type
// Mkdir make a directory
Mkdir(string) error
// ReadDir read the contents of a directory
ReadDir(string) ([]os.FileInfo, error)
// OpenFile open a handle to read or write to a file
OpenFile(string, int) (File, error)
// Label get the label for the filesystem, or "" if none. Be careful to trim it, as it may contain
// leading or following whitespace. The label is passed as-is and not cleaned up at all.
Label() string
// SetLabel changes the label on the writable filesystem. Different file system may hav different
// length constraints.
SetLabel(string) error
}
// Type represents the type of disk this is
type Type int
const (
// TypeFat32 is a FAT32 compatible filesystem
TypeFat32 Type = iota
// TypeISO9660 is an iso filesystem
TypeISO9660
// TypeSquashfs is a squashfs filesystem
TypeSquashfs
)
0707010000031C000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004A00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660 0707010000031D000081A4000000000000000000000001645E367C000005A7000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/directory.go package iso9660
// Directory represents a single directory in a FAT32 filesystem
type Directory struct {
directoryEntry
entries []*directoryEntry
}
// dirEntriesFromBytes loads the directory entries from the raw bytes
func (d *Directory) entriesFromBytes(b []byte, f *FileSystem) error {
entries, err := parseDirEntries(b, f)
if err != nil {
return err
}
d.entries = entries
return nil
}
// entriesToBytes convert our entries to raw bytes
func (d *Directory) entriesToBytes(ceBlockLocations []uint32) ([][]byte, error) {
b := make([]byte, 0)
ceBlocks := make([][]byte, 0)
blocksize := int(d.filesystem.blocksize)
for _, de := range d.entries {
b2, err := de.toBytes(false, ceBlockLocations)
if err != nil {
return nil, err
}
recBytes := b2[0]
// a directory entry cannot cross a block boundary
// so if adding this puts us past it, then pad it
// but only if we are not already exactly at the boundary
newlength := len(b) + len(recBytes)
left := blocksize - len(b)%blocksize
if left != 0 && newlength/blocksize > len(b)/blocksize {
b = append(b, make([]byte, left)...)
}
b = append(b, recBytes...)
if len(b2) > 1 {
ceBlocks = append(ceBlocks, b2[1:]...)
}
}
// in the end, must pad to exact blocks
left := blocksize - len(b)%blocksize
if left > 0 {
b = append(b, make([]byte, left)...)
}
ret := [][]byte{b}
if len(ceBlocks) > 0 {
ret = append(ret, ceBlocks...)
}
return ret, nil
}
0707010000031E000081A4000000000000000000000001645E367C0000473E000000000000000000000000000000000000005C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/directoryentry.go package iso9660
import (
"encoding/binary"
"errors"
"fmt"
"os"
"path"
"regexp"
"strings"
"time"
)
const (
directoryEntryMinSize uint8 = 34 // min size is all the required fields (33 bytes) plus 1 byte for the filename
directoryEntryMaxSize int = 254 // max size allowed
)
// directoryEntry is a single directory entry
// also fulfills os.FileInfo
//
// Name() string // base name of the file
// Size() int64 // length in bytes for regular files; system-dependent for others
// Mode() FileMode // file mode bits
// ModTime() time.Time // modification time
// IsDir() bool // abbreviation for Mode().IsDir()
// Sys() interface{} // underlying data source (can return nil)
type directoryEntry struct {
extAttrSize uint8
location uint32
size uint32
creation time.Time
isHidden bool
isSubdirectory bool
isAssociated bool
hasExtendedAttrs bool
hasOwnerGroupPermissions bool
hasMoreEntries bool
isSelf bool
isParent bool
volumeSequence uint16
filesystem *FileSystem
filename string
extensions []directoryEntrySystemUseExtension
}
func (de *directoryEntry) countNamelenBytes() int {
// size includes the ";1" at the end as two bytes if a filename
var namelen int
switch {
case de.isSelf:
namelen = 1
case de.isParent:
namelen = 1
default:
namelen = len(de.filename)
}
return namelen
}
func (de *directoryEntry) countBaseBytes() int {
namelen := de.countNamelenBytes()
// if even, we add one byte of padding to always end on an even byte
if namelen%2 == 0 {
namelen++
}
return 33 + namelen
}
func (de *directoryEntry) toBytes(skipExt bool, ceBlocks []uint32) ([][]byte, error) {
baseRecordSize := de.countBaseBytes()
namelen := de.countNamelenBytes()
b := make([]byte, baseRecordSize)
b[1] = de.extAttrSize
binary.LittleEndian.PutUint32(b[2:6], de.location)
binary.BigEndian.PutUint32(b[6:10], de.location)
binary.LittleEndian.PutUint32(b[10:14], de.size)
binary.BigEndian.PutUint32(b[14:18], de.size)
copy(b[18:25], timeToBytes(de.creation))
// set the flags
var flagByte byte = 0x00
if de.isHidden {
flagByte |= 0x01
}
if de.isSubdirectory {
flagByte |= 0x02
}
if de.isAssociated {
flagByte |= 0x04
}
if de.hasExtendedAttrs {
flagByte |= 0x08
}
if de.hasOwnerGroupPermissions {
flagByte |= 0x10
}
if de.hasMoreEntries {
flagByte |= 0x80
}
b[25] = flagByte
// volume sequence number - uint16 in both endian
binary.LittleEndian.PutUint16(b[28:30], de.volumeSequence)
binary.BigEndian.PutUint16(b[30:32], de.volumeSequence)
b[32] = uint8(namelen)
// save the filename
var filenameBytes []byte
var err error
switch {
case de.isSelf:
filenameBytes = []byte{0x00}
case de.isParent:
filenameBytes = []byte{0x01}
default:
// first validate the filename
err = validateFilename(de.filename, de.isSubdirectory)
if err != nil {
nametype := "filename"
if de.isSubdirectory {
nametype = "directory"
}
return nil, fmt.Errorf("invalid %s %s: %v", nametype, de.filename, err)
}
filenameBytes, err = stringToASCIIBytes(de.filename)
if err != nil {
return nil, fmt.Errorf("error converting filename to bytes: %v", err)
}
}
// copy it over
copy(b[33:], filenameBytes)
// output directory entry extensions - but only if we did not skip it
var extBytes [][]byte
if !skipExt {
extBytes, err = dirEntryExtensionsToBytes(de.extensions, directoryEntryMaxSize-len(b), de.filesystem.blocksize, ceBlocks)
if err != nil {
return nil, fmt.Errorf("enable to convert directory entry SUSP extensions to bytes: %v", err)
}
b = append(b, extBytes[0]...)
}
// always end on an even
if len(b)%2 != 0 {
b = append(b, 0x00)
}
// update the record size
b[0] = uint8(len(b))
recWithCE := [][]byte{b}
if len(extBytes) > 1 {
recWithCE = append(recWithCE, extBytes[1:]...)
}
return recWithCE, nil
}
// dirEntryExtensionsToBytes converts slice of SUSP extensions to slice ot []byte: first is dir entry, rest are continuation areas
// returns:
//
// slice of []byte
func dirEntryExtensionsToBytes(extensions []directoryEntrySystemUseExtension, maxSize int, blocksize int64, ceBlocks []uint32) ([][]byte, error) {
// output directory entries
var (
err error
b []byte
continuedBytes [][]byte
)
ret := make([][]byte, 0)
for i, e := range extensions {
b2 := e.Bytes()
// do we overrun the size
if len(b)+len(b2) > maxSize {
// we need an extension, so pop the first one off the slice, use it as a pointer, and pass the rest
nextCeBlock := ceBlocks[0]
continuedBytes, err = dirEntryExtensionsToBytes(extensions[i:], int(blocksize), blocksize, ceBlocks[1:])
if err != nil {
return nil, err
}
// use a continuation entry until the end of the
ce := &directoryEntrySystemUseContinuation{
offset: 0,
location: nextCeBlock,
continuationLength: uint32(len(continuedBytes[0])),
}
b = append(b, ce.Bytes()...)
break
} else {
b = append(b, b2...)
}
}
ret = append(ret, b)
if len(continuedBytes) > 0 {
ret = append(ret, continuedBytes...)
}
return ret, nil
}
func dirEntryFromBytes(b []byte, ext []suspExtension) (*directoryEntry, error) {
// has to be at least 34 bytes
if len(b) < int(directoryEntryMinSize) {
return nil, fmt.Errorf("cannot read directoryEntry from %d bytes, fewer than minimum of %d bytes", len(b), directoryEntryMinSize)
}
recordSize := b[0]
// what if it is not the right size?
if len(b) != int(recordSize) {
return nil, fmt.Errorf("directoryEntry should be size %d bytes according to first byte, but have %d bytes", recordSize, len(b))
}
extAttrSize := b[1]
location := binary.LittleEndian.Uint32(b[2:6])
size := binary.LittleEndian.Uint32(b[10:14])
creation := bytesToTime(b[18:25])
// get the flags
flagByte := b[25]
isHidden := flagByte&0x01 == 0x01
isSubdirectory := flagByte&0x02 == 0x02
isAssociated := flagByte&0x04 == 0x04
hasExtendedAttrs := flagByte&0x08 == 0x08
hasOwnerGroupPermissions := flagByte&0x10 == 0x10
hasMoreEntries := flagByte&0x80 == 0x80
volumeSequence := binary.LittleEndian.Uint16(b[28:30])
// size includes the ";1" at the end as two bytes and any padding
namelen := b[32]
nameLenWithPadding := namelen
// get the filename itself
nameBytes := b[33 : 33+namelen]
if namelen > 1 && namelen%2 == 0 {
nameLenWithPadding++
}
var filename string
var isSelf, isParent bool
switch {
case namelen == 1 && nameBytes[0] == 0x00:
filename = ""
isSelf = true
case namelen == 1 && nameBytes[0] == 0x01:
filename = ""
isParent = true
default:
filename = string(nameBytes)
}
// and now for extensions in the system use area
suspFields := make([]directoryEntrySystemUseExtension, 0)
if len(b) > 33+int(nameLenWithPadding) {
var err error
suspFields, err = parseDirectoryEntryExtensions(b[33+nameLenWithPadding:], ext)
if err != nil {
return nil, fmt.Errorf("unable to parse directory entry extensions: %v", err)
}
}
return &directoryEntry{
extAttrSize: extAttrSize,
location: location,
size: size,
creation: creation,
isHidden: isHidden,
isSubdirectory: isSubdirectory,
isAssociated: isAssociated,
hasExtendedAttrs: hasExtendedAttrs,
hasOwnerGroupPermissions: hasOwnerGroupPermissions,
hasMoreEntries: hasMoreEntries,
isSelf: isSelf,
isParent: isParent,
volumeSequence: volumeSequence,
filename: filename,
extensions: suspFields,
}, nil
}
// parseDirEntry takes the bytes of a single directory entry
// and parses it, including pulling in continuation entry bytes
func parseDirEntry(b []byte, f *FileSystem) (*directoryEntry, error) {
// empty entry means nothing more to read - this might not actually be accurate, but work with it for now
if len(b) < 1 {
return nil, errors.New("cannot parse zero length directory entry")
}
entryLen := int(b[0])
if entryLen == 0 {
return nil, nil
}
// get the bytes
de, err := dirEntryFromBytes(b[:entryLen], f.suspExtensions)
if err != nil {
return nil, fmt.Errorf("invalid directory entry : %v", err)
}
de.filesystem = f
if f.suspEnabled && len(de.extensions) > 0 {
// if the last entry is a continuation SUSP entry and SUSP is enabled, we need to follow and parse them
// because the extensions can be a linked list directory -> CE area -> CE area ...
// we need to loop until it is no more
for {
if ce, ok := de.extensions[len(de.extensions)-1].(directoryEntrySystemUseContinuation); ok {
location := int64(ce.Location())
size := int(ce.ContinuationLength())
offset := int64(ce.Offset())
// read it from disk
continuationBytes := make([]byte, size)
read, err := f.file.ReadAt(continuationBytes, location*f.blocksize+offset)
if err != nil {
return nil, fmt.Errorf("error reading continuation entry data at %d: %v", location, err)
}
if read != size {
return nil, fmt.Errorf("read continuation entry data %d bytes instead of expected %d", read, size)
}
// parse and append
entries, err := parseDirectoryEntryExtensions(continuationBytes, f.suspExtensions)
if err != nil {
return nil, fmt.Errorf("error parsing continuation entry data at %d: %v", location, err)
}
// remove the CE one from the extensions array and append our new ones
de.extensions = append(de.extensions[:len(de.extensions)-1], entries...)
} else {
break
}
}
}
return de, nil
}
// parseDirEntries takes all of the bytes in a special file (i.e. a directory)
// and gets all of the DirectoryEntry for that directory
// this is, essentially, the equivalent of `ls -l` or if you prefer `dir`
func parseDirEntries(b []byte, f *FileSystem) ([]*directoryEntry, error) {
dirEntries := make([]*directoryEntry, 0, 20)
count := 0
for i := 0; i < len(b); count++ {
// empty entry means nothing more to read - this might not actually be accurate, but work with it for now
entryLen := int(b[i+0])
if entryLen == 0 {
i += (int(f.blocksize) - i%int(f.blocksize))
continue
}
de, err := parseDirEntry(b[i+0:i+entryLen], f)
if err != nil {
return nil, fmt.Errorf("invalid directory entry %d at byte %d: %v", count, i, err)
}
// some extensions to directory relocation, so check if we should ignore it
if f.suspEnabled {
for _, e := range f.suspExtensions {
if e.Relocated(de) {
de = nil
break
}
}
}
if de != nil {
dirEntries = append(dirEntries, de)
}
i += entryLen
}
return dirEntries, nil
}
// get the location of a particular path relative to this directory
func (de *directoryEntry) getLocation(p string) (location, size uint32, err error) {
// break path down into parts and levels
parts := splitPath(p)
if len(parts) == 0 {
location = de.location
size = de.size
} else {
current := parts[0]
// read the directory bytes
dirb := make([]byte, de.size)
n, err := de.filesystem.file.ReadAt(dirb, int64(de.location)*de.filesystem.blocksize)
if err != nil {
return 0, 0, fmt.Errorf("could not read directory: %v", err)
}
if n != len(dirb) {
return 0, 0, fmt.Errorf("read %d bytes instead of expected %d", n, len(dirb))
}
// parse those entries
dirEntries, err := parseDirEntries(dirb, de.filesystem)
if err != nil {
return 0, 0, fmt.Errorf("could not parse directory: %v", err)
}
// find the entry among the children that has the desired name
for _, entry := range dirEntries {
// do we have an alternate name?
// only care if not self or parent entry
checkFilename := entry.filename
if de.filesystem.suspEnabled && !entry.isSelf && !entry.isParent {
for _, e := range de.filesystem.suspExtensions {
filename, err2 := e.GetFilename(entry)
switch {
case err2 != nil && err2 == ErrSuspFilenameUnsupported:
continue
case err2 != nil:
return 0, 0, fmt.Errorf("extension %s count not find a filename property: %v", e.ID(), err2)
default:
checkFilename = filename
//nolint:gosimple // redundant break, but we want this explicit
break
}
}
}
if checkFilename == current {
if len(parts) > 1 {
// just dig down further - what if it looks like a file, but is a relocated directory?
if !entry.isSubdirectory && de.filesystem.suspEnabled && !entry.isSelf && !entry.isParent {
for _, e := range de.filesystem.suspExtensions {
location2 := e.GetDirectoryLocation(entry)
if location2 != 0 {
// need to get the directory entry for the child
dirb := make([]byte, de.filesystem.blocksize)
n, err2 := de.filesystem.file.ReadAt(dirb, int64(location2)*de.filesystem.blocksize)
if err2 != nil {
return 0, 0, fmt.Errorf("could not read bytes of relocated directory %s from block %d: %v", checkFilename, location2, err2)
}
if n != len(dirb) {
return 0, 0, fmt.Errorf("read %d bytes instead of expected %d for relocated directory %s from block %d: %v", n, len(dirb), checkFilename, location2, err)
}
// get the size of the actual directory entry
size2 := dirb[0]
entry, err2 = parseDirEntry(dirb[:size2], de.filesystem)
if err2 != nil {
return 0, 0, fmt.Errorf("error converting bytes to a directory entry for relocated directory %s from block %d: %v", checkFilename, location2, err2)
}
break
}
}
}
location, size, err = entry.getLocation(path.Join(parts[1:]...))
if err != nil {
return 0, 0, fmt.Errorf("could not get location: %v", err)
}
} else {
// this is the final one, we found it, keep it
location = entry.location
size = entry.size
}
break
}
}
}
return location, size, nil
}
// Name() string // base name of the file
func (de *directoryEntry) Name() string {
name := de.filename
if de.filesystem.suspEnabled {
for _, e := range de.filesystem.suspExtensions {
filename, err := e.GetFilename(de)
switch {
case err != nil:
continue
default:
name = filename
//nolint:gosimple // redundant break, but we want this explicit
break
}
}
}
// check if we have an extension that overrides it
// filenames should have the ';1' stripped off, as well as the leading or trailing '.'
if !de.IsDir() {
name = strings.TrimSuffix(name, ";1")
name = strings.TrimSuffix(name, ".")
name = strings.TrimPrefix(name, ".")
}
return name
}
// Size() int64 // length in bytes for regular files; system-dependent for others
func (de *directoryEntry) Size() int64 {
return int64(de.size)
}
// Mode() FileMode // file mode bits
func (de *directoryEntry) Mode() os.FileMode {
return 0o755
}
// ModTime() time.Time // modification time
func (de *directoryEntry) ModTime() time.Time {
return de.creation
}
// IsDir() bool // abbreviation for Mode().IsDir()
func (de *directoryEntry) IsDir() bool {
return de.isSubdirectory
}
// Sys() interface{} // underlying data source (can return nil)
func (de *directoryEntry) Sys() interface{} {
return nil
}
// utilities
func bytesToTime(b []byte) time.Time {
year := int(b[0])
month := time.Month(b[1])
date := int(b[2])
hour := int(b[3])
minute := int(b[4])
second := int(b[5])
offset := int(int8(b[6]))
location := time.FixedZone("iso", offset*15*60)
return time.Date(year+1900, month, date, hour, minute, second, 0, location)
}
func timeToBytes(t time.Time) []byte {
year := t.Year()
month := t.Month()
date := t.Day()
second := t.Second()
minute := t.Minute()
hour := t.Hour()
_, offset := t.Zone()
b := make([]byte, 7)
b[0] = byte(year - 1900)
b[1] = byte(month)
b[2] = byte(date)
b[3] = byte(hour)
b[4] = byte(minute)
b[5] = byte(second)
b[6] = byte(int8(offset / 60 / 15))
return b
}
// convert a string to ascii bytes, but only accept valid d-characters
func validateFilename(s string, isDir bool) error {
var err error
if isDir {
// directory only allowed up to 8 characters of A-Z,0-9,_
re := regexp.MustCompile("^[A-Z0-9_]{1,30}$")
if !re.MatchString(s) {
err = fmt.Errorf("directory name must be of up to 30 characters from A-Z0-9_")
}
} else {
// filename only allowed up to 8 characters of A-Z,0-9,_, plus an optional '.' plus up to 3 characters of A-Z,0-9,_, plus must have ";1"
re := regexp.MustCompile("^[A-Z0-9_]+(.[A-Z0-9_]*)?;1$")
switch {
case !re.MatchString(s):
err = fmt.Errorf("file name must be of characters from A-Z0-9_, followed by an optional '.' and an extension of the same characters")
case len(strings.ReplaceAll(s, ".", "")) > 30:
err = fmt.Errorf("file name must be at most 30 characters, not including the separator '.'")
}
}
return err
}
// convert a string to a byte array, if all characters are valid ascii
func stringToASCIIBytes(s string) ([]byte, error) {
length := len(s)
b := make([]byte, length)
// convert the name into 11 bytes
r := []rune(s)
// take the first 8 characters
for i := 0; i < length; i++ {
val := int(r[i])
// we only can handle values less than max byte = 255
if val > 255 {
return nil, fmt.Errorf("non-ASCII character in name: %s", s)
}
b[i] = byte(val)
}
return b, nil
}
// converts a string into upper-case with only valid characters
func uCaseValid(name string) string {
// easiest way to do this is to go through the name one char at a time
r := []rune(name)
r2 := make([]rune, 0, len(r))
for _, val := range r {
switch {
case (0x30 <= val && val <= 0x39) || (0x41 <= val && val <= 0x5a) || (val == 0x7e):
// naturally valid characters
r2 = append(r2, val)
case (0x61 <= val && val <= 0x7a):
// lower-case characters should be upper-cased
r2 = append(r2, val-32)
case val == ' ' || val == '.':
// remove spaces and periods
continue
default:
// replace the rest with _
r2 = append(r2, '_')
}
}
return string(r2)
}
0707010000031F000081A4000000000000000000000001645E367C00004923000000000000000000000000000000000000006E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/directoryentrysystemuseextension.go package iso9660
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
)
const (
suspExtensionContinuationArea = "CE"
suspExtensionPaddingField = "PD"
suspExtensionSharingProtocolIndicator = "SP"
suspExtensionSharingProtocolTerminator = "ST"
suspExtensionExtensionsReference = "ER"
suspExtensionExtensionsSelector = "ES"
suspExtensionCheckBytes = 0xbeef
)
var (
// ErrSuspNoHandler error to show gracefully that we do not have a handler for this signature. Opposed to processing error
ErrSuspNoHandler = errors.New("NoHandler")
// ErrSuspFilenameUnsupported error to show that this extension does not support searching by path
ErrSuspFilenameUnsupported = errors.New("FilenameUnsupported")
// ErrSuspRelocatedDirectoryUnsupported error to indicate that this extension does not support relocated directories
ErrSuspRelocatedDirectoryUnsupported = errors.New("relocatedDirectoryUnsupported")
)
// suspExtension master for an extension that is registered with an "ER" entry
type suspExtension interface {
ID() string
Process(string, []byte) (directoryEntrySystemUseExtension, error)
GetFilename(*directoryEntry) (string, error)
Relocated(*directoryEntry) bool
UsePathtable() bool
GetDirectoryLocation(*directoryEntry) uint32
Descriptor() string
Source() string
Version() uint8
GetFileExtensions(string, bool, bool) ([]directoryEntrySystemUseExtension, error)
GetFinalizeExtensions(*finalizeFileInfo) ([]directoryEntrySystemUseExtension, error)
Relocatable() bool
Relocate(map[string]*finalizeFileInfo) ([]*finalizeFileInfo, map[string]*finalizeFileInfo, error)
}
type directoryEntrySystemUseExtension interface {
Equal(directoryEntrySystemUseExtension) bool
Signature() string
Length() int
Version() uint8
Data() []byte
Bytes() []byte
Continuable() bool // if this one is continuable to the next one of the same signature
Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension // merge
}
// directoryEntrySystemUseExtensionRaw raw holder, common to all
type directoryEntrySystemUseExtensionRaw struct {
signature string
length uint8
version uint8
data []byte
}
func (d directoryEntrySystemUseExtensionRaw) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseExtensionRaw)
return ok && t.signature == d.signature && t.length == d.length && t.version == d.version && bytes.Equal(d.data, t.data)
}
func (d directoryEntrySystemUseExtensionRaw) Signature() string {
return d.signature
}
func (d directoryEntrySystemUseExtensionRaw) Length() int {
return int(d.length)
}
func (d directoryEntrySystemUseExtensionRaw) Version() uint8 {
return d.version
}
func (d directoryEntrySystemUseExtensionRaw) Data() []byte {
return d.data
}
func (d directoryEntrySystemUseExtensionRaw) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], d.Signature())
ret[2] = d.length
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseExtensionRaw) Continuable() bool {
return false
}
func (d directoryEntrySystemUseExtensionRaw) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionRaw(b []byte) directoryEntrySystemUseExtension {
size := len(b)
signature := string(b[:2])
version := b[3]
data := make([]byte, 0)
if size > 4 {
data = b[4:]
}
return directoryEntrySystemUseExtensionRaw{
signature: signature,
length: uint8(size),
version: version,
data: data,
}
}
// directoryEntrySystemUseExtensionSharingProtocolIndicator single appearance in root entry
type directoryEntrySystemUseExtensionSharingProtocolIndicator struct {
skipBytes uint8
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseExtensionSharingProtocolIndicator)
return ok && t == d
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Signature() string {
return suspExtensionSharingProtocolIndicator
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Length() int {
return 7
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Data() []byte {
ret := make([]byte, 3)
binary.BigEndian.PutUint16(ret[0:2], suspExtensionCheckBytes)
ret[2] = d.skipBytes
return ret
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionSharingProtocolIndicator)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) SkipBytes() uint8 {
return d.skipBytes
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Continuable() bool {
return false
}
func (d directoryEntrySystemUseExtensionSharingProtocolIndicator) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionSharingProtocolIndicator(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 7
if len(b) != targetSize {
return nil, fmt.Errorf("SP extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
return nil, fmt.Errorf("SP extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("SP extension must be version 1, was %d", version)
}
checkBytes := binary.BigEndian.Uint16(b[4:6])
if checkBytes != suspExtensionCheckBytes {
return nil, fmt.Errorf("SP extension must had mismatched check bytes, received % x instead of % x", checkBytes, suspExtensionCheckBytes)
}
return directoryEntrySystemUseExtensionSharingProtocolIndicator{
skipBytes: b[6],
}, nil
}
// directoryEntrySystemUseExtensionPadding padding
type directoryEntrySystemUseExtensionPadding struct {
length uint8
}
func (d directoryEntrySystemUseExtensionPadding) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseExtensionPadding)
return ok && t == d
}
func (d directoryEntrySystemUseExtensionPadding) Signature() string {
return suspExtensionPaddingField
}
func (d directoryEntrySystemUseExtensionPadding) Length() int {
return int(d.length)
}
func (d directoryEntrySystemUseExtensionPadding) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseExtensionPadding) Data() []byte {
ret := make([]byte, d.Length()-4)
return ret
}
func (d directoryEntrySystemUseExtensionPadding) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionPaddingField)
ret[2] = d.length
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseExtensionPadding) Continuable() bool {
return false
}
func (d directoryEntrySystemUseExtensionPadding) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionPadding(b []byte) (directoryEntrySystemUseExtension, error) {
size := b[2]
if int(size) != len(b) {
return nil, fmt.Errorf("PD extension received %d bytes, but byte 2 indicated %d", len(b), size)
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("PD extension must be version 1, was %d", version)
}
return directoryEntrySystemUseExtensionPadding{
length: size,
}, nil
}
// directoryEntrySystemUseTerminator termination
type directoryEntrySystemUseTerminator struct {
}
func (d directoryEntrySystemUseTerminator) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseTerminator)
return ok && t == d
}
func (d directoryEntrySystemUseTerminator) Signature() string {
return suspExtensionSharingProtocolTerminator
}
func (d directoryEntrySystemUseTerminator) Length() int {
return 4
}
func (d directoryEntrySystemUseTerminator) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseTerminator) Data() []byte {
return []byte{}
}
func (d directoryEntrySystemUseTerminator) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionSharingProtocolTerminator)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
return ret
}
func (d directoryEntrySystemUseTerminator) Continuable() bool {
return false
}
func (d directoryEntrySystemUseTerminator) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionTerminator(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 4
if len(b) != targetSize {
return nil, fmt.Errorf("ST extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
return nil, fmt.Errorf("ST extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("ST extension must be version 1, was %d", version)
}
return directoryEntrySystemUseTerminator{}, nil
}
// directoryEntrySystemUseContinuation termination
type directoryEntrySystemUseContinuation struct {
location uint32
offset uint32
continuationLength uint32
}
func (d directoryEntrySystemUseContinuation) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseContinuation)
return ok && t == d
}
func (d directoryEntrySystemUseContinuation) Signature() string {
return suspExtensionContinuationArea
}
func (d directoryEntrySystemUseContinuation) Length() int {
return 28
}
func (d directoryEntrySystemUseContinuation) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseContinuation) Data() []byte {
b := make([]byte, 24)
binary.LittleEndian.PutUint32(b[0:4], d.location)
binary.BigEndian.PutUint32(b[4:8], d.location)
binary.LittleEndian.PutUint32(b[8:12], d.offset)
binary.BigEndian.PutUint32(b[12:16], d.offset)
binary.LittleEndian.PutUint32(b[16:20], d.continuationLength)
binary.BigEndian.PutUint32(b[20:24], d.continuationLength)
return b
}
func (d directoryEntrySystemUseContinuation) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionContinuationArea)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseContinuation) Location() uint32 {
return d.location
}
func (d directoryEntrySystemUseContinuation) Offset() uint32 {
return d.offset
}
func (d directoryEntrySystemUseContinuation) ContinuationLength() uint32 {
return d.continuationLength
}
func (d directoryEntrySystemUseContinuation) Continuable() bool {
return false
}
func (d directoryEntrySystemUseContinuation) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionContinuationArea(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 28
if len(b) != targetSize {
return nil, fmt.Errorf("CE extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
return nil, fmt.Errorf("CE extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("CE extension must be version 1, was %d", version)
}
location := binary.LittleEndian.Uint32(b[4:8])
offset := binary.LittleEndian.Uint32(b[12:16])
continuationLength := binary.LittleEndian.Uint32(b[20:24])
return directoryEntrySystemUseContinuation{
location: location,
offset: offset,
continuationLength: continuationLength,
}, nil
}
// directoryEntrySystemUseExtensionSelector termination
type directoryEntrySystemUseExtensionSelector struct {
sequence uint8
}
func (d directoryEntrySystemUseExtensionSelector) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseExtensionSelector)
return ok && t == d
}
func (d directoryEntrySystemUseExtensionSelector) Signature() string {
return suspExtensionExtensionsSelector
}
func (d directoryEntrySystemUseExtensionSelector) Length() int {
return 5
}
func (d directoryEntrySystemUseExtensionSelector) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseExtensionSelector) Data() []byte {
return []byte{d.sequence}
}
func (d directoryEntrySystemUseExtensionSelector) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionExtensionsSelector)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseExtensionSelector) Sequence() uint8 {
return d.sequence
}
func (d directoryEntrySystemUseExtensionSelector) Continuable() bool {
return false
}
func (d directoryEntrySystemUseExtensionSelector) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionExtensionsSelector(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 5
if len(b) != targetSize {
return nil, fmt.Errorf("ES extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
return nil, fmt.Errorf("ES extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("ES extension must be version 1, was %d", version)
}
sequence := b[4]
return directoryEntrySystemUseExtensionSelector{
sequence: sequence,
}, nil
}
// directoryEntrySystemUseExtensionReference termination
type directoryEntrySystemUseExtensionReference struct {
id string
descriptor string
source string
extensionVersion uint8
}
func (d directoryEntrySystemUseExtensionReference) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(directoryEntrySystemUseExtensionReference)
return ok && t == d
}
func (d directoryEntrySystemUseExtensionReference) Signature() string {
return suspExtensionExtensionsReference
}
func (d directoryEntrySystemUseExtensionReference) Length() int {
return 8 + len(d.id) + len(d.descriptor) + len(d.source)
}
func (d directoryEntrySystemUseExtensionReference) Version() uint8 {
return 1
}
func (d directoryEntrySystemUseExtensionReference) Data() []byte {
ret := make([]byte, 4)
ret[0] = uint8(len(d.id))
ret[1] = uint8(len(d.descriptor))
ret[2] = uint8(len(d.source))
ret[3] = d.extensionVersion
ret = append(ret, []byte(d.id)...)
ret = append(ret, []byte(d.descriptor)...)
ret = append(ret, []byte(d.source)...)
return ret
}
func (d directoryEntrySystemUseExtensionReference) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], suspExtensionExtensionsReference)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d directoryEntrySystemUseExtensionReference) ExtensionVersion() uint8 {
return d.extensionVersion
}
func (d directoryEntrySystemUseExtensionReference) ExtensionID() string {
return d.id
}
func (d directoryEntrySystemUseExtensionReference) ExtensionDescriptor() string {
return d.descriptor
}
func (d directoryEntrySystemUseExtensionReference) ExtensionSource() string {
return d.source
}
func (d directoryEntrySystemUseExtensionReference) Continuable() bool {
return false
}
func (d directoryEntrySystemUseExtensionReference) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func parseSystemUseExtensionExtensionsReference(b []byte) (directoryEntrySystemUseExtension, error) {
size := b[2]
if len(b) != int(size) {
return nil, fmt.Errorf("ER extension byte 2 indicated size of %d bytes, but received %d", size, len(b))
}
version := b[3]
if version != 1 {
return nil, fmt.Errorf("EE extension must be version 1, was %d", version)
}
idSize := int(b[4])
descriptorSize := int(b[5])
sourceSize := int(b[6])
extVersion := b[7]
idStart := 8
descriptorStart := 8 + idSize
sourceStart := 8 + idSize + descriptorSize
id := string(b[idStart : idStart+idSize])
descriptor := string(b[descriptorStart : descriptorStart+descriptorSize])
source := string(b[sourceStart : sourceStart+sourceSize])
return directoryEntrySystemUseExtensionReference{
id: id,
descriptor: descriptor,
source: source,
extensionVersion: extVersion,
}, nil
}
var suspExtensionParser = map[string]func([]byte) (directoryEntrySystemUseExtension, error){
// base extensions
suspExtensionSharingProtocolIndicator: parseSystemUseExtensionSharingProtocolIndicator,
suspExtensionSharingProtocolTerminator: parseSystemUseExtensionTerminator,
suspExtensionExtensionsSelector: parseSystemUseExtensionExtensionsSelector,
suspExtensionExtensionsReference: parseSystemUseExtensionExtensionsReference,
suspExtensionPaddingField: parseSystemUseExtensionPadding,
suspExtensionContinuationArea: parseSystemUseExtensionContinuationArea,
}
// parseDirectoryEntryExtensions parse system use extensions area of a directory entry
func parseDirectoryEntryExtensions(b []byte, handlers []suspExtension) ([]directoryEntrySystemUseExtension, error) {
// and now for extensions in the system use area
entries := make([]directoryEntrySystemUseExtension, 0)
lastEntryBySignature := map[string]directoryEntrySystemUseExtension{}
// minimum size of 4 bytes for any SUSP entry
for i := 0; i+4 < len(b); {
// get the indicator
signature := string(b[i : i+2])
size := b[i+2]
suspBytes := b[i : i+int(size)]
var (
entry directoryEntrySystemUseExtension
err error
)
// if we have a parser, use it, else use the raw parser
if parser, ok := suspExtensionParser[signature]; ok {
entry, err = parser(suspBytes)
if err != nil {
return nil, fmt.Errorf("error parsing %s extension at byte position %d: %v", signature, i, err)
}
} else {
// go through each extension we have and see if it can process
for _, ext := range handlers {
entry, err = ext.Process(signature, suspBytes)
if err != nil && err != ErrSuspNoHandler {
return nil, fmt.Errorf("SUSP Extension handler %s error processing extension %s: %v", ext.ID(), signature, err)
}
if err == nil {
break
}
}
if entry == nil {
entry = parseSystemUseExtensionRaw(suspBytes)
}
}
// we now have the entry - see if there was a prior continuable one
if last, ok := lastEntryBySignature[signature]; ok {
entry = last.Merge([]directoryEntrySystemUseExtension{entry})
if entry.Continuable() {
lastEntryBySignature[signature] = entry
} else {
delete(lastEntryBySignature, signature)
}
}
entries = append(entries, entry)
i += int(size)
}
return entries, nil
}
07070100000320000081A4000000000000000000000001645E367C0000020B000000000000000000000000000000000000005100000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/doc.go // Package iso9660 provides utilities to interact with, manipulate and create an iso9660 filesystem on a block device or
// a disk image.
//
// Reference documentation
//
// ISO9660 https://wiki.osdev.org/ISO_9660
// ISO9660 / ECMA-119 http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-119.pdf
// System Use Sharing Protocol http://cdrtools.sourceforge.net/private/RRIP/susp.ps
// Rock Ridge http://cdrtools.sourceforge.net/private/RRIP/rrip.ps
// El Torito https://wiki.osdev.org/El-Torito
package iso9660
07070100000321000081A4000000000000000000000001645E367C000014B2000000000000000000000000000000000000005600000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/eltorito.go package iso9660
import (
"encoding/binary"
"fmt"
"io"
"os"
"github.com/diskfs/go-diskfs/partition/mbr"
"github.com/diskfs/go-diskfs/util"
)
//nolint:deadcode,varcheck,unused // we need these references in the future
const (
elToritoSector = 0x11
elToritoDefaultBlocks = 4
)
// Platform target booting system for a bootable iso
type Platform uint8
const (
// BIOS classic PC-BIOS x86
BIOS Platform = 0x0
// PPC PowerPC
PPC Platform = 0x1
// Mac some Macintosh system,s
Mac Platform = 0x2
// EFI newer extensible firmware interface
EFI Platform = 0xef
// default name for a boot catalog
elToritoDefaultCatalog = "BOOT.CAT"
elToritoDefaultCatalogRR = "boot.catalog"
)
// Emulation what emulation should be used for booting, normally none
type Emulation uint8
const (
// NoEmulation do not do any emulation, the normal mode
NoEmulation Emulation = 0
// Floppy12Emulation emulate a 1.2 M floppy
Floppy12Emulation Emulation = 1
// Floppy144Emulation emulate a 1.44 M floppy
Floppy144Emulation Emulation = 2
// Floppy288Emulation emulate a 2.88 M floppy
Floppy288Emulation Emulation = 3
// HardDiskEmulation emulate a hard disk
HardDiskEmulation Emulation = 4
)
// ElTorito boot structure for a disk
type ElTorito struct {
// BootCatalog path to save the boot catalog in the file structure. Defaults to "/BOOT.CAT" in iso9660 and "/boot.catalog" in Rock Ridge
BootCatalog string
// HideBootCatalog if the boot catalog should be hidden in the file system. Defaults to false
HideBootCatalog bool
// Entries list of ElToritoEntry boot entires
Entries []*ElToritoEntry
// Platform supported platform
Platform Platform
}
// ElToritoEntry single entry in an el torito boot catalog
type ElToritoEntry struct {
Platform Platform
Emulation Emulation
BootFile string
HideBootFile bool
LoadSegment uint16
// BootTable whether to insert a boot table into the entry, equivalent to genisoimage
// option `-boot-info-table`. Unlike genisoimage, does not modify the file in the
// filesystem, but inserts it on the fly.
BootTable bool
// SystemType type of system the partition is, accordinng to the MBR standard
SystemType mbr.Type
// LoadSize how many blocks of BootFile to load, equivalent to genisoimage option `-boot-load-size`
LoadSize uint16
size uint16
location uint32
}
// generateCatalog generate the el torito boot catalog file
func (et *ElTorito) generateCatalog() []byte {
b := make([]byte, 0)
b = append(b, et.validationEntry()...)
for i, e := range et.Entries {
// only subsequent entries have a header, not the first
if i != 0 {
b = append(b, e.headerBytes(i == len(et.Entries)-1, 1)...)
}
b = append(b, e.entryBytes()...)
}
return b
}
func (et *ElTorito) validationEntry() []byte {
b := make([]byte, 0x20)
b[0] = 1
b[1] = byte(et.Platform)
copy(b[4:0x1c], util.AppNameVersion)
b[0x1e] = 0x55
b[0x1f] = 0xaa
// calculate checksum
checksum := uint16(0x0)
for i := 0; i < len(b); i += 2 {
checksum += binary.LittleEndian.Uint16(b[i : i+2])
}
binary.LittleEndian.PutUint16(b[0x1c:0x1e], -checksum)
return b
}
// toHeaderBytes provide header bytes
func (e *ElToritoEntry) headerBytes(last bool, entries uint16) []byte {
b := make([]byte, 0x20)
b[0] = 0x90
if last {
b[0] = 0x91
}
b[1] = byte(e.Platform)
binary.LittleEndian.PutUint16(b[2:4], entries)
// we do not use the section identifier for now
return b
}
// toBytes convert ElToritoEntry to appropriate entry bytes
func (e *ElToritoEntry) entryBytes() []byte {
blocks := e.LoadSize
if blocks == 0 {
blocks = e.size / 512
if e.size%512 > 1 {
blocks++
}
}
b := make([]byte, 0x20)
b[0] = 0x88
b[1] = byte(e.Emulation)
binary.LittleEndian.PutUint16(b[2:4], e.LoadSegment)
// b[4] is system type, taken from byte 5 in the partition table in the boot image
b[4] = byte(e.SystemType)
// b[5] is unused and must be 0
// b[6:8] is the number of emulated (512-byte) sectors, i.e. the size of the file
binary.LittleEndian.PutUint16(b[6:8], blocks)
// b[8:0xc] is the location of the boot image on disk, in disk (2048) sectors
binary.LittleEndian.PutUint32(b[8:12], e.location)
// b[0xc] is selection criteria type. We do not yet support it, so leave as 0.
// b[0xd:] is vendor unique selectiomn criteria. We do not yet support it, so leave as 0.
return b
}
// generateBootTable generate the el torito boot table for this entry
func (e *ElToritoEntry) generateBootTable(pvdSector uint32, p string) ([]byte, error) {
b := make([]byte, 56)
binary.LittleEndian.PutUint32(b[0:4], pvdSector)
binary.LittleEndian.PutUint32(b[4:8], e.location)
binary.LittleEndian.PutUint32(b[8:12], uint32(e.size))
// Checksum - simply add up all 32-bit words beginning at byte position 64
f, err := os.Open(p)
if err != nil {
return nil, fmt.Errorf("failed to open boot file for checksum reading %s: %v", p, err)
}
defer f.Close()
var (
checksum uint32
)
for offset := 64; offset <= int(e.size); offset += 4 {
buf := make([]byte, 4)
n, err := f.ReadAt(buf, int64(offset))
if err != nil && err != io.EOF {
return nil, err
}
if n == 0 {
break
}
checksum += binary.LittleEndian.Uint32(buf)
if err == io.EOF {
break
}
}
binary.LittleEndian.PutUint32(b[12:16], checksum)
return b, nil
}
07070100000322000081A4000000000000000000000001645E367C00000979000000000000000000000000000000000000005200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/file.go package iso9660
import (
"fmt"
"io"
"os"
)
// File represents a single file in an iso9660 filesystem
//
// it is NOT used when working in a workspace, where we just use the underlying OS
type File struct {
*directoryEntry
isReadWrite bool
isAppend bool
offset int64
closed bool
}
// Read reads up to len(b) bytes from the File.
// It returns the number of bytes read and any error encountered.
// At end of file, Read returns 0, io.EOF
// reads from the last known offset in the file from last read or write
// use Seek() to set at a particular point
func (fl *File) Read(b []byte) (int, error) {
if fl == nil || fl.closed {
return 0, os.ErrClosed
}
// we have the DirectoryEntry, so we can get the starting location and size
// since iso9660 files are contiguous, we only need the starting location and size
// to get the entire file
fs := fl.filesystem
size := int(fl.size) - int(fl.offset)
location := int(fl.location)
maxRead := size
file := fs.file
// if there is nothing left to read, just return EOF
if size <= 0 {
return 0, io.EOF
}
// we stop when we hit the lesser of
// 1- len(b)
// 2- file end
if len(b) < maxRead {
maxRead = len(b)
}
// just read the requested number of bytes and change our offset
_, err := file.ReadAt(b[0:maxRead], int64(location)*fs.blocksize+fl.offset)
if err != nil && err != io.EOF {
return 0, err
}
fl.offset += int64(maxRead)
var retErr error
if fl.offset >= int64(fl.size) {
retErr = io.EOF
}
return maxRead, retErr
}
// Write writes len(b) bytes to the File.
//
// you cannot write to an iso, so this returns an error
func (fl *File) Write(p []byte) (int, error) {
return 0, fmt.Errorf("cannot write to a read-only iso filesystem")
}
// Seek set the offset to a particular point in the file
func (fl *File) Seek(offset int64, whence int) (int64, error) {
if fl == nil || fl.closed {
return 0, os.ErrClosed
}
newOffset := int64(0)
switch whence {
case io.SeekStart:
newOffset = offset
case io.SeekEnd:
newOffset = int64(fl.size) + offset
case io.SeekCurrent:
newOffset = fl.offset + offset
}
if newOffset < 0 {
return fl.offset, fmt.Errorf("cannot set offset %d before start of file", offset)
}
fl.offset = newOffset
return fl.offset, nil
}
func (fl *File) Location() uint32 {
return fl.location
}
// Close close the file
func (fl *File) Close() error {
fl.closed = true
return nil
}
07070100000323000081A4000000000000000000000001645E367C00006D61000000000000000000000000000000000000005600000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/finalize.go package iso9660
import (
"fmt"
"io"
"os"
"path"
"path/filepath"
"regexp"
"sort"
"strings"
"time"
"github.com/diskfs/go-diskfs/util"
)
const (
dataStartSector = 16
defaultVolumeIdentifier = "ISOIMAGE"
)
// FinalizeOptions options to pass to finalize
type FinalizeOptions struct {
// RockRidge enable Rock Ridge extensions
RockRidge bool
// DeepDirectories allow directories deeper than 8
DeepDirectories bool
// ElTorito slice of el torito entry configs
ElTorito *ElTorito
// VolumeIdentifier custom volume name, defaults to "ISOIMAGE"
VolumeIdentifier string
}
// finalizeFileInfo is a file info useful for finalization
// fulfills os.FileInfo
//
// Name() string // base name of the file
// Size() int64 // length in bytes for regular files; system-dependent for others
// Mode() FileMode // file mode bits
// ModTime() time.Time // modification time
// IsDir() bool // abbreviation for Mode().IsDir()
// Sys() interface{} // underlying data source (can return nil)
//
//nolint:structcheck // keep unused members so that we can know their references
type finalizeFileInfo struct {
path string
target string
shortname string
extension string
location uint32
blocks uint32 // blocks for the directory itself and its entries
continuationBlocks uint32 // blocks for CE entries
recordSize uint8
depth int
name string
size int64
mode os.FileMode
modTime time.Time
isDir bool
isRoot bool
bytes [][]byte
parent *finalizeFileInfo
children []*finalizeFileInfo
trueParent *finalizeFileInfo
trueChild *finalizeFileInfo
elToritoEntry *ElToritoEntry
content []byte
}
func (fi *finalizeFileInfo) Name() string {
// we are using plain iso9660 (without extensions), so just shortname possibly with extension
ret := fi.shortname
if !fi.isDir {
ret = fmt.Sprintf("%s.%s;1", fi.shortname, fi.extension)
}
// shortname already is ucased
return ret
}
func (fi *finalizeFileInfo) Size() int64 {
return fi.size
}
func (fi *finalizeFileInfo) Mode() os.FileMode {
return fi.mode
}
func (fi *finalizeFileInfo) ModTime() time.Time {
return fi.modTime
}
func (fi *finalizeFileInfo) IsDir() bool {
return fi.isDir
}
func (fi *finalizeFileInfo) Sys() interface{} {
return nil
}
func (fi *finalizeFileInfo) updateDepth(depth int) {
fi.depth = depth
if fi.isDir {
for _, e := range fi.children {
e.updateDepth(depth + 1)
}
}
}
func (fi *finalizeFileInfo) toDirectoryEntry(fs *FileSystem, isSelf, isParent bool) (*directoryEntry, error) {
de := &directoryEntry{
extAttrSize: 0,
location: fi.location,
size: uint32(fi.Size()),
creation: fi.ModTime(),
isHidden: false,
isSubdirectory: fi.IsDir(),
isAssociated: false,
hasExtendedAttrs: false,
hasOwnerGroupPermissions: false,
hasMoreEntries: false,
isSelf: isSelf,
isParent: isParent,
volumeSequence: 1,
filesystem: fs,
// we keep the full filename until after processing
filename: fi.Name(),
}
// if it is root, and we have susp enabled, add the necessary entries
if fs.suspEnabled {
if fi.isRoot && isSelf {
de.extensions = append(de.extensions, directoryEntrySystemUseExtensionSharingProtocolIndicator{skipBytes: 0})
}
// add appropriate PX, TF, SL, NM extensions
for _, e := range fs.suspExtensions {
ext, err := e.GetFileExtensions(path.Join(fs.workspace, fi.path), isSelf, isParent)
if err != nil {
return nil, fmt.Errorf("error getting extensions for %s at path %s: %v", e.ID(), fi.path, err)
}
ext2, err := e.GetFinalizeExtensions(fi)
if err != nil {
return nil, fmt.Errorf("error getting finalize extensions for %s at path %s: %v", e.ID(), fi.path, err)
}
ext = append(ext, ext2...)
de.extensions = append(de.extensions, ext...)
}
if fi.isRoot && isSelf {
for _, e := range fs.suspExtensions {
de.extensions = append(de.extensions, directoryEntrySystemUseExtensionReference{id: e.ID(), descriptor: e.Descriptor(), source: e.Source(), extensionVersion: e.Version()})
}
}
}
return de, nil
}
func (fi *finalizeFileInfo) toDirectory(fs *FileSystem) (*Directory, error) {
// also need to add self and parent to it
var (
self, parent, dirEntry *directoryEntry
err error
)
if !fi.IsDir() {
return nil, fmt.Errorf("cannot convert a file entry to a directtory")
}
self, err = fi.toDirectoryEntry(fs, true, false)
if err != nil {
return nil, fmt.Errorf("could not convert self entry %s to dirEntry: %v", fi.path, err)
}
// if we have no parent, we are the root entry
// we also need to put in the SUSP if it is enabled
parentEntry := fi.parent
if fi.isRoot {
parentEntry = fi
}
parent, err = parentEntry.toDirectoryEntry(fs, false, true)
if err != nil {
return nil, fmt.Errorf("could not convert parent entry %s to dirEntry: %v", fi.parent.path, err)
}
entries := []*directoryEntry{self, parent}
for _, child := range fi.children {
dirEntry, err = child.toDirectoryEntry(fs, false, false)
if err != nil {
return nil, fmt.Errorf("could not convert child entry %s to dirEntry: %v", child.path, err)
}
entries = append(entries, dirEntry)
}
d := &Directory{
directoryEntry: *self,
entries: entries,
}
return d, nil
}
// calculate the size of a directory entry single record
func (fi *finalizeFileInfo) calculateRecordSize(fs *FileSystem, isSelf, isParent bool) (dirEntrySize, continuationBlocksSize int, err error) {
// we do not actually need the the continuation blocks to calculate size, just length, so use an empty slice
extTmpBlocks := make([]uint32, 100)
dirEntry, err := fi.toDirectoryEntry(fs, isSelf, isParent)
if err != nil {
return 0, 0, fmt.Errorf("could not convert to dirEntry: %v", err)
}
dirBytes, err := dirEntry.toBytes(false, extTmpBlocks)
if err != nil {
return 0, 0, fmt.Errorf("could not convert dirEntry to bytes: %v", err)
}
// first entry is the bytes to store in the directory
// rest are continuation blocks
return len(dirBytes[0]), len(dirBytes) - 1, nil
}
// calculate the size of a directory, similar to a file size
func (fi *finalizeFileInfo) calculateDirectorySize(fs *FileSystem) (dirEntrySize, continuationBlocksSize int, err error) {
var (
recSize, recCE int
)
if !fi.IsDir() {
return 0, 0, fmt.Errorf("cannot convert a file entry to a directtory")
}
recSize, recCE, err = fi.calculateRecordSize(fs, true, false)
if err != nil {
return 0, 0, fmt.Errorf("could not calculate self entry size %s: %v", fi.path, err)
}
dirEntrySize += recSize
continuationBlocksSize += recCE
recSize, recCE, err = fi.calculateRecordSize(fs, false, true)
if err != nil {
return 0, 0, fmt.Errorf("could not calculate parent entry size %s: %v", fi.path, err)
}
dirEntrySize += recSize
continuationBlocksSize += recCE
for _, e := range fi.children {
// get size of data and CE blocks
recSize, recCE, err = e.calculateRecordSize(fs, false, false)
if err != nil {
return 0, 0, fmt.Errorf("could not calculate child %s entry size %s: %v", e.path, fi.path, err)
}
// do not go over a block boundary; pad if necessary
newSize := dirEntrySize + recSize
blocksize := int(fs.blocksize)
left := blocksize - dirEntrySize%blocksize
if left != 0 && newSize/blocksize > dirEntrySize/blocksize {
dirEntrySize += left
}
continuationBlocksSize += recCE
dirEntrySize += recSize
}
return dirEntrySize, continuationBlocksSize, nil
}
// add depth to all children
func (fi *finalizeFileInfo) addProperties(depth int) {
fi.depth = depth
for _, e := range fi.children {
e.parent = fi
e.addProperties(depth + 1)
}
}
// sort all of the directory children recursively - this is for ordering into blocks
func (fi *finalizeFileInfo) collapseAndSortChildren() (dirs, files []*finalizeFileInfo) {
tmpDirs := make([]*finalizeFileInfo, 0)
tmpFiles := make([]*finalizeFileInfo, 0)
// first extract all of the directories
for _, e := range fi.children {
if e.IsDir() {
tmpDirs = append(tmpDirs, e)
} else {
tmpFiles = append(tmpFiles, e)
}
}
// next sort them
sort.Slice(tmpDirs, func(i, j int) bool {
// just sort by filename; as good as anything else
return tmpDirs[i].Name() < tmpDirs[j].Name()
})
sort.Slice(tmpFiles, func(i, j int) bool {
// just sort by filename; as good as anything else
return tmpFiles[i].Name() < tmpFiles[j].Name()
})
// finally add in the children going down
dirs = make([]*finalizeFileInfo, 0)
files = tmpFiles
for _, e := range tmpDirs {
dirs = append(dirs, e)
// now get any children
d, f := e.collapseAndSortChildren()
dirs = append(dirs, d...)
files = append(files, f...)
}
return dirs, files
}
func (fi *finalizeFileInfo) findEntry(p string) (*finalizeFileInfo, error) {
// break path down into parts and levels
var (
target *finalizeFileInfo
err error
)
parts := splitPath(p)
if len(parts) == 0 || p == "." {
target = fi
} else {
current := parts[0]
// read the directory bytes
for _, e := range fi.children {
// do we have an alternate name?
// only care if not self or parent entry
checkFilename := e.name
if checkFilename == current {
if len(parts) > 1 {
target, err = e.findEntry(path.Join(parts[1:]...))
if err != nil {
return nil, fmt.Errorf("could not get entry: %v", err)
}
} else {
// this is the final one, we found it, keep it
target = e
}
break
}
}
}
return target, nil
}
func (fi *finalizeFileInfo) removeChild(p string) *finalizeFileInfo {
var removed *finalizeFileInfo
children := make([]*finalizeFileInfo, 0)
for _, e := range fi.children {
if e.name != p {
children = append(children, e)
} else {
removed = e
}
}
fi.children = children
return removed
}
func (fi *finalizeFileInfo) addChild(entry *finalizeFileInfo) {
fi.children = append(fi.children, entry)
}
// Finalize finalize a read-only filesystem by writing it out to a read-only format
//
//nolint:gocyclo // this finalize function is complex and needs to be. We might be better off refactoring it to multiple functions, but it does not buy all that much.
func (fs *FileSystem) Finalize(options FinalizeOptions) error {
if fs.workspace == "" {
return fmt.Errorf("cannot finalize an already finalized filesystem")
}
// did we ask for susp?
if options.RockRidge {
fs.suspEnabled = true
fs.suspExtensions = append(fs.suspExtensions, getRockRidgeExtension(rockRidge112))
}
/*
There is nothing in the iso9660 spec about the order of directories and files,
other than that they must be accessible in the location specified in directory entry and/or path table
However, most implementations seem to it as follows:
- each directory follows its parent
- data (i.e. file) sectors in each directory are immediately after its directory and immediately before the next sibling directory to its parent
to keep it simple, we will follow what xorriso/mkisofs on linux does, in the following order:
- volume descriptor set, beginning at sector 16
- root directory entry
- all other directory entries, sorted alphabetically, depth first
- L path table
- M path table
- data sectors for files, sorted alphabetically, matching order of directories
this is where we build our filesystem
1- blank out sectors 0-15 for system use
2- skip sectors 16-17 for PVD and terminator (fill later)
3- calculate how many sectors required for root directory
4- calculate each child directory, working our way down, including number of sectors and location
5- write path tables (L & M)
6- write files for root directory
7- write root directory entry into its sector (18)
8- repeat steps 6&7 for all other directories
9- write PVD
10- write volume descriptor set terminator
*/
f := fs.file
blocksize := int(fs.blocksize)
// 1- blank out sectors 0-15
b := make([]byte, dataStartSector*fs.blocksize)
n, err := f.WriteAt(b, 0)
if err != nil {
return fmt.Errorf("could not write blank system area: %v", err)
}
if n != len(b) {
return fmt.Errorf("only wrote %d bytes instead of expected %d to system area", n, len(b))
}
// 3- build out file tree
fileList, dirList, err := walkTree(fs.Workspace())
if err != nil {
return fmt.Errorf("error walking tree: %v", err)
}
// starting point
root := dirList["."]
root.addProperties(1)
// if we need to relocate directories, must do them here, before finalizing order and sizes
// do not bother if enabled DeepDirectories, i.e. non-ISO9660 compliant
if !options.DeepDirectories {
if fs.suspEnabled {
var handler suspExtension
for _, e := range fs.suspExtensions {
if e.Relocatable() {
handler = e
break
}
}
var relocateFiles []*finalizeFileInfo
relocateFiles, dirList, err = handler.Relocate(dirList)
if err != nil {
return fmt.Errorf("unable to use extension %s to relocate directories from depth > 8: %v", handler.ID(), err)
}
fileList = append(fileList, relocateFiles...)
}
// check if there are any deeper than 9
for _, e := range dirList {
if e.depth > 8 {
return fmt.Errorf("directory %s deeper than 8 deep and DeepDirectories override not enabled", e.path)
}
}
}
// convert sizes to required blocks for files
for _, e := range fileList {
e.blocks = calculateBlocks(e.size, fs.blocksize)
}
// we now have list of all of the files and directories and their properties, as well as children of every directory
// store them in a flat sorted slice, beginning with root so we can write them out in order to blocks after
dirs := make([]*finalizeFileInfo, 0, 20)
dirs = append(dirs, root)
subdirs, files := root.collapseAndSortChildren()
dirs = append(dirs, subdirs...)
// calculate the sizes and locations of the directories from the flat list and assign blocks
rootLocation := uint32(dataStartSector + 2)
// if el torito was enabled, use one sector for boot volume entry
if options.ElTorito != nil {
rootLocation++
}
location := rootLocation
var (
catEntry *finalizeFileInfo
bootcat []byte
)
if options.ElTorito != nil {
bootcat = options.ElTorito.generateCatalog()
// figure out where to save it on disk
catname := options.ElTorito.BootCatalog
switch {
case catname == "" && options.RockRidge:
catname = elToritoDefaultCatalogRR
case catname == "":
catname = elToritoDefaultCatalog
}
shortname, extension := calculateShortnameExtension(path.Base(catname))
// break down the catalog basename from the parent dir
catSize := int64(len(bootcat))
catEntry = &finalizeFileInfo{
content: bootcat,
size: catSize,
path: catname,
name: path.Base(catname),
shortname: shortname,
extension: extension,
blocks: calculateBlocks(catSize, fs.blocksize),
}
// make it the first file
files = append([]*finalizeFileInfo{catEntry}, files...)
// if we were not told to hide the catalog, add it to its parent
if !options.ElTorito.HideBootCatalog {
var parent *finalizeFileInfo
parent, err = root.findEntry(path.Dir(catname))
if err != nil {
return fmt.Errorf("error finding parent for boot catalog %s: %v", catname, err)
}
parent.addChild(catEntry)
}
for _, e := range options.ElTorito.Entries {
var parent, child *finalizeFileInfo
parent, err = root.findEntry(path.Dir(e.BootFile))
if err != nil {
return fmt.Errorf("error finding parent for boot image file %s: %v", e.BootFile, err)
}
// did we ask to hide any image files?
if e.HideBootFile {
child = parent.removeChild(path.Base(e.BootFile))
} else {
child, err = parent.findEntry(path.Base(e.BootFile))
if err != nil {
return fmt.Errorf("unable to find image child %s: %v", e.BootFile, err)
}
}
// save the child so we can add location late
e.size = uint16(child.size)
child.elToritoEntry = e
}
}
var size, ceBlocks int
for _, dir := range dirs {
dir.location = location
size, ceBlocks, err = dir.calculateDirectorySize(fs)
if err != nil {
return fmt.Errorf("unable to calculate size of directory for %s: %v", dir.path, err)
}
dir.size = int64(size)
dir.blocks = calculateBlocks(int64(size), int64(blocksize))
dir.continuationBlocks = uint32(ceBlocks)
location += dir.blocks + dir.continuationBlocks
}
// we now have sorted list of block order, with sizes and number of blocks on each
// next assign the blocks to each, and then we can enter the data in the directory entries
// create the pathtables (L & M)
// with the list of directories, we can make a path table
pathTable := createPathTable(dirs)
// how big is the path table? we will take LSB for now, because they are the same size
pathTableLBytes := pathTable.toLBytes()
pathTableMBytes := pathTable.toMBytes()
pathTableSize := len(pathTableLBytes)
pathTableBlocks := uint32(pathTableSize / blocksize)
if pathTableSize%blocksize > 0 {
pathTableBlocks++
}
// we do not do optional path tables yet
pathTableLLocation := location
location += pathTableBlocks
pathTableMLocation := location
location += pathTableBlocks
// if we asked for ElTorito, need to generate the boot catalog and save it
volIdentifier := defaultVolumeIdentifier
if options.VolumeIdentifier != "" {
volIdentifier = options.VolumeIdentifier
}
for _, e := range files {
e.location = location
location += e.blocks
if e.elToritoEntry != nil {
e.elToritoEntry.location = e.location
}
}
// now that we have all of the files with their locations, we can rebuild the boot catalog using the correct data
if catEntry != nil {
bootcat = options.ElTorito.generateCatalog()
catEntry.content = bootcat
}
// now we can write each one out - dirs first then files
for _, e := range dirs {
writeAt := int64(e.location) * int64(blocksize)
var d *Directory
d, err = e.toDirectory(fs)
if err != nil {
return fmt.Errorf("unable to convert entry to directory: %v", err)
}
// Directory.toBytes() always returns whole blocks
// get the continuation entry locations
ceLocations := make([]uint32, 0)
ceLocationStart := e.location + e.blocks
for i := 0; i < int(e.continuationBlocks); i++ {
ceLocations = append(ceLocations, ceLocationStart+uint32(i))
}
var p [][]byte
p, err = d.entriesToBytes(ceLocations)
if err != nil {
return fmt.Errorf("could not convert directory to bytes: %v", err)
}
for i, e := range p {
_, _ = f.WriteAt(e, writeAt+int64(i*blocksize))
}
}
// now write out the path tables, L & M
writeAt := int64(pathTableLLocation) * int64(blocksize)
_, _ = f.WriteAt(pathTableLBytes, writeAt)
writeAt = int64(pathTableMLocation) * int64(blocksize)
_, _ = f.WriteAt(pathTableMBytes, writeAt)
var closeFiles []*os.File
defer func() {
for _, f := range closeFiles {
f.Close()
}
}()
for _, e := range files {
var (
from *os.File
copied int
)
writeAt := int64(e.location) * int64(blocksize)
if e.content == nil {
// for file, just copy the data across
from, err = os.Open(path.Join(fs.workspace, e.path))
if err != nil {
return fmt.Errorf("failed to open file for reading %s: %v", e.path, err)
}
closeFiles = append(closeFiles, from)
if e.elToritoEntry != nil && e.elToritoEntry.BootTable {
// copy first 8 bytes, then insert the El Torito Boot Information Table, then the rest
var count int
// first 8 bytes
count, err = copyFileData(from, f, 0, writeAt, 8)
if err != nil {
return fmt.Errorf("failed to copy first bytes 0-8 of boot file to disk %s: %v", e.path, err)
}
copied += count
// insert El Torito Boot Information Table
bootTable, err := e.elToritoEntry.generateBootTable(dataStartSector, path.Join(fs.workspace, e.path))
if err != nil {
return fmt.Errorf("failed to generate boot table for %s: %v", e.path, err)
}
count, err = f.WriteAt(bootTable, writeAt+8)
if err != nil {
return fmt.Errorf("failed to write 56 byte boot table to disk %s: %v", e.path, err)
}
copied += count
// remainder of file
count, err = copyFileData(from, f, 64, writeAt+64, 0)
if err != nil {
return fmt.Errorf("failed to copy bytes 64 to end of boot file to disk %s: %v", e.path, err)
}
copied += count
} else {
copied, err = copyFileData(from, f, 0, writeAt, 0)
if err != nil {
return fmt.Errorf("failed to copy file to disk %s: %v", e.path, err)
}
}
if copied != int(e.Size()) {
return fmt.Errorf("error copying file %s to disk, copied %d bytes, expected %d", e.path, copied, e.Size())
}
} else {
copied = len(e.content)
if _, err = f.WriteAt(e.content, writeAt); err != nil {
return fmt.Errorf("failed to write content of %s to disk: %v", e.path, err)
}
}
// fill in
left := blocksize - (copied % blocksize)
if left > 0 {
b2 := make([]byte, left)
_, _ = f.WriteAt(b2, writeAt+int64(copied))
}
}
totalSize := location
location = dataStartSector
// create and write the primary volume descriptor, supplementary and boot, and volume descriptor set terminator
now := time.Now()
rootDE, err := root.toDirectoryEntry(fs, true, false)
if err != nil {
return fmt.Errorf("could not convert root entry for primary volume descriptor to dirEntry: %v", err)
}
pvd := &primaryVolumeDescriptor{
systemIdentifier: "",
volumeIdentifier: volIdentifier,
volumeSize: totalSize,
setSize: 1,
sequenceNumber: 1,
blocksize: uint16(fs.blocksize),
pathTableSize: uint32(pathTableSize),
pathTableLLocation: pathTableLLocation,
pathTableLOptionalLocation: 0,
pathTableMLocation: pathTableMLocation,
pathTableMOptionalLocation: 0,
volumeSetIdentifier: "",
publisherIdentifier: "",
preparerIdentifier: util.AppNameVersion,
applicationIdentifier: "",
copyrightFile: "", // 37 bytes
abstractFile: "", // 37 bytes
bibliographicFile: "", // 37 bytes
creation: now,
modification: now,
expiration: now,
effective: now,
rootDirectoryEntry: rootDE,
}
b = pvd.toBytes()
_, _ = f.WriteAt(b, int64(location)*int64(blocksize))
location++
// do we have a boot sector?
if options.ElTorito != nil {
bvd := &bootVolumeDescriptor{location: catEntry.location}
b = bvd.toBytes()
_, _ = f.WriteAt(b, int64(location)*int64(blocksize))
location++
}
terminator := &terminatorVolumeDescriptor{}
b = terminator.toBytes()
_, _ = f.WriteAt(b, int64(location)*int64(blocksize))
_ = os.RemoveAll(fs.workspace)
// finish by setting as finalized
fs.workspace = ""
return nil
}
// copyFileData copy data from file `from` at offset `fromOffset` to file `to` at offset `toOffset`.
// Copies `size` bytes. If `size` is 0, copies as many bytes as it can.
func copyFileData(from, to util.File, fromOffset, toOffset int64, size int) (int, error) {
buf := make([]byte, 2048)
copied := 0
for {
n, err := from.ReadAt(buf, fromOffset+int64(copied))
if err != nil && err != io.EOF {
return copied, err
}
if size > 0 && n > (size-copied) {
n = size - copied
}
if n == 0 {
break
}
if _, err := to.WriteAt(buf[:n], toOffset+int64(copied)); err != nil {
return copied, err
}
copied += n
}
return copied, nil
}
// sort path table entries
func sortFinalizeFileInfoPathTable(left, right *finalizeFileInfo) bool {
switch {
case left.parent == right.parent:
// same parents = same depth, just sort on name
lname := left.Name()
rname := right.Name()
maxLen := maxInt(len(lname), len(rname))
format := fmt.Sprintf("%%-%ds", maxLen)
return fmt.Sprintf(format, lname) < fmt.Sprintf(format, rname)
case left.depth < right.depth:
// different parents with different depth, lower first
return true
case right.depth > left.depth:
return false
case left.parent == nil && right.parent != nil:
return true
case left.parent != nil && right.parent == nil:
return false
default:
// same depth, different parents, it depends on the sort order of the parents
return sortFinalizeFileInfoPathTable(left.parent, right.parent)
}
}
// create a path table from a slice of *finalizeFileInfo that are directories
func createPathTable(fi []*finalizeFileInfo) *pathTable {
// copy so we do not modify the original
fs := make([]*finalizeFileInfo, len(fi))
copy(fs, fi)
// sort via the rules
sort.Slice(fs, func(i, j int) bool {
return sortFinalizeFileInfoPathTable(fs[i], fs[j])
})
indexMap := make(map[*finalizeFileInfo]int)
// now that it is sorted, create the ordered path table entries
entries := make([]*pathTableEntry, 0)
for i, e := range fs {
name := e.Name()
nameSize := len(name)
size := 8 + uint16(nameSize)
if nameSize%2 != 0 {
size++
}
ownIndex := i + 1
indexMap[e] = ownIndex
// root just points to itself
parentIndex := ownIndex
if ip, ok := indexMap[e.parent]; ok {
parentIndex = ip
}
pte := &pathTableEntry{
nameSize: uint8(nameSize),
size: size,
extAttrLength: 0,
location: e.location,
parentIndex: uint16(parentIndex),
dirname: name,
}
entries = append(entries, pte)
}
return &pathTable{
records: entries,
}
}
func walkTree(workspace string) ([]*finalizeFileInfo, map[string]*finalizeFileInfo, error) {
cwd, err := os.Getwd()
if err != nil {
return nil, nil, fmt.Errorf("could not get pwd: %v", err)
}
// make everything relative to the workspace
_ = os.Chdir(workspace)
dirList := make(map[string]*finalizeFileInfo)
fileList := make([]*finalizeFileInfo, 0)
var entry *finalizeFileInfo
err = filepath.Walk(".", func(fp string, fi os.FileInfo, err error) error {
if err != nil {
return fmt.Errorf("error walking path %s: %v", fp, err)
}
isRoot := fp == "."
name := fi.Name()
shortname, extension := calculateShortnameExtension(name)
if isRoot {
name = string([]byte{0x00})
shortname = name
}
entry = &finalizeFileInfo{path: fp, name: name, isDir: fi.IsDir(), isRoot: isRoot, modTime: fi.ModTime(), mode: fi.Mode(), size: fi.Size(), shortname: shortname}
// we will have to save it as its parent
parentDir := filepath.Dir(fp)
parentDirInfo := dirList[parentDir]
if fi.IsDir() {
entry.children = make([]*finalizeFileInfo, 0, 20)
dirList[fp] = entry
if !isRoot {
parentDirInfo.children = append(parentDirInfo.children, entry)
dirList[parentDir] = parentDirInfo
}
} else {
// calculate blocks
entry.size = fi.Size()
entry.extension = extension
parentDirInfo.children = append(parentDirInfo.children, entry)
dirList[parentDir] = parentDirInfo
fileList = append(fileList, entry)
}
return nil
})
if err != nil {
return nil, nil, err
}
// reset the workspace
_ = os.Chdir(cwd)
return fileList, dirList, nil
}
func calculateBlocks(size, blocksize int64) uint32 {
blocks := uint32(size / blocksize)
// add one for partial
if size%blocksize > 0 {
blocks++
}
return blocks
}
func calculateShortnameExtension(name string) (shortname, extension string) {
parts := strings.SplitN(name, ".", 2)
shortname = parts[0]
if len(parts) > 1 {
extension = parts[1]
}
// shortname and extension must be upper-case
shortname = strings.ToUpper(shortname)
extension = strings.ToUpper(extension)
// replace illegal characters in shortname and extension with _
re := regexp.MustCompile("[^A-Z0-9_]")
shortname = re.ReplaceAllString(shortname, "_")
extension = re.ReplaceAllString(extension, "_")
return shortname, extension
}
07070100000324000081A4000000000000000000000001645E367C00004217000000000000000000000000000000000000005500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/iso9660.go package iso9660
import (
"encoding/binary"
"fmt"
"os"
"path"
"github.com/diskfs/go-diskfs/filesystem"
"github.com/diskfs/go-diskfs/util"
)
const (
volumeDescriptorSize int64 = 2 * KB // each volume descriptor is 2KB
systemAreaSize int64 = 32 * KB // 32KB system area size
defaultSectorSize int64 = 2 * KB
// MaxBlocks maximum number of blocks allowed in an iso9660 filesystem
MaxBlocks int64 = 4.294967296e+09 // 2^32
)
// FileSystem implements the FileSystem interface
type FileSystem struct {
workspace string
size int64
start int64
file util.File
blocksize int64
volumes volumeDescriptors
pathTable *pathTable
rootDir *directoryEntry
suspEnabled bool // is the SUSP in use?
suspSkip uint8 // how many bytes to skip in each directory record
suspExtensions []suspExtension
}
// Equal compare if two filesystems are equal
func (fs *FileSystem) Equal(a *FileSystem) bool {
localMatch := fs.file == a.file && fs.size == a.size
vdMatch := fs.volumes.equal(&a.volumes)
return localMatch && vdMatch
}
// Workspace get the workspace path
func (fs *FileSystem) Workspace() string {
return fs.workspace
}
// Create creates an ISO9660 filesystem in a given directory
//
// requires the util.File where to create the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File to create the filesystem,
// and blocksize is is the logical blocksize to use for creating the filesystem
//
// note that you are *not* required to create the filesystem on the entire disk. You could have a disk of size
// 20GB, and create a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for creating filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 2 KB.
func Create(f util.File, size, start, blocksize int64, workspace string) (*FileSystem, error) {
if blocksize == 0 {
blocksize = defaultSectorSize
}
// make sure it is an allowed blocksize
if err := validateBlocksize(blocksize); err != nil {
return nil, err
}
// size of 0 means to use defaults
if size != 0 && size > MaxBlocks*blocksize {
return nil, fmt.Errorf("requested size is larger than maximum allowed ISO9660 size of %d blocks", MaxBlocks)
}
// at bare minimum, it must have enough space for the system area, one volume descriptor, one volume decriptor set terminator, and one block of data
if size != 0 && size < systemAreaSize+2*volumeDescriptorSize+blocksize {
return nil, fmt.Errorf("requested size is smaller than minimum allowed ISO9660 size: system area (%d), one volume descriptor (%d), one volume descriptor set terminator (%d), and one block (%d)", systemAreaSize, volumeDescriptorSize, volumeDescriptorSize, blocksize)
}
var workdir string
if workspace != "" {
info, err := os.Stat(workspace)
if err != nil {
return nil, fmt.Errorf("could not stat working directory: %v", err)
}
if !info.IsDir() {
return nil, fmt.Errorf("provided workspace is not a directory: %s", workspace)
}
workdir = workspace
} else {
// create a temporary working area where we can create the filesystem.
// It is only on `Finalize()` that we write it out to the actual disk file
var err error
workdir, err = os.MkdirTemp("", "diskfs_iso")
if err != nil {
return nil, fmt.Errorf("could not create working directory: %v", err)
}
}
// create root directory
// there is nothing in there
return &FileSystem{
workspace: workdir,
start: start,
size: size,
file: f,
volumes: volumeDescriptors{},
blocksize: blocksize,
}, nil
}
// Read reads a filesystem from a given disk.
//
// requires the util.File where to read the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File the filesystem is expected to begin,
// and blocksize is is the physical blocksize to use for reading the filesystem
//
// note that you are *not* required to read a filesystem on the entire disk. You could have a disk of size
// 20GB, and a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for working with filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 2K bytes
func Read(file util.File, size, start, blocksize int64) (*FileSystem, error) {
var read int
if blocksize == 0 {
blocksize = defaultSectorSize
}
// make sure it is an allowed blocksize
if err := validateBlocksize(blocksize); err != nil {
return nil, err
}
// default size of 0 means use whatever size is available
if size != 0 && size > MaxBlocks*blocksize {
return nil, fmt.Errorf("requested size is larger than maximum allowed ISO9660 size of %d blocks", MaxBlocks)
}
// at bare minimum, it must have enough space for the system area, one volume descriptor, one volume decriptor set terminator, and one block of data
if size != 0 && size < systemAreaSize+2*volumeDescriptorSize+blocksize {
return nil, fmt.Errorf("requested size is too small to allow for system area (%d), one volume descriptor (%d), one volume descriptor set terminator (%d), and one block (%d)", systemAreaSize, volumeDescriptorSize, volumeDescriptorSize, blocksize)
}
// load the information from the disk
// read system area
systemArea := make([]byte, systemAreaSize)
n, err := file.ReadAt(systemArea, start)
if err != nil {
return nil, fmt.Errorf("could not read bytes from file: %v", err)
}
if uint16(n) < uint16(systemAreaSize) {
return nil, fmt.Errorf("only could read %d bytes from file", n)
}
// we do not do anything with the system area for now
// next read the volume descriptors, one at a time, until we hit the terminator
vds := make([]volumeDescriptor, 2)
terminated := false
var (
pvd *primaryVolumeDescriptor
vd volumeDescriptor
)
for i := 0; !terminated; i++ {
vdBytes := make([]byte, volumeDescriptorSize)
// read vdBytes
read, err = file.ReadAt(vdBytes, start+systemAreaSize+int64(i)*volumeDescriptorSize)
if err != nil {
return nil, fmt.Errorf("unable to read bytes for volume descriptor %d: %v", i, err)
}
if int64(read) != volumeDescriptorSize {
return nil, fmt.Errorf("read %d bytes instead of expected %d for volume descriptor %d", read, volumeDescriptorSize, i)
}
// convert to a vd structure
vd, err = volumeDescriptorFromBytes(vdBytes)
if err != nil {
return nil, fmt.Errorf("error reading Volume Descriptor: %v", err)
}
// is this a terminator?
//nolint:exhaustive // we only are looking for the terminators; all of the rest are covered by default
switch vd.Type() {
case volumeDescriptorTerminator:
terminated = true
case volumeDescriptorPrimary:
vds = append(vds, vd)
pvd, _ = vd.(*primaryVolumeDescriptor)
default:
vds = append(vds, vd)
}
}
// load up our path table and root directory entry
var (
pt *pathTable
rootDirEntry *directoryEntry
)
if pvd != nil {
rootDirEntry = pvd.rootDirectoryEntry
pathTableBytes := make([]byte, pvd.pathTableSize)
pathTableLocation := pvd.pathTableLLocation * uint32(pvd.blocksize)
read, err = file.ReadAt(pathTableBytes, int64(pathTableLocation))
if err != nil {
return nil, fmt.Errorf("unable to read path table of size %d at location %d: %v", pvd.pathTableSize, pathTableLocation, err)
}
if read != len(pathTableBytes) {
return nil, fmt.Errorf("read %d bytes of path table instead of expected %d at location %d", read, pvd.pathTableSize, pathTableLocation)
}
pt = parsePathTable(pathTableBytes)
}
// is system use enabled?
location := int64(rootDirEntry.location) * blocksize
// get the size of the directory entry
b := make([]byte, 1)
read, err = file.ReadAt(b, location)
if err != nil {
return nil, fmt.Errorf("unable to read root directory size at location %d: %v", location, err)
}
if read != len(b) {
return nil, fmt.Errorf("root directory entry size, read %d bytes instead of expected %d", read, len(b))
}
if b[0] == 0 {
return nil, fmt.Errorf("root directory entry size at location %d was zero, check header and blocksize, given as %d", location, blocksize)
}
// now read the whole entry
b = make([]byte, b[0])
read, err = file.ReadAt(b, location)
if err != nil {
return nil, fmt.Errorf("unable to read root directory entry at location %d: %v", location, err)
}
if read != len(b) {
return nil, fmt.Errorf("root directory entry, read %d bytes instead of expected %d", read, len(b))
}
// parse it - we do not have any handlers yet
de, err := parseDirEntry(b, &FileSystem{
suspEnabled: true,
file: file,
blocksize: blocksize,
})
if err != nil {
return nil, fmt.Errorf("error parsing root entry from bytes: %v", err)
}
// is the SUSP in use?
var (
suspEnabled bool
skipBytes uint8
suspHandlers []suspExtension
)
for _, ext := range de.extensions {
if s, ok := ext.(directoryEntrySystemUseExtensionSharingProtocolIndicator); ok {
suspEnabled = true
skipBytes = s.SkipBytes()
}
// register any extension handlers
if s, ok := ext.(directoryEntrySystemUseExtensionReference); suspEnabled && ok {
extHandler := getRockRidgeExtension(s.ExtensionID())
if extHandler != nil {
suspHandlers = append(suspHandlers, extHandler)
}
}
}
fs := &FileSystem{
workspace: "", // no workspace when we do nothing with it
start: start,
size: size,
file: file,
volumes: volumeDescriptors{
descriptors: vds,
primary: pvd,
},
blocksize: blocksize,
pathTable: pt,
rootDir: rootDirEntry,
suspEnabled: suspEnabled,
suspSkip: skipBytes,
suspExtensions: suspHandlers,
}
rootDirEntry.filesystem = fs
return fs, nil
}
// Type returns the type code for the filesystem. Always returns filesystem.TypeFat32
func (fs *FileSystem) Type() filesystem.Type {
return filesystem.TypeISO9660
}
// Mkdir make a directory at the given path. It is equivalent to `mkdir -p`, i.e. idempotent, in that:
//
// * It will make the entire tree path if it does not exist
// * It will not return an error if the path already exists
//
// if readonly and not in workspace, will return an error
func (fs *FileSystem) Mkdir(p string) error {
if fs.workspace == "" {
return fmt.Errorf("cannot write to read-only filesystem")
}
err := os.MkdirAll(path.Join(fs.workspace, p), 0o755)
if err != nil {
return fmt.Errorf("could not create directory %s: %v", p, err)
}
// we are not interesting in returning the entries
return err
}
// ReadDir return the contents of a given directory in a given filesystem.
//
// Returns a slice of os.FileInfo with all of the entries in the directory.
//
// Will return an error if the directory does not exist or is a regular file and not a directory
func (fs *FileSystem) ReadDir(p string) ([]os.FileInfo, error) {
var fi []os.FileInfo
// non-workspace: read from iso9660
// workspace: read from regular filesystem
if fs.workspace != "" {
fullPath := path.Join(fs.workspace, p)
// read the entries
dirEntries, err := os.ReadDir(fullPath)
if err != nil {
return nil, fmt.Errorf("could not read directory %s: %v", p, err)
}
for _, e := range dirEntries {
info, err := e.Info()
if err != nil {
return nil, fmt.Errorf("could not read directory %s: %v", p, err)
}
fi = append(fi, info)
}
} else {
dirEntries, err := fs.readDirectory(p)
if err != nil {
return nil, fmt.Errorf("error reading directory %s: %v", p, err)
}
fi = make([]os.FileInfo, 0, len(dirEntries))
for _, entry := range dirEntries {
// ignore any entry that is current directory or parent
if entry.isSelf || entry.isParent {
continue
}
fi = append(fi, entry)
}
}
return fi, nil
}
// OpenFile returns an io.ReadWriter from which you can read the contents of a file
// or write contents to the file
//
// accepts normal os.OpenFile flags
//
// returns an error if the file does not exist
func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
var f filesystem.File
var err error
// get the path and filename
dir := path.Dir(p)
filename := path.Base(p)
// if the dir == filename, then it is just /
if dir == filename {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
// cannot open to write or append or create if we do not have a workspace
writeMode := flag&os.O_WRONLY != 0 || flag&os.O_RDWR != 0 || flag&os.O_APPEND != 0 || flag&os.O_CREATE != 0 || flag&os.O_TRUNC != 0 || flag&os.O_EXCL != 0
if fs.workspace == "" {
if writeMode {
return nil, fmt.Errorf("cannot write to read-only filesystem")
}
// get the directory entries
var entries []*directoryEntry
entries, err = fs.readDirectory(dir)
if err != nil {
return nil, fmt.Errorf("could not read directory entries for %s", dir)
}
// we now know that the directory exists, see if the file exists
var targetEntry *directoryEntry
for _, e := range entries {
eName := e.Name()
// cannot do anything with directories
if eName == filename && e.IsDir() {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
if eName == filename {
// if we got this far, we have found the file
targetEntry = e
break
}
}
// see if the file exists
// if the file does not exist, and is not opened for os.O_CREATE, return an error
if targetEntry == nil {
return nil, fmt.Errorf("target file %s does not exist", p)
}
// now open the file
f = &File{
directoryEntry: targetEntry,
isReadWrite: false,
isAppend: false,
offset: 0,
}
} else {
f, err = os.OpenFile(path.Join(fs.workspace, p), flag, 0o644)
if err != nil {
return nil, fmt.Errorf("target file %s does not exist: %v", p, err)
}
}
return f, nil
}
// readDirectory - read directory entry on iso only (not workspace)
func (fs *FileSystem) readDirectory(p string) ([]*directoryEntry, error) {
var (
location, size uint32
err error
n int
)
// try from path table, then walk the directory tree, unless we were told explicitly not to
usePathtable := true
for _, e := range fs.suspExtensions {
usePathtable = e.UsePathtable()
if !usePathtable {
break
}
}
if usePathtable {
location = fs.pathTable.getLocation(p)
}
// if we found it, read the first directory entry to get the size
if location != 0 {
// we need 4 bytes to read the size of the directory; it is at offset 10 from beginning
dirb := make([]byte, 4)
n, err = fs.file.ReadAt(dirb, int64(location)*fs.blocksize+10)
if err != nil {
return nil, fmt.Errorf("could not read directory %s: %v", p, err)
}
if n != len(dirb) {
return nil, fmt.Errorf("read %d bytes instead of expected %d", n, len(dirb))
}
// convert to uint32
size = binary.LittleEndian.Uint32(dirb)
} else {
// if we could not find the location in the path table, try reading directly from the disk
// it is slow, but this is how Unix does it, since many iso creators *do* create illegitimate disks
location, size, err = fs.rootDir.getLocation(p)
if err != nil {
return nil, fmt.Errorf("unable to read directory tree for %s: %v", p, err)
}
}
// did we still not find it?
if location == 0 {
return nil, fmt.Errorf("could not find directory %s", p)
}
// we have a location, let's read the directories from it
b := make([]byte, size)
n, err = fs.file.ReadAt(b, int64(location)*fs.blocksize)
if err != nil {
return nil, fmt.Errorf("could not read directory entries for %s: %v", p, err)
}
if n != int(size) {
return nil, fmt.Errorf("reading directory %s returned %d bytes read instead of expected %d", p, n, size)
}
// parse the entries
entries, err := parseDirEntries(b, fs)
if err != nil {
return nil, fmt.Errorf("could not parse directory entries for %s: %v", p, err)
}
return entries, nil
}
func validateBlocksize(blocksize int64) error {
switch blocksize {
case 0, 2048, 4096, 8192:
return nil
default:
return fmt.Errorf("blocksize for ISO9660 must be one of 2048, 4096, 8192")
}
}
func (fs *FileSystem) Label() string {
if fs.volumes.primary == nil {
return ""
}
return fs.volumes.primary.volumeIdentifier
}
func (fs *FileSystem) SetLabel(string) error {
return fmt.Errorf("ISO9660 filesystem is read-only")
}
07070100000325000081A4000000000000000000000001645E367C00000E04000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/pathtable.go package iso9660
import (
"encoding/binary"
)
// pathTable represents an on-iso path table
type pathTable struct {
records []*pathTableEntry
}
type pathTableEntry struct {
nameSize uint8
size uint16
extAttrLength uint8
location uint32
parentIndex uint16
dirname string
}
func (pt *pathTable) equal(b *pathTable) bool {
switch {
case (pt == nil && b != nil) || (pt != nil && b == nil):
return false
case len(pt.records) != len(b.records):
return false
default:
for i, e := range pt.records {
if *e != *b.records[i] {
return false
}
}
}
return true
}
func (pt *pathTable) names() []string {
ret := make([]string, len(pt.records))
for i, v := range pt.records {
ret[i] = v.dirname
}
return ret
}
func (pt *pathTable) toLBytes() []byte {
b := make([]byte, 0)
for _, e := range pt.records {
name := []byte(e.dirname)
nameSize := len(name)
size := 8 + uint16(nameSize)
if nameSize%2 != 0 {
size++
}
b2 := make([]byte, size)
b2[0] = uint8(nameSize)
b2[1] = e.extAttrLength
binary.LittleEndian.PutUint32(b2[2:6], e.location)
binary.LittleEndian.PutUint16(b2[6:8], e.parentIndex)
copy(b2[8:8+nameSize], name)
if nameSize%2 != 0 {
b2[8+nameSize] = 0
}
b = append(b, b2...)
}
return b
}
func (pt *pathTable) toMBytes() []byte {
b := make([]byte, 0)
for _, e := range pt.records {
name := []byte(e.dirname)
nameSize := len(name)
size := 8 + uint16(nameSize)
if nameSize%2 != 0 {
size++
}
b2 := make([]byte, size)
b2[0] = uint8(nameSize)
b2[1] = e.extAttrLength
binary.BigEndian.PutUint32(b2[2:6], e.location)
binary.BigEndian.PutUint16(b2[6:8], e.parentIndex)
copy(b2[8:8+nameSize], name)
if nameSize%2 != 0 {
b2[8+nameSize] = 0
}
b = append(b, b2...)
}
return b
}
// getLocation gets the location of the extent that contains this path
// we can get the size because the first record always points to the current directory
func (pt *pathTable) getLocation(p string) uint32 {
// break path down into parts and levels
parts := splitPath(p)
// level represents the level of the parent
var level uint16 = 1
var location uint32
if len(parts) == 0 {
location = pt.records[0].location
} else {
current := parts[0]
// loop through the path table until we find our entry
// we always can go forward because of the known depth ordering of path table
for i, entry := range pt.records {
// did we find a match for our current level?
if entry.parentIndex == level && entry.dirname == current {
level = uint16(i)
if len(parts) > 1 {
parts = parts[1:]
} else {
// this is the final one, we found it, keep it
location = entry.location
break
}
}
}
}
return location
}
// parsePathTable load pathtable bytes into structures
func parsePathTable(b []byte) *pathTable {
totalSize := len(b)
entries := make([]*pathTableEntry, 0, 20)
for i := 0; i < totalSize; {
var nameSize = b[i]
// is it zeroes? If so, we are at the end
if nameSize == 0 {
break
}
size := 8 + uint16(nameSize)
if nameSize%2 != 0 {
size++
}
var extAttrSize = b[i+1]
location := binary.LittleEndian.Uint32(b[i+2 : i+6])
parent := binary.LittleEndian.Uint16(b[i+6 : i+8])
name := string(b[i+8 : i+8+int(nameSize)])
entry := &pathTableEntry{
nameSize: nameSize,
size: size,
extAttrLength: extAttrSize,
location: location,
parentIndex: parent,
dirname: name,
}
entries = append(entries, entry)
i += int(size)
}
return &pathTable{
records: entries,
}
}
07070100000326000081A4000000000000000000000001645E367C000085F3000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/rockridge.go package iso9660
import (
"encoding/binary"
"fmt"
"os"
"sort"
"time"
"gopkg.in/djherbis/times.v1"
)
const (
rockRidgeSignaturePosixAttributes = "PX"
rockRidgeSignaturePosixDeviceNumber = "PN"
rockRidgeSignatureSymbolicLink = "SL"
rockRidgeSignatureName = "NM"
rockRidgeSignatureChild = "CL"
rockRidgeSignatureParent = "PL"
rockRidgeSignatureRelocatedDirectory = "RE"
rockRidgeSignatureTimestamps = "TF"
rockRidgeSignatureSparseFile = "SF"
rockRidge110 = "RRIP_1991A"
rockRidge112 = "IEEE_P1282"
)
// rockRidgeExtension implements suspExtension interface
type rockRidgeExtension struct {
version string
id string
descriptor string
source string
pxLength int
sfLength int
}
func (r *rockRidgeExtension) ID() string {
return r.id
}
func (r *rockRidgeExtension) Descriptor() string {
return r.descriptor
}
func (r *rockRidgeExtension) Source() string {
return r.source
}
func (r *rockRidgeExtension) Version() uint8 {
return 1
}
func (r *rockRidgeExtension) Process(signature string, b []byte) (directoryEntrySystemUseExtension, error) {
// if we have a parser, use it, else use the raw parser
var (
entry directoryEntrySystemUseExtension
err error
)
switch signature {
case rockRidgeSignaturePosixAttributes:
entry, err = r.parsePosixAttributes(b)
case rockRidgeSignaturePosixDeviceNumber:
entry, err = r.parsePosixDeviceNumber(b)
case rockRidgeSignatureSymbolicLink:
entry, err = r.parseSymlink(b)
case rockRidgeSignatureName:
entry, err = r.parseName(b)
case rockRidgeSignatureChild:
entry, err = r.parseChildDirectory(b)
case rockRidgeSignatureParent:
entry, err = r.parseParentDirectory(b)
case rockRidgeSignatureRelocatedDirectory:
entry, err = r.parseRelocatedDirectory(b)
case rockRidgeSignatureTimestamps:
entry, err = r.parseTimestamps(b)
case rockRidgeSignatureSparseFile:
entry, err = r.parseSparseFile(b)
default:
return nil, ErrSuspNoHandler
}
if err != nil {
return nil, fmt.Errorf("error parsing %s extension by Rock Ridge : %v", signature, err)
}
return entry, nil
}
// get the rock ridge filename for a directory entry
func (r *rockRidgeExtension) GetFilename(de *directoryEntry) (string, error) {
found := false
name := ""
for _, e := range de.extensions {
if nm, ok := e.(rockRidgeName); ok {
found = true
name = nm.name
break
}
}
if !found {
return "", fmt.Errorf("could not find Rock Ridge filename property")
}
return name, nil
}
func (r *rockRidgeExtension) GetFileExtensions(fp string, isSelf, isParent bool) ([]directoryEntrySystemUseExtension, error) {
// we always do PX, TF, NM, SL order
ret := []directoryEntrySystemUseExtension{}
// do not follow symlinks
fi, err := os.Lstat(fp)
if err != nil {
return nil, fmt.Errorf("error reading file %s: %v", fp, err)
}
t, err := times.Lstat(fp)
if err != nil {
return nil, fmt.Errorf("error reading times %s: %v", fp, err)
}
// PX
nlink, uid, gid := statt(fi)
mtime := fi.ModTime()
atime := t.AccessTime()
ctime := t.ChangeTime()
ret = append(ret, rockRidgePosixAttributes{
mode: fi.Mode(),
linkCount: nlink,
uid: uid,
gid: gid,
length: r.pxLength,
})
// TF
tf := rockRidgeTimestamps{longForm: false, stamps: []rockRidgeTimestamp{
{timestampType: rockRidgeTimestampModify, time: mtime},
{timestampType: rockRidgeTimestampAccess, time: atime},
{timestampType: rockRidgeTimestampAttribute, time: ctime},
}}
ret = append(ret, tf)
// NM
if !isSelf && !isParent {
ret = append(ret, rockRidgeName{name: fi.Name()})
}
// SL
if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
// need the target if it is a symlink
target, err := os.Readlink(fp)
if err != nil {
return nil, fmt.Errorf("error reading symlink target at %s", fp)
}
ret = append(ret, rockRidgeSymlink{continued: false, name: target})
}
return ret, nil
}
func (r *rockRidgeExtension) GetFinalizeExtensions(fi *finalizeFileInfo) ([]directoryEntrySystemUseExtension, error) {
// we look for CL, PL, RE entries
ret := []directoryEntrySystemUseExtension{}
if fi.trueParent != nil {
ret = append(ret, rockRidgeRelocatedDirectory{}, rockRidgeParentDirectory{location: fi.trueParent.location})
}
if fi.trueChild != nil {
ret = append(ret, rockRidgeChildDirectory{location: fi.trueChild.location})
}
return ret, nil
}
// determine if a directory entry was relocated
func (r *rockRidgeExtension) Relocated(de *directoryEntry) bool {
relocated := false
for _, e := range de.extensions {
if _, ok := e.(rockRidgeRelocatedDirectory); ok {
relocated = true
break
}
}
return relocated
}
// Relocatable can rock ridge handle deep directory relocations? yes
func (r *rockRidgeExtension) Relocatable() bool {
return true
}
func (r *rockRidgeExtension) UsePathtable() bool {
return false
}
// Relocate restructure so that all directories are at a depth of 8 or fewer
func (r *rockRidgeExtension) Relocate(dirs map[string]*finalizeFileInfo) ([]*finalizeFileInfo, map[string]*finalizeFileInfo, error) {
files := make([]*finalizeFileInfo, 0)
root := dirs["."]
relocationDir := root
if relocationDir.depth == 8 {
return nil, nil, fmt.Errorf("cannot relocate when relocation parent already is max depth 8")
}
/* logic:
* 1. go down the directories
* 2. as soon as we find one whose depth > 8, move it to the parent
* 3. change the depth of it and all of its children to its new depth
* 4. reparent it
* 5. change child entries in the parent
*
* repeat until none is deeper than 8
*/
// deepers contains the list of all dirs exactly at one too deep, i.e. 9
deepers := make([]*finalizeFileInfo, 0)
for _, e := range dirs {
if e.depth == 9 {
deepers = append(deepers, e)
}
}
// repeat until deepers has no children of depth > 8
for {
if len(deepers) < 1 {
break
}
for _, e := range deepers {
// we have a depth greater than 8, so move it
e.trueParent = e.parent
e.parent = relocationDir
// create the file that represents it
children := make([]*finalizeFileInfo, 0)
for _, c := range e.trueParent.children {
if c != e {
children = append(children, e)
continue
}
// copy over but replace a few key items
content := []byte("Rock Ridge relocated")
replacer := &finalizeFileInfo{}
*replacer = *c
replacer.isDir = false
replacer.mode = c.mode & (^os.ModeDir)
replacer.size = int64(len(content))
replacer.content = content
replacer.trueChild = e
children = append(children, replacer)
}
e.trueParent.children = children
// cycle down and update the depth for all children
e.updateDepth(relocationDir.depth + 1)
}
// go through deepers, remove all of those that are not >8
deepers = make([]*finalizeFileInfo, 0)
for _, e := range dirs {
if e.depth == 9 {
deepers = append(deepers, e)
}
}
}
return files, dirs, nil
}
// find the directory location
func (r *rockRidgeExtension) GetDirectoryLocation(de *directoryEntry) uint32 {
newEntry := uint32(0)
for _, e := range de.extensions {
if child, ok := e.(rockRidgeChildDirectory); ok {
newEntry = child.location
break
}
}
return newEntry
}
func getRockRidgeExtension(id string) *rockRidgeExtension {
var ret *rockRidgeExtension // defaults to nil
switch id {
case rockRidge110:
ret = &rockRidgeExtension{
id: id,
version: "1.10",
descriptor: "THE ROCK RIDGE INTERCHANGE PROTOCOL PROVIDES SUPPORT FOR POSIX FILE SYSTEM SEMANTICS",
source: "PLEASE CONTACT DISC PUBLISHER FOR SPECIFICATION SOURCE. SEE PUBLISHER IDENTIFIER IN PRIMARY VOLUME DESCRIPTOR FOR CONTACT INFORMATION.",
pxLength: 36,
sfLength: 12,
}
case rockRidge112:
ret = &rockRidgeExtension{
id: id,
version: "1.12",
descriptor: "THE IEEE P1282 PROTOCOL PROVIDES SUPPORT FOR POSIX FILE SYSTEM SEMANTICS.",
source: "PLEASE CONTACT THE IEEE STANDARDS DEPARTMENT, PISCATAWAY, NJ, USA FOR THE P1282 SPECIFICATION.",
pxLength: 44,
sfLength: 21,
}
}
return ret
}
// rockRidgePosixAttributes
type rockRidgePosixAttributes struct {
mode os.FileMode
saveSwapText bool
length int
linkCount uint32
uid uint32
gid uint32
serial uint32
}
func (d rockRidgePosixAttributes) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgePosixAttributes)
return ok && t == d
}
func (d rockRidgePosixAttributes) Signature() string {
return rockRidgeSignaturePosixAttributes
}
func (d rockRidgePosixAttributes) Length() int {
return d.length
}
func (d rockRidgePosixAttributes) Version() uint8 {
return 1
}
func (d rockRidgePosixAttributes) Data() []byte {
ret := make([]byte, d.length-4)
modes := uint32(0)
regular := true
m := d.mode
// get Unix permission bits - golang and Rock Ridge use the same ones
modes |= uint32(m & 0o777)
// get setuid and setgid
modes |= uint32(m & os.ModeSetuid)
modes |= uint32(m & os.ModeSetgid)
// save swapped text mode seems to have no parallel
if d.saveSwapText {
modes |= 0o1000
}
// the rest of the modes do not use the same bits on Rock Ridge and on golang
if m&os.ModeSocket == os.ModeSocket {
modes |= 0o140000
regular = false
}
if m&os.ModeSymlink == os.ModeSymlink {
modes |= 0o120000
regular = false
}
if m&os.ModeDevice == os.ModeDevice {
regular = false
if m&os.ModeCharDevice == os.ModeCharDevice {
modes |= 0o20000
} else {
modes |= 0o60000
}
}
if m&os.ModeDir == os.ModeDir {
modes |= 0o40000
regular = false
}
if m&os.ModeNamedPipe == os.ModeNamedPipe {
modes |= 0o10000
regular = false
}
if regular {
modes |= 0o100000
}
binary.LittleEndian.PutUint32(ret[0:4], modes)
binary.BigEndian.PutUint32(ret[4:8], modes)
binary.LittleEndian.PutUint32(ret[8:12], d.linkCount)
binary.BigEndian.PutUint32(ret[12:16], d.linkCount)
binary.LittleEndian.PutUint32(ret[16:20], d.uid)
binary.BigEndian.PutUint32(ret[20:24], d.uid)
binary.LittleEndian.PutUint32(ret[24:28], d.gid)
binary.BigEndian.PutUint32(ret[28:32], d.gid)
if d.length == 44 {
binary.LittleEndian.PutUint32(ret[32:36], d.serial)
binary.BigEndian.PutUint32(ret[36:40], d.serial)
}
return ret
}
func (d rockRidgePosixAttributes) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], rockRidgeSignaturePosixAttributes)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d rockRidgePosixAttributes) Continuable() bool {
return false
}
func (d rockRidgePosixAttributes) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parsePosixAttributes(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := r.pxLength
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PX extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PX extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PX extension must be version 1, was %d", version)
}
// file mode
modes := binary.LittleEndian.Uint32(b[4:8])
var m uint32
// get Unix permission bits - golang and Rock Ridge use the same ones
m |= (modes & 0o777)
// get setuid and setgid
m |= (modes & uint32(os.ModeSetuid))
m |= (modes & uint32(os.ModeSetgid))
// save swapped text mode seems to have no parallel
var saveSwapText bool
if modes&0o01000 != 0 {
saveSwapText = true
}
// the rest of the modes do not use the same bits on Rock Ridge and on golang, and are exclusive
switch {
case modes&0o140000 == 0o140000:
m |= uint32(os.ModeSocket)
case modes&0o120000 == 0o120000:
m |= uint32(os.ModeSymlink)
case modes&0o20000 == 0o20000:
m |= uint32(os.ModeCharDevice | os.ModeDevice)
case modes&0o60000 == 0o60000:
m |= uint32(os.ModeDevice)
case modes&0o40000 == 0o40000:
m |= uint32(os.ModeDir)
case modes&0o10000 == 0o10000:
m |= uint32(os.ModeNamedPipe)
}
var serial uint32
if len(b) == 44 {
serial = binary.LittleEndian.Uint32(b[36:40])
}
return rockRidgePosixAttributes{
mode: os.FileMode(m),
saveSwapText: saveSwapText,
linkCount: binary.LittleEndian.Uint32(b[12:16]),
uid: binary.LittleEndian.Uint32(b[20:24]),
gid: binary.LittleEndian.Uint32(b[28:32]),
serial: serial,
length: targetSize,
}, nil
}
// rockRidgePosixDeviceNumber
type rockRidgePosixDeviceNumber struct {
high uint32
low uint32
}
func (d rockRidgePosixDeviceNumber) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgePosixDeviceNumber)
return ok && t == d
}
func (d rockRidgePosixDeviceNumber) Signature() string {
return rockRidgeSignaturePosixDeviceNumber
}
func (d rockRidgePosixDeviceNumber) Length() int {
return 20
}
func (d rockRidgePosixDeviceNumber) Version() uint8 {
return 1
}
func (d rockRidgePosixDeviceNumber) Data() []byte {
ret := make([]byte, 16)
binary.LittleEndian.PutUint32(ret[0:4], d.high)
binary.BigEndian.PutUint32(ret[4:8], d.high)
binary.LittleEndian.PutUint32(ret[8:12], d.low)
binary.BigEndian.PutUint32(ret[12:16], d.low)
return ret
}
func (d rockRidgePosixDeviceNumber) Bytes() []byte {
ret := make([]byte, 4)
copy(ret[0:2], rockRidgeSignaturePosixDeviceNumber)
ret[2] = uint8(d.Length())
ret[3] = d.Version()
ret = append(ret, d.Data()...)
return ret
}
func (d rockRidgePosixDeviceNumber) Continuable() bool {
return false
}
func (d rockRidgePosixDeviceNumber) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parsePosixDeviceNumber(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 20
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PN extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PN extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PN extension must be version 1, was %d", version)
}
return rockRidgePosixDeviceNumber{
high: binary.LittleEndian.Uint32(b[4:8]),
low: binary.LittleEndian.Uint32(b[12:16]),
}, nil
}
// rockRidgeSymlink
// a symlink can be greater than the 254 max size of a SUSP extension, so it may continue across multiple extension entries
// a rockRidgeSymlink can represent the individual components, or an entire set merged together
// Bytes(), when called, will provide as many consecutive symlink bytes as needed
type rockRidgeSymlink struct {
continued bool // if this is continuted in another rockRidgeSymlink entry
name string
}
func (d rockRidgeSymlink) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeSymlink)
return ok && t == d
}
func (d rockRidgeSymlink) Signature() string {
return rockRidgeSignatureSymbolicLink
}
func (d rockRidgeSymlink) Length() int {
// basic 4 bytes for all SUSP entries, 1 byte for flags, 1 for Component Flags, 1 for Component Len, name
return 4 + 1 + 2 + len(d.name)
}
func (d rockRidgeSymlink) Version() uint8 {
return 1
}
func (d rockRidgeSymlink) Data() []byte {
return []byte{}
}
func (d rockRidgeSymlink) Bytes() []byte {
// This could be a single entry, or so long that you need multiple concatenated
// maximum size of a single entry is 254 bytes
// each SL record requires 4 bytes of header, 1 byte of flags, and 2 bytes of flags and length in component area
// so available = 254-(4+1+2) = 247
headerSize := 4 + 1 + 2
maxComponentSize := directoryEntryMaxSize - headerSize
// break the target of the link down into component parts, and then we can calculate the size
components := splitPath(d.name)
root := false
if d.name[0] == "/"[0] {
root = true
}
// go through the components, convert to []byte and add on
cBytes := make([][]byte, 0)
if root {
// component flag, component len, component of path
cBytes = append(cBytes, []byte{0x08, 0x0})
}
for _, e := range components {
switch e {
case "..":
cBytes = append(cBytes, []byte{0x4, 0x0})
case ".":
cBytes = append(cBytes, []byte{0x2, 0x0})
default:
cBytes = append(cBytes, []byte{0x0, byte(len(e))}, []byte(e))
}
}
// we now have cBytes, which is all of the component parts
// split into SL entries as needed
b := make([]byte, 0)
b2 := make([]byte, 5)
copy(b2[0:2], rockRidgeSignatureSymbolicLink)
// we set size and continuing flag when we are done with this entry
b2[3] = d.Version()
componentByteCount := 0
for _, e := range cBytes {
if len(e)+componentByteCount > maxComponentSize {
// cannot add it, so close the existing one and start a new record
b2[2] = uint8(componentByteCount + 5)
b2[4] = 1
b = append(b, b2...)
// new record
b2 = make([]byte, 5)
copy(b2[0:2], rockRidgeSignatureSymbolicLink)
// we set size and continuing flag when we are done with this entry
b2[3] = d.Version()
componentByteCount = 0
}
b2 = append(b2, e...)
componentByteCount += len(e)
}
if len(b2) > 0 {
b2[2] = uint8(componentByteCount + 5)
// this one is not continuing, it is the last
b2[4] = 0
b = append(b, b2...)
}
return b
}
func (d rockRidgeSymlink) Continuable() bool {
return d.continued
}
func (d rockRidgeSymlink) Merge(links []directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
for _, e := range links {
if l, ok := e.(rockRidgeSymlink); ok {
d.name += l.name
}
}
d.continued = false
return d
}
func (r *rockRidgeExtension) parseSymlink(b []byte) (directoryEntrySystemUseExtension, error) {
size := int(b[2])
if size != len(b) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge SL extension received %d bytes, but byte 2 indicated %d", len(b), size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge SL extension must be version 1, was %d", version)
}
continued := b[4] == 1
name := ""
for i := 5; i < len(b); {
// make it easier to work with
b2 := b[i:]
// find out how many bytes we will read
flags := b2[0]
size := b2[1]
switch {
case flags&0x1 == 0x1:
name += "."
case flags&0x2 == 0x2:
name += ".."
case flags&0x3 == 0x3:
name = "/"
case size > 0:
name += "/" + string(b2[2:2+size])
}
i += 2 + int(size)
}
return rockRidgeSymlink{
continued: continued,
name: name,
}, nil
}
// rockRidgeName
// a name can be greater than the 254 max size of a SUSP extension, so it may continue across multiple extension entries
// a rockRidgeName can represent the individual components, or an entire set merged together
// Bytes(), when called, will provide as many consecutive name bytes as needed
type rockRidgeName struct {
continued bool // if this is continued in another rockRidgeName entry
current bool // refers to current directory, i.e. "."
parent bool // refers to parent directory, i.e. ".."
name string
}
func (d rockRidgeName) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeName)
return ok && t == d
}
func (d rockRidgeName) Signature() string {
return rockRidgeSignatureName
}
func (d rockRidgeName) Length() int {
// basic 4 bytes for all SUSP entries, 1 byte for flags, name
return 4 + 1 + len(d.name)
}
func (d rockRidgeName) Version() uint8 {
return 1
}
func (d rockRidgeName) Data() []byte {
return []byte{}
}
func (d rockRidgeName) Bytes() []byte {
// This could be a single entry, or so long that you need multiple concatenated
// maximum size of a single entry is 254 bytes
// each SL record requires 4 bytes of header, 1 byte of flags
// so available = 254-(4+1) = 249
headerSize := 4 + 1
maxComponentSize := directoryEntryMaxSize - headerSize
// count how many entries we will need
nameBytes := []byte(d.name)
count := len(nameBytes) / maxComponentSize
if len(nameBytes)%maxComponentSize > 0 {
count++
}
b := make([]byte, 0)
for i := 0; i < count; i++ {
b2 := make([]byte, 5)
copy(b2[0:2], rockRidgeSignatureName)
// we set size and continuing flag when we are done with this entry
b2[3] = d.Version()
copyBytes := nameBytes
continuing := 0
if len(nameBytes) > maxComponentSize {
copyBytes = nameBytes[:maxComponentSize]
continuing = 1
}
b2 = append(b2, copyBytes...)
b2[2] = 5 + uint8(len(copyBytes))
flags := 0x0 | continuing
if d.current {
flags |= 0x2
}
if d.parent {
flags |= 0x4
}
b2[4] = byte(flags)
b = append(b, b2...)
}
return b
}
func (d rockRidgeName) Continuable() bool {
return d.continued
}
func (d rockRidgeName) Merge(names []directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
for _, e := range names {
if n, ok := e.(rockRidgeName); ok {
d.name += n.name
}
}
d.continued = false
return d
}
func (r *rockRidgeExtension) parseName(b []byte) (directoryEntrySystemUseExtension, error) {
size := int(b[2])
if size != len(b) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge NM extension received %d bytes, but byte 2 indicated %d", len(b), size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge NM extension must be version 1, was %d", version)
}
continued := b[4]&1 != 0
current := b[4]&2 != 0
parent := b[4]&4 != 0
name := ""
if size > 5 {
name = string(b[5:])
}
return rockRidgeName{
continued: continued,
name: name,
current: current,
parent: parent,
}, nil
}
// rockRidgeTimestamp constants - these are the bitmasks for the flag field
const (
rockRidgeTimestampCreation uint8 = 1
rockRidgeTimestampModify uint8 = 2
rockRidgeTimestampAccess uint8 = 4
rockRidgeTimestampAttribute uint8 = 8
rockRidgeTimestampBackup uint8 = 16
rockRidgeTimestampExpiration uint8 = 32
rockRidgeTimestampEffective uint8 = 64
rockRidgeTimestampLongForm uint8 = 128
)
// rockRidgeTimestamp
type rockRidgeTimestamp struct {
timestampType uint8
time time.Time
}
func (r rockRidgeTimestamp) Equal(o rockRidgeTimestamp) bool {
// we compare down to the second, not below
return r.timestampType == o.timestampType && r.time.Unix() == o.time.Unix()
}
func (r rockRidgeTimestamp) Close(o rockRidgeTimestamp) bool {
// we compare within 5 seconds
margin := int64(5)
diff := r.time.Unix() - o.time.Unix()
return r.timestampType == o.timestampType && diff < margin && diff > -margin
}
type rockRidgeTimestamps struct {
longForm bool
stamps []rockRidgeTimestamp
}
type rockRidgeTimestampByBitOrder []rockRidgeTimestamp
func (s rockRidgeTimestampByBitOrder) Len() int {
return len(s)
}
func (s rockRidgeTimestampByBitOrder) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
func (s rockRidgeTimestampByBitOrder) Less(i, j int) bool {
return s[i].timestampType < s[j].timestampType
}
func (d rockRidgeTimestamps) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeTimestamps)
matched := ok
if matched && t.longForm == d.longForm && len(d.stamps) == len(t.stamps) {
for i, e := range d.stamps {
if !e.Equal(t.stamps[i]) {
matched = false
break
}
}
} else {
matched = false
}
return matched
}
func (d rockRidgeTimestamps) Close(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeTimestamps)
matched := ok
if matched && t.longForm == d.longForm && len(d.stamps) == len(t.stamps) {
for i, e := range d.stamps {
if !e.Close(t.stamps[i]) {
matched = false
break
}
}
} else {
matched = false
}
return matched
}
func (d rockRidgeTimestamps) Signature() string {
return rockRidgeSignatureTimestamps
}
func (d rockRidgeTimestamps) Length() int {
entryLength := 7
if d.longForm {
entryLength = 17
}
return 5 + entryLength*len(d.stamps)
}
func (d rockRidgeTimestamps) Version() uint8 {
return 1
}
func (d rockRidgeTimestamps) Data() []byte {
return []byte{}
}
func (d rockRidgeTimestamps) Bytes() []byte {
b := make([]byte, 5)
copy(b[0:2], rockRidgeSignatureTimestamps)
b[2] = uint8(d.Length())
b[3] = d.Version()
if d.longForm {
b[4] |= rockRidgeTimestampLongForm
}
// now get all of the timestamps
// these have to be in a specific order
// creation, modify, access, attributes, backup, expiration, effective
// this is the increasing but order they are in anyways
sort.Sort(rockRidgeTimestampByBitOrder(d.stamps))
for _, t := range d.stamps {
var b2 []byte
b[4] |= t.timestampType
if d.longForm {
b2 = timeToDecBytes(t.time)
} else {
b2 = timeToBytes(t.time)
}
b = append(b, b2...)
}
return b
}
func (d rockRidgeTimestamps) Continuable() bool {
return false
}
func (d rockRidgeTimestamps) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parseTimestamps(b []byte) (directoryEntrySystemUseExtension, error) {
size := b[2]
if int(size) != len(b) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge TF extension has %d bytes, but byte 2 indicated %d", len(b), size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge TF extension must be version 1, was %d", version)
}
// what timestamps are recorded?
flags := b[4]
// go through them one by one in order
entryLength := 7
longForm := false
if flags&rockRidgeTimestampLongForm != 0 {
entryLength = 17
longForm = true
}
entries := make([]rockRidgeTimestamp, 0)
tfBytes := b[5:]
tfTypes := []uint8{rockRidgeTimestampCreation, rockRidgeTimestampModify, rockRidgeTimestampAccess, rockRidgeTimestampAttribute,
rockRidgeTimestampBackup, rockRidgeTimestampExpiration, rockRidgeTimestampEffective}
for _, tf := range tfTypes {
if flags&tf == 0 {
continue
}
timeBytes := tfBytes[:entryLength]
tfBytes = tfBytes[entryLength:]
var (
t time.Time
err error
)
if longForm {
t, err = decBytesToTime(timeBytes)
if err != nil {
return nil, fmt.Errorf("could not process timestamp %d bytes to long form bytes: %v % x", tf, err, timeBytes)
}
} else {
t = bytesToTime(timeBytes)
}
entry := rockRidgeTimestamp{
time: t,
timestampType: tf,
}
entries = append(entries, entry)
}
return rockRidgeTimestamps{
stamps: entries,
longForm: longForm,
}, nil
}
// rockRidgeSparseFile
type rockRidgeSparseFile struct {
length int
high uint32
low uint32
tableDepth uint8
}
func (d rockRidgeSparseFile) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeSparseFile)
return ok && t == d
}
func (d rockRidgeSparseFile) Signature() string {
return rockRidgeSignatureSparseFile
}
func (d rockRidgeSparseFile) Length() int {
return d.length
}
func (d rockRidgeSparseFile) Version() uint8 {
return 1
}
func (d rockRidgeSparseFile) Data() []byte {
return []byte{}
}
func (d rockRidgeSparseFile) Bytes() []byte {
b := make([]byte, d.length)
copy(b[0:2], rockRidgeSignatureSparseFile)
b[2] = uint8(d.Length())
b[3] = d.Version()
binary.LittleEndian.PutUint32(b[4:8], d.high)
binary.BigEndian.PutUint32(b[8:12], d.high)
if d.length == 21 {
binary.LittleEndian.PutUint32(b[12:16], d.low)
binary.BigEndian.PutUint32(b[16:20], d.low)
b[20] = d.tableDepth
}
return b
}
func (d rockRidgeSparseFile) Continuable() bool {
return false
}
func (d rockRidgeSparseFile) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parseSparseFile(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := r.sfLength
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge SF extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge SF extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge SF extension must be version 1, was %d", version)
}
sf := &rockRidgeSparseFile{
high: binary.LittleEndian.Uint32(b[4:8]),
length: targetSize,
}
if targetSize == 21 {
sf.low = binary.LittleEndian.Uint32(b[12:16])
sf.tableDepth = b[20]
}
return sf, nil
}
// rockRidgeChildDirectory
type rockRidgeChildDirectory struct {
location uint32
}
func (d rockRidgeChildDirectory) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeChildDirectory)
return ok && t == d
}
func (d rockRidgeChildDirectory) Signature() string {
return rockRidgeSignatureChild
}
func (d rockRidgeChildDirectory) Length() int {
return 12
}
func (d rockRidgeChildDirectory) Version() uint8 {
return 1
}
func (d rockRidgeChildDirectory) Data() []byte {
return []byte{}
}
func (d rockRidgeChildDirectory) Bytes() []byte {
b := make([]byte, 12)
copy(b[0:2], rockRidgeSignatureChild)
b[2] = uint8(d.Length())
b[3] = d.Version()
binary.LittleEndian.PutUint32(b[4:8], d.location)
binary.BigEndian.PutUint32(b[8:12], d.location)
return b
}
func (d rockRidgeChildDirectory) Continuable() bool {
return false
}
func (d rockRidgeChildDirectory) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parseChildDirectory(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 12
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge CL extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge CL extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge CL extension must be version 1, was %d", version)
}
return rockRidgeChildDirectory{
location: binary.LittleEndian.Uint32(b[4:8]),
}, nil
}
// rockRidgeParentDirectory
type rockRidgeParentDirectory struct {
location uint32
}
func (d rockRidgeParentDirectory) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeParentDirectory)
return ok && t == d
}
func (d rockRidgeParentDirectory) Signature() string {
return rockRidgeSignatureParent
}
func (d rockRidgeParentDirectory) Length() int {
return 12
}
func (d rockRidgeParentDirectory) Version() uint8 {
return 1
}
func (d rockRidgeParentDirectory) Data() []byte {
return []byte{}
}
func (d rockRidgeParentDirectory) Bytes() []byte {
b := make([]byte, 12)
copy(b[0:2], rockRidgeSignatureParent)
b[2] = uint8(d.Length())
b[3] = d.Version()
binary.LittleEndian.PutUint32(b[4:8], d.location)
binary.BigEndian.PutUint32(b[8:12], d.location)
return b
}
func (d rockRidgeParentDirectory) Continuable() bool {
return false
}
func (d rockRidgeParentDirectory) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parseParentDirectory(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 12
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PL extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PL extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge PL extension must be version 1, was %d", version)
}
return rockRidgeParentDirectory{
location: binary.LittleEndian.Uint32(b[4:8]),
}, nil
}
// rockRidgeRelocatedDirectory
type rockRidgeRelocatedDirectory struct {
}
func (d rockRidgeRelocatedDirectory) Equal(o directoryEntrySystemUseExtension) bool {
t, ok := o.(rockRidgeRelocatedDirectory)
return ok && t == d
}
func (d rockRidgeRelocatedDirectory) Signature() string {
return rockRidgeSignatureRelocatedDirectory
}
func (d rockRidgeRelocatedDirectory) Length() int {
return 8
}
func (d rockRidgeRelocatedDirectory) Version() uint8 {
return 1
}
func (d rockRidgeRelocatedDirectory) Data() []byte {
return []byte{}
}
func (d rockRidgeRelocatedDirectory) Bytes() []byte {
b := make([]byte, 8)
copy(b[0:2], rockRidgeSignatureRelocatedDirectory)
b[2] = uint8(d.Length())
b[3] = d.Version()
return b
}
func (d rockRidgeRelocatedDirectory) Continuable() bool {
return false
}
func (d rockRidgeRelocatedDirectory) Merge([]directoryEntrySystemUseExtension) directoryEntrySystemUseExtension {
return nil
}
func (r *rockRidgeExtension) parseRelocatedDirectory(b []byte) (directoryEntrySystemUseExtension, error) {
targetSize := 4
if len(b) != targetSize {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge RE extension must be %d bytes, but received %d", targetSize, len(b))
}
size := b[2]
if size != uint8(targetSize) {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge RE extension must be %d bytes, but byte 2 indicated %d", targetSize, size)
}
version := b[3]
if version != 1 {
//nolint:stylecheck // "Rock Ridge" is a proper noun
return nil, fmt.Errorf("Rock Ridge RE extension must be version 1, was %d", version)
}
return rockRidgeRelocatedDirectory{}, nil
}
07070100000327000081A4000000000000000000000001645E367C00000214000000000000000000000000000000000000005A00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/statt_others.go //go:build !windows
// +build !windows
//nolint:unconvert // linter gets confused in this file
package iso9660
import (
"os"
"syscall"
)
func statt(fi os.FileInfo) (links, uid, gid uint32) {
if sys := fi.Sys(); sys != nil {
if stat, ok := sys.(*syscall.Stat_t); ok {
links, uid, gid = uint32(stat.Nlink), stat.Uid, stat.Gid
}
}
return links, uid, gid
}
//nolint:deadcode // this is here solely so that linter does not complain on darwin about unconvert
func unused() uint32 {
var f uint32 = 25
return uint32(f)
}
07070100000328000081A4000000000000000000000001645E367C00000085000000000000000000000000000000000000005B00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/statt_windows.go // +build windows
package iso9660
func statt(sys interface{}) (uint32, uint32, uint32) {
return uint32(0), uint32(0), uint32(0)
}
07070100000329000081A4000000000000000000000001645E367C0000060B000000000000000000000000000000000000005200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/util.go package iso9660
import (
"strings"
)
const (
// KB represents one KB
KB int64 = 1024
// MB represents one MB
MB int64 = 1024 * KB
// GB represents one GB
GB int64 = 1024 * MB
// TB represents one TB
TB int64 = 1024 * GB
)
func universalizePath(p string) string {
// globalize the separator
return strings.ReplaceAll(p, `\`, "/")
}
func splitPath(p string) []string {
ps := universalizePath(p)
// we need to split such that each one ends in "/", except possibly the last one
parts := strings.Split(ps, "/")
// eliminate empty parts
ret := make([]string, 0)
for _, sub := range parts {
if sub != "" {
ret = append(ret, sub)
}
}
return ret
}
func ucs2StringToBytes(s string) []byte {
rs := []rune(s)
l := len(rs)
b := make([]byte, 0, 2*l)
// big endian
for _, r := range rs {
tmpb := []byte{byte(r >> 8), byte(r & 0x00ff)}
b = append(b, tmpb...)
}
return b
}
// bytesToUCS2String convert bytes to UCS-2. We aren't 100% sure that this is right,
// as it is possible to pass it an odd number of characters. But good enough for now.
func bytesToUCS2String(b []byte) string {
r := make([]rune, 0, 30)
// now we can iterate - be careful in case we were given an odd number of bytes
for i := 0; i < len(b); {
// little endian
var val uint16
if i >= len(b)-1 {
val = uint16(b[i])
} else {
val = uint16(b[i])<<8 + uint16(b[i+1])
}
r = append(r, rune(val))
i += 2
}
return string(r)
}
// maxInt returns the larger of x or y.
func maxInt(x, y int) int {
if x < y {
return y
}
return x
}
0707010000032A000081A4000000000000000000000001645E367C0000497E000000000000000000000000000000000000005F00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/iso9660/volume_descriptor.go package iso9660
import (
"bytes"
"encoding/binary"
"fmt"
"strconv"
"time"
)
type volumeDescriptorType uint8
const (
volumeDescriptorBoot volumeDescriptorType = 0x00
volumeDescriptorPrimary volumeDescriptorType = 0x01
volumeDescriptorSupplementary volumeDescriptorType = 0x02
volumeDescriptorPartition volumeDescriptorType = 0x03
volumeDescriptorTerminator volumeDescriptorType = 0xff
)
const (
isoIdentifier uint64 = 0x4344303031 // string "CD001"
isoVersion uint8 = 0x01
bootSystemIdentifier = "EL TORITO SPECIFICATION"
)
// volumeDescriptor interface for any given type of volume descriptor
type volumeDescriptor interface {
Type() volumeDescriptorType
toBytes() []byte
equal(volumeDescriptor) bool
}
type primaryVolumeDescriptor struct {
systemIdentifier string // length 32 bytes
volumeIdentifier string // length 32 bytes
volumeSize uint32 // in blocks
setSize uint16
sequenceNumber uint16
blocksize uint16
pathTableSize uint32
pathTableLLocation uint32
pathTableLOptionalLocation uint32
pathTableMLocation uint32
pathTableMOptionalLocation uint32
rootDirectoryEntry *directoryEntry
volumeSetIdentifier string // 128 bytes
publisherIdentifier string // 128 bytes
preparerIdentifier string // 128 bytes
applicationIdentifier string // 128 bytes
copyrightFile string // 37 bytes
abstractFile string // 37 bytes
bibliographicFile string // 37 bytes
creation time.Time
modification time.Time
expiration time.Time
effective time.Time
}
type bootVolumeDescriptor struct {
location uint32 // length 1977 bytes; trailing 0x00 are stripped off
}
type terminatorVolumeDescriptor struct {
}
//nolint:structcheck // we accept some unused fields as useful for reference
type supplementaryVolumeDescriptor struct {
volumeFlags uint8
systemIdentifier string // length 32 bytes
volumeIdentifier string // length 32 bytes
volumeSize uint64 // in bytes
escapeSequences []byte // 32 bytes
setSize uint16
sequenceNumber uint16
blocksize uint16
pathTableSize uint32
pathTableLLocation uint32
pathTableLOptionalLocation uint32
pathTableMLocation uint32
pathTableMOptionalLocation uint32
rootDirectoryEntry *directoryEntry
volumeSetIdentifier string // 128 bytes
publisherIdentifier string // 128 bytes
preparerIdentifier string // 128 bytes
applicationIdentifier string // 128 bytes
copyrightFile string // 37 bytes
abstractFile string // 37 bytes
bibliographicFile string // 37 bytes
creation time.Time
modification time.Time
expiration time.Time
effective time.Time
}
type partitionVolumeDescriptor struct {
data []byte // length 2048 bytes; trailing 0x00 are stripped off
}
type volumeDescriptors struct {
descriptors []volumeDescriptor
primary *primaryVolumeDescriptor
}
func (v *volumeDescriptors) equal(a *volumeDescriptors) bool {
if len(v.descriptors) != len(a.descriptors) {
return false
}
// just convert everything to bytes and compare
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *volumeDescriptors) toBytes() []byte {
b := make([]byte, 0, 20)
for _, d := range v.descriptors {
b = append(b, d.toBytes()...)
}
return b
}
// primaryVolumeDescriptor
func (v *primaryVolumeDescriptor) Type() volumeDescriptorType {
return volumeDescriptorPrimary
}
func (v *primaryVolumeDescriptor) equal(a volumeDescriptor) bool {
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *primaryVolumeDescriptor) toBytes() []byte {
b := volumeDescriptorFirstBytes(volumeDescriptorPrimary)
copy(b[8:40], v.systemIdentifier)
copy(b[40:72], v.volumeIdentifier)
binary.LittleEndian.PutUint32(b[80:84], v.volumeSize)
binary.BigEndian.PutUint32(b[84:88], v.volumeSize)
binary.LittleEndian.PutUint16(b[120:122], v.setSize)
binary.BigEndian.PutUint16(b[122:124], v.setSize)
binary.LittleEndian.PutUint16(b[124:126], v.sequenceNumber)
binary.BigEndian.PutUint16(b[126:128], v.sequenceNumber)
binary.LittleEndian.PutUint16(b[128:130], v.blocksize)
binary.BigEndian.PutUint16(b[130:132], v.blocksize)
binary.LittleEndian.PutUint32(b[132:136], v.pathTableSize)
binary.BigEndian.PutUint32(b[136:140], v.pathTableSize)
binary.LittleEndian.PutUint32(b[140:144], v.pathTableLLocation)
binary.LittleEndian.PutUint32(b[144:148], v.pathTableLOptionalLocation)
binary.BigEndian.PutUint32(b[148:152], v.pathTableMLocation)
binary.BigEndian.PutUint32(b[152:156], v.pathTableMOptionalLocation)
rootDirEntry := make([]byte, 34)
if v.rootDirectoryEntry != nil {
// we will skip the extensions anyways, so the CE blocks do not matter
rootDirEntrySlice, _ := v.rootDirectoryEntry.toBytes(true, []uint32{})
rootDirEntry = rootDirEntrySlice[0]
}
copy(b[156:156+34], rootDirEntry)
copy(b[190:190+128], v.volumeSetIdentifier)
copy(b[318:318+128], v.publisherIdentifier)
copy(b[446:446+128], v.preparerIdentifier)
copy(b[574:574+128], v.applicationIdentifier)
copy(b[702:702+37], v.copyrightFile)
copy(b[739:739+37], v.abstractFile)
copy(b[776:776+37], v.bibliographicFile)
copy(b[813:813+17], timeToDecBytes(v.creation))
copy(b[830:830+17], timeToDecBytes(v.modification))
copy(b[847:847+17], timeToDecBytes(v.expiration))
copy(b[864:864+17], timeToDecBytes(v.effective))
// these two are set by the standard
b[881] = 1
b[882] = 0
return b
}
// volumeDescriptorFromBytes create a volumeDescriptor struct from bytes
func volumeDescriptorFromBytes(b []byte) (volumeDescriptor, error) {
if len(b) != int(volumeDescriptorSize) {
return nil, fmt.Errorf("cannot read volume descriptor from bytes of length %d, must be %d", len(b), volumeDescriptorSize)
}
// validate the signature
tmpb := make([]byte, 8)
copy(tmpb[3:8], b[1:6])
signature := binary.BigEndian.Uint64(tmpb)
if signature != isoIdentifier {
return nil, fmt.Errorf("mismatched ISO identifier in Volume Descriptor. Found %x expected %x", signature, isoIdentifier)
}
// validate the version
version := b[6]
if version != isoVersion {
return nil, fmt.Errorf("mismatched ISO version in Volume Descriptor. Found %x expected %x", version, isoVersion)
}
// get the type and data - later we will be more intelligent about this and read actual primary volume info
vdType := volumeDescriptorType(b[0])
var vd volumeDescriptor
var err error
switch vdType {
case volumeDescriptorPrimary:
vd, err = parsePrimaryVolumeDescriptor(b)
if err != nil {
return nil, fmt.Errorf("unable to parse primary volume descriptor bytes: %v", err)
}
case volumeDescriptorBoot:
vd, err = parseBootVolumeDescriptor(b)
if err != nil {
return nil, fmt.Errorf("unable to parse primary volume descriptor bytes: %v", err)
}
case volumeDescriptorTerminator:
vd = &terminatorVolumeDescriptor{}
case volumeDescriptorPartition:
vd = &partitionVolumeDescriptor{
data: b[8:volumeDescriptorSize],
}
case volumeDescriptorSupplementary:
vd, err = parseSupplementaryVolumeDescriptor(b)
if err != nil {
return nil, fmt.Errorf("unable to parse primary volume descriptor bytes: %v", err)
}
default:
return nil, fmt.Errorf("unknown volume descriptor type %d", vdType)
}
return vd, nil
}
func parsePrimaryVolumeDescriptor(b []byte) (*primaryVolumeDescriptor, error) {
blocksize := binary.LittleEndian.Uint16(b[128:130])
creation, err := decBytesToTime(b[813 : 813+17])
if err != nil {
return nil, fmt.Errorf("unable to convert creation date/time from bytes: %v", err)
}
modification, err := decBytesToTime(b[830 : 830+17])
if err != nil {
return nil, fmt.Errorf("unable to convert modification date/time from bytes: %v", err)
}
// expiration can be never
nullBytes := []byte{48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 0}
var expiration, effective time.Time
expirationBytes := b[847 : 847+17]
effectiveBytes := b[864 : 864+17]
if !bytes.Equal(expirationBytes, nullBytes) {
expiration, err = decBytesToTime(expirationBytes)
if err != nil {
return nil, fmt.Errorf("unable to convert expiration date/time from bytes: %v", err)
}
}
if !bytes.Equal(effectiveBytes, nullBytes) {
effective, err = decBytesToTime(effectiveBytes)
if err != nil {
return nil, fmt.Errorf("unable to convert effective date/time from bytes: %v", err)
}
}
rootDirEntry, err := dirEntryFromBytes(b[156:156+34], nil)
if err != nil {
return nil, fmt.Errorf("unable to read root directory entry: %v", err)
}
return &primaryVolumeDescriptor{
systemIdentifier: string(b[8:40]),
volumeIdentifier: string(b[40:72]),
volumeSize: binary.LittleEndian.Uint32(b[80:84]),
setSize: binary.LittleEndian.Uint16(b[120:122]),
sequenceNumber: binary.LittleEndian.Uint16(b[124:126]),
blocksize: blocksize,
pathTableSize: binary.LittleEndian.Uint32(b[132:136]),
pathTableLLocation: binary.LittleEndian.Uint32(b[140:144]),
pathTableLOptionalLocation: binary.LittleEndian.Uint32(b[144:148]),
pathTableMLocation: binary.BigEndian.Uint32(b[148:152]),
pathTableMOptionalLocation: binary.BigEndian.Uint32(b[152:156]),
volumeSetIdentifier: string(b[190 : 190+128]),
publisherIdentifier: string(b[318 : 318+128]),
preparerIdentifier: string(b[446 : 446+128]),
applicationIdentifier: string(b[574 : 574+128]),
copyrightFile: string(b[702 : 702+37]),
abstractFile: string(b[739 : 739+37]),
bibliographicFile: string(b[776 : 776+37]),
creation: creation,
modification: modification,
expiration: expiration,
effective: effective,
rootDirectoryEntry: rootDirEntry,
}, nil
}
// terminatorVolumeDescriptor
func (v *terminatorVolumeDescriptor) Type() volumeDescriptorType {
return volumeDescriptorTerminator
}
func (v *terminatorVolumeDescriptor) equal(a volumeDescriptor) bool {
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *terminatorVolumeDescriptor) toBytes() []byte {
b := volumeDescriptorFirstBytes(volumeDescriptorTerminator)
return b
}
// bootVolumeDescriptor
func (v *bootVolumeDescriptor) Type() volumeDescriptorType {
return volumeDescriptorBoot
}
func (v *bootVolumeDescriptor) equal(a volumeDescriptor) bool {
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *bootVolumeDescriptor) toBytes() []byte {
b := volumeDescriptorFirstBytes(volumeDescriptorBoot)
copy(b[7:39], bootSystemIdentifier)
binary.LittleEndian.PutUint32(b[0x47:0x4b], v.location)
return b
}
// parseBootVolumeDescriptor
func parseBootVolumeDescriptor(b []byte) (*bootVolumeDescriptor, error) {
systemIdentifier := string(b[0x7 : 0x7+len(bootSystemIdentifier)])
if systemIdentifier != bootSystemIdentifier {
return nil, fmt.Errorf("incorrect specification, actual '%s' expected '%s'", systemIdentifier, bootSystemIdentifier)
}
location := binary.LittleEndian.Uint32(b[0x47:0x4b])
return &bootVolumeDescriptor{location: location}, nil
}
// supplementaryVolumeDescriptor
func parseSupplementaryVolumeDescriptor(b []byte) (*supplementaryVolumeDescriptor, error) {
blocksize := binary.LittleEndian.Uint16(b[128:130])
volumesize := binary.LittleEndian.Uint32(b[80:84])
volumesizeBytes := uint64(blocksize) * uint64(volumesize)
creation, err := decBytesToTime(b[813 : 813+17])
if err != nil {
return nil, fmt.Errorf("unable to convert creation date/time from bytes: %v", err)
}
modification, err := decBytesToTime(b[830 : 830+17])
if err != nil {
return nil, fmt.Errorf("unable to convert modification date/time from bytes: %v", err)
}
// expiration can be never
nullBytes := []byte{48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 0}
var expiration, effective time.Time
expirationBytes := b[847 : 847+17]
effectiveBytes := b[864 : 864+17]
if !bytes.Equal(expirationBytes, nullBytes) {
expiration, err = decBytesToTime(expirationBytes)
if err != nil {
return nil, fmt.Errorf("unable to convert expiration date/time from bytes: %v", err)
}
}
if !bytes.Equal(effectiveBytes, nullBytes) {
effective, err = decBytesToTime(effectiveBytes)
if err != nil {
return nil, fmt.Errorf("unable to convert effective date/time from bytes: %v", err)
}
}
// no susp extensions for the dir entry in the volume descriptor
rootDirEntry, err := dirEntryFromBytes(b[156:156+34], nil)
if err != nil {
return nil, fmt.Errorf("unable to read root directory entry: %v", err)
}
return &supplementaryVolumeDescriptor{
systemIdentifier: string(b[8:40]),
volumeIdentifier: string(b[40:72]),
volumeSize: volumesizeBytes,
setSize: binary.LittleEndian.Uint16(b[120:122]),
sequenceNumber: binary.LittleEndian.Uint16(b[124:126]),
blocksize: blocksize,
pathTableSize: binary.LittleEndian.Uint32(b[132:136]),
pathTableLLocation: binary.LittleEndian.Uint32(b[140:144]),
pathTableLOptionalLocation: binary.LittleEndian.Uint32(b[144:148]),
pathTableMLocation: binary.BigEndian.Uint32(b[148:152]),
pathTableMOptionalLocation: binary.BigEndian.Uint32(b[152:156]),
volumeSetIdentifier: bytesToUCS2String(b[190 : 190+128]),
publisherIdentifier: bytesToUCS2String(b[318 : 318+128]),
preparerIdentifier: bytesToUCS2String(b[446 : 446+128]),
applicationIdentifier: bytesToUCS2String(b[574 : 574+128]),
copyrightFile: bytesToUCS2String(b[702 : 702+37]),
abstractFile: bytesToUCS2String(b[739 : 739+37]),
bibliographicFile: bytesToUCS2String(b[776 : 776+37]),
creation: creation,
modification: modification,
expiration: expiration,
effective: effective,
rootDirectoryEntry: rootDirEntry,
}, nil
}
func (v *supplementaryVolumeDescriptor) Type() volumeDescriptorType {
return volumeDescriptorSupplementary
}
func (v *supplementaryVolumeDescriptor) equal(a volumeDescriptor) bool {
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *supplementaryVolumeDescriptor) toBytes() []byte {
b := volumeDescriptorFirstBytes(volumeDescriptorSupplementary)
copy(b[8:40], v.systemIdentifier)
copy(b[40:72], v.volumeIdentifier)
blockcount := uint32(v.volumeSize / uint64(v.blocksize))
binary.LittleEndian.PutUint32(b[80:84], blockcount)
binary.BigEndian.PutUint32(b[84:88], blockcount)
binary.LittleEndian.PutUint16(b[120:122], v.setSize)
binary.BigEndian.PutUint16(b[122:124], v.setSize)
binary.LittleEndian.PutUint16(b[124:126], v.sequenceNumber)
binary.BigEndian.PutUint16(b[126:128], v.sequenceNumber)
binary.LittleEndian.PutUint16(b[128:130], v.blocksize)
binary.BigEndian.PutUint16(b[130:132], v.blocksize)
binary.LittleEndian.PutUint32(b[132:136], v.pathTableSize)
binary.BigEndian.PutUint32(b[136:140], v.pathTableSize)
binary.LittleEndian.PutUint32(b[140:144], v.pathTableLLocation)
binary.LittleEndian.PutUint32(b[144:148], v.pathTableLOptionalLocation)
binary.BigEndian.PutUint32(b[148:152], v.pathTableMLocation)
binary.BigEndian.PutUint32(b[152:156], v.pathTableMOptionalLocation)
rootDirEntry := make([]byte, 34)
if v.rootDirectoryEntry != nil {
// we will skip the extensions anyways, so the CE blocks do not matter
rootDirEntrySlice, _ := v.rootDirectoryEntry.toBytes(true, []uint32{})
rootDirEntry = rootDirEntrySlice[0]
}
copy(b[156:156+34], rootDirEntry)
copy(b[190:190+128], ucs2StringToBytes(v.volumeSetIdentifier))
copy(b[318:318+128], ucs2StringToBytes(v.publisherIdentifier))
copy(b[446:446+128], ucs2StringToBytes(v.preparerIdentifier))
copy(b[574:574+128], ucs2StringToBytes(v.applicationIdentifier))
copy(b[702:702+37], ucs2StringToBytes(v.copyrightFile))
copy(b[739:739+37], ucs2StringToBytes(v.abstractFile))
copy(b[776:776+37], ucs2StringToBytes(v.bibliographicFile))
copy(b[813:813+17], timeToDecBytes(v.creation))
copy(b[830:830+17], timeToDecBytes(v.modification))
copy(b[847:847+17], timeToDecBytes(v.expiration))
copy(b[864:864+17], timeToDecBytes(v.effective))
return b
}
// partitionVolumeDescriptor
func (v *partitionVolumeDescriptor) Type() volumeDescriptorType {
return volumeDescriptorPartition
}
func (v *partitionVolumeDescriptor) equal(a volumeDescriptor) bool {
return bytes.Equal(v.toBytes(), a.toBytes())
}
func (v *partitionVolumeDescriptor) toBytes() []byte {
b := volumeDescriptorFirstBytes(volumeDescriptorPartition)
copy(b[7:], v.data)
return b
}
// utilities
func volumeDescriptorFirstBytes(t volumeDescriptorType) []byte {
b := make([]byte, volumeDescriptorSize)
b[0] = byte(t)
tmpb := make([]byte, 8)
binary.BigEndian.PutUint64(tmpb, isoIdentifier)
copy(b[1:6], tmpb[3:8])
b[6] = isoVersion
return b
}
func decBytesToTime(b []byte) (time.Time, error) {
year := string(b[0:4])
month := string(b[4:6])
date := string(b[6:8])
hour := string(b[8:10])
minute := string(b[10:12])
second := string(b[12:14])
csec := string(b[14:16])
offset := int(int8(b[16]))
location := offset * 15
format := "2006-01-02T15:04:05-07:00"
offsetHr := location / 60
offsetMin := location % 60
offsetString := ""
// if negative offset, show it just on the hour part, not twice, so we end up with "-06:30" and not "-06:-30"
switch {
case offset == 0:
offsetString = "+00:00"
case offset < 0:
offsetString = fmt.Sprintf("-%02d:%02d", -offsetHr, -offsetMin)
case offset > 0:
offsetString = fmt.Sprintf("+%02d:%02d", offsetHr, offsetMin)
}
return time.Parse(format, fmt.Sprintf("%s-%s-%sT%s:%s:%s.%s%s", year, month, date, hour, minute, second, csec, offsetString))
}
func timeToDecBytes(t time.Time) []byte {
year := strconv.Itoa(t.Year())
month := strconv.Itoa(int(t.Month()))
date := strconv.Itoa(t.Day())
hour := strconv.Itoa(t.Hour())
minute := strconv.Itoa(t.Minute())
second := strconv.Itoa(t.Second())
csec := strconv.Itoa(t.Nanosecond() / 1e+7)
_, offset := t.Zone()
b := make([]byte, 17)
copy(b[0:4], fmt.Sprintf("%04s", year))
copy(b[4:6], fmt.Sprintf("%02s", month))
copy(b[6:8], fmt.Sprintf("%02s", date))
copy(b[8:10], fmt.Sprintf("%02s", hour))
copy(b[10:12], fmt.Sprintf("%02s", minute))
copy(b[12:14], fmt.Sprintf("%02s", second))
copy(b[14:16], fmt.Sprintf("%02s", csec))
b[16] = byte(offset / 60 / 15)
return b
}
0707010000032B000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004B00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs 0707010000032C000081A4000000000000000000000001645E367C00002372000000000000000000000000000000000000005900000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/compressor.go package squashfs
import (
"bytes"
"compress/zlib"
"encoding/binary"
"fmt"
"io"
"github.com/pierrec/lz4"
"github.com/ulikunitz/xz"
"github.com/ulikunitz/xz/lzma"
)
// Compressor defines a compressor. Fulfilled by various implementations in this package
type Compressor interface {
compress([]byte) ([]byte, error)
decompress([]byte) ([]byte, error)
loadOptions([]byte) error
optionsBytes() []byte
flavour() compression
}
// CompressorLzma lzma compression
type CompressorLzma struct {
}
func (c *CompressorLzma) compress(in []byte) ([]byte, error) {
var b bytes.Buffer
lz, err := lzma.NewWriter(&b)
if err != nil {
return nil, fmt.Errorf("error creating lzma compressor: %v", err)
}
if _, err := lz.Write(in); err != nil {
return nil, err
}
if err := lz.Close(); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func (c *CompressorLzma) decompress(in []byte) ([]byte, error) {
b := bytes.NewReader(in)
lz, err := lzma.NewReader(b)
if err != nil {
return nil, fmt.Errorf("error creating lzma decompressor: %v", err)
}
p, err := io.ReadAll(lz)
if err != nil {
return nil, fmt.Errorf("error decompressing: %v", err)
}
return p, nil
}
func (c *CompressorLzma) loadOptions(b []byte) error {
// lzma has no supported optiosn
return nil
}
func (c *CompressorLzma) optionsBytes() []byte {
return []byte{}
}
func (c *CompressorLzma) flavour() compression {
return compressionLzma
}
type GzipStrategy uint16
// gzip strategy options
const (
GzipDefault GzipStrategy = 0x1
GzipFiltered GzipStrategy = 0x2
GzipHuffman GzipStrategy = 0x4
GzipRunLengthEncoded GzipStrategy = 0x8
GzipFixed GzipStrategy = 0x10
)
// CompressorGzip gzip compression
type CompressorGzip struct {
CompressionLevel uint32
WindowSize uint16
Strategies map[GzipStrategy]bool
}
func (c *CompressorGzip) compress(in []byte) ([]byte, error) {
var b bytes.Buffer
gz, err := zlib.NewWriterLevel(&b, int(c.CompressionLevel))
if err != nil {
return nil, fmt.Errorf("error creating gzip compressor: %v", err)
}
if _, err := gz.Write(in); err != nil {
return nil, err
}
if err := gz.Flush(); err != nil {
return nil, err
}
if err := gz.Close(); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func (c *CompressorGzip) decompress(in []byte) ([]byte, error) {
b := bytes.NewReader(in)
gz, err := zlib.NewReader(b)
if err != nil {
return nil, fmt.Errorf("error creating gzip decompressor: %v", err)
}
p, err := io.ReadAll(gz)
if err != nil {
return nil, fmt.Errorf("error decompressing: %v", err)
}
return p, nil
}
func (c *CompressorGzip) loadOptions(b []byte) error {
expected := 8
if len(b) != expected {
return fmt.Errorf("cannot parse gzip options, received %d bytes expected %d", len(b), expected)
}
c.CompressionLevel = binary.LittleEndian.Uint32(b[0:4])
c.WindowSize = binary.LittleEndian.Uint16(b[4:6])
strategies := map[GzipStrategy]bool{}
flags := binary.LittleEndian.Uint16(b[6:8])
for _, strategy := range []GzipStrategy{GzipDefault, GzipFiltered, GzipHuffman, GzipRunLengthEncoded, GzipFixed} {
if flags&uint16(strategy) == uint16(strategy) {
strategies[strategy] = true
}
}
c.Strategies = strategies
return nil
}
func (c *CompressorGzip) optionsBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], c.CompressionLevel)
binary.LittleEndian.PutUint16(b[4:6], c.WindowSize)
var flags uint16
for _, strategy := range []GzipStrategy{GzipDefault, GzipFiltered, GzipHuffman, GzipRunLengthEncoded, GzipFixed} {
if c.Strategies[strategy] {
flags |= uint16(strategy)
}
}
binary.LittleEndian.PutUint16(b[6:8], flags)
return b
}
func (c *CompressorGzip) flavour() compression {
return compressionGzip
}
// XzFilter filter for xz compression
type XzFilter uint32
// xz filter options
const (
XzFilterX86 XzFilter = 0x1
XzFilterPowerPC XzFilter = 0x2
XzFilterIA64 XzFilter = 0x4
XzFilterArm XzFilter = 0x8
XzFilterArmThumb XzFilter = 0x10
XzFilterSparc XzFilter = 0x20
)
// CompressorXz xz compression
type CompressorXz struct {
DictionarySize uint32
ExecutableFilters map[XzFilter]bool
}
func (c *CompressorXz) compress(in []byte) ([]byte, error) {
var b bytes.Buffer
config := xz.WriterConfig{
DictCap: int(c.DictionarySize),
}
xzWriter, err := config.NewWriter(&b)
if err != nil {
return nil, fmt.Errorf("error creating xz compressor: %v", err)
}
if _, err := xzWriter.Write(in); err != nil {
return nil, err
}
if err := xzWriter.Close(); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func (c *CompressorXz) decompress(in []byte) ([]byte, error) {
b := bytes.NewReader(in)
xzReader, err := xz.NewReader(b)
if err != nil {
return nil, fmt.Errorf("error creating xz decompressor: %v", err)
}
p, err := io.ReadAll(xzReader)
if err != nil {
return nil, fmt.Errorf("error decompressing: %v", err)
}
return p, nil
}
func (c *CompressorXz) loadOptions(b []byte) error {
expected := 8
if len(b) != expected {
return fmt.Errorf("cannot parse xz options, received %d bytes expected %d", len(b), expected)
}
c.DictionarySize = binary.LittleEndian.Uint32(b[0:4])
filters := map[XzFilter]bool{}
flags := binary.LittleEndian.Uint32(b[4:8])
for _, filter := range []XzFilter{XzFilterX86, XzFilterPowerPC, XzFilterIA64, XzFilterArm, XzFilterArmThumb, XzFilterSparc} {
if flags&uint32(filter) == uint32(filter) {
filters[filter] = true
}
}
c.ExecutableFilters = filters
return nil
}
func (c *CompressorXz) optionsBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], c.DictionarySize)
var flags uint32
for _, filter := range []XzFilter{XzFilterX86, XzFilterPowerPC, XzFilterIA64, XzFilterArm, XzFilterArmThumb, XzFilterSparc} {
if c.ExecutableFilters[filter] {
flags |= uint32(filter)
}
}
binary.LittleEndian.PutUint32(b[4:8], flags)
return b
}
func (c *CompressorXz) flavour() compression {
return compressionXz
}
// lz4 compression
type lz4Flag uint32
const (
lz4HighCompression lz4Flag = 0x1
)
const (
lz4version1 uint32 = 1
)
// CompressorLz4 lz4 compression
type CompressorLz4 struct {
version uint32
flags map[lz4Flag]bool
}
func (c *CompressorLz4) compress(in []byte) ([]byte, error) {
var b bytes.Buffer
lz := lz4.NewWriter(&b)
if _, err := lz.Write(in); err != nil {
return nil, err
}
if err := lz.Close(); err != nil {
return nil, err
}
return b.Bytes(), nil
}
func (c *CompressorLz4) decompress(in []byte) ([]byte, error) {
b := bytes.NewReader(in)
lz := lz4.NewReader(b)
p, err := io.ReadAll(lz)
if err != nil {
return nil, fmt.Errorf("error decompressing: %v", err)
}
return p, nil
}
func (c *CompressorLz4) loadOptions(b []byte) error {
expected := 8
if len(b) != expected {
return fmt.Errorf("cannot parse lz4 options, received %d bytes expected %d", len(b), expected)
}
version := binary.LittleEndian.Uint32(b[0:4])
if version != lz4version1 {
return fmt.Errorf("compressed with lz4 version %d, only support %d", version, lz4version1)
}
c.version = version
flagMap := map[lz4Flag]bool{}
flags := binary.LittleEndian.Uint32(b[4:8])
for _, f := range []lz4Flag{lz4HighCompression} {
if flags&uint32(f) == uint32(f) {
flagMap[f] = true
}
}
c.flags = flagMap
return nil
}
func (c *CompressorLz4) optionsBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], c.version)
var flags uint32
for _, f := range []lz4Flag{lz4HighCompression} {
if c.flags[f] {
flags |= uint32(f)
}
}
binary.LittleEndian.PutUint32(b[4:8], flags)
return b
}
func (c *CompressorLz4) flavour() compression {
return compressionLz4
}
// CompressorZstd zstd compression
type CompressorZstd struct {
level uint32
}
const (
zstdMinLevel uint32 = 1
zstdMaxLevel uint32 = 22
)
func (c *CompressorZstd) loadOptions(b []byte) error {
expected := 4
if len(b) != expected {
return fmt.Errorf("cannot parse zstd options, received %d bytes expected %d", len(b), expected)
}
level := binary.LittleEndian.Uint32(b[0:4])
if level < zstdMinLevel || level > zstdMaxLevel {
return fmt.Errorf("zstd compression level requested %d, must be at least %d and not more thann %d", level, zstdMinLevel, zstdMaxLevel)
}
c.level = level
return nil
}
func (c *CompressorZstd) optionsBytes() []byte {
b := make([]byte, 4)
binary.LittleEndian.PutUint32(b[0:4], c.level)
return b
}
func (c *CompressorZstd) flavour() compression {
return compressionZstd
}
func newCompressor(flavour compression) (Compressor, error) {
var c Compressor
switch flavour {
case compressionNone:
c = nil
case compressionGzip:
c = &CompressorGzip{}
case compressionLzma:
c = &CompressorLzma{}
case compressionLzo:
return nil, fmt.Errorf("LZO compression not yet supported")
case compressionXz:
c = &CompressorXz{}
case compressionLz4:
c = &CompressorLz4{}
case compressionZstd:
return nil, fmt.Errorf("zstd compression not yet supported")
default:
return nil, fmt.Errorf("unknown compression type: %d", flavour)
}
return c, nil
}
0707010000032D000081A4000000000000000000000001645E367C0000158B000000000000000000000000000000000000005800000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/directory.go package squashfs
import (
"encoding/binary"
"fmt"
)
const (
maxDirEntries = 256
dirHeaderSize = 12
dirEntryMinSize = 8
dirNameMaxSize = 256
)
// directory represents a contiguous directory on disk, composed of one header
// and one or more entries under that header, i.e. directoryEntryRaw. An entire
// directory may be composed of one or more of these "directory", depending
// on how many headers it requires
type directory struct {
inodeIndex uint32
entries []*directoryEntryRaw
}
type directoryEntryRaw struct {
offset uint16
inodeNumber uint32
inodeType inodeType
name string
isSubdirectory bool
startBlock uint32
}
func (d *directoryEntryRaw) toBytes(inodeIndex uint32) []byte {
b := make([]byte, 8)
nameBytes := []byte(d.name)
binary.LittleEndian.PutUint16(b[0:2], d.offset)
binary.LittleEndian.PutUint16(b[2:4], uint16(d.inodeNumber-inodeIndex))
binary.LittleEndian.PutUint16(b[4:6], uint16(d.inodeType))
binary.LittleEndian.PutUint16(b[6:8], uint16(len(nameBytes)-1))
b = append(b, nameBytes...)
return b
}
type directoryHeader struct {
count uint32
startBlock uint32
inode uint32
}
type directoryEntryGroup struct {
header *directoryHeader
entries []*directoryEntryRaw
}
// parse raw bytes of a directory to get the contents
func parseDirectory(b []byte) (*directory, error) {
// must have at least one header
if _, err := parseDirectoryHeader(b); err != nil {
return nil, fmt.Errorf("could not parse directory header: %v", err)
}
entries := make([]*directoryEntryRaw, 0)
for pos := 0; pos+dirHeaderSize < len(b); {
directoryHeader, err := parseDirectoryHeader(b[pos:])
if err != nil {
return nil, fmt.Errorf("could not parse directory header: %v", err)
}
if directoryHeader.count+1 > maxDirEntries {
return nil, fmt.Errorf("corrupted directory, had %d entries instead of max %d", directoryHeader.count+1, maxDirEntries)
}
pos += dirHeaderSize
for count := uint32(0); count < directoryHeader.count; count++ {
entry, size, err := parseDirectoryEntry(b[pos:], directoryHeader.inode)
if err != nil {
return nil, fmt.Errorf("unable to parse entry at position %d: %v", pos, err)
}
entry.startBlock = directoryHeader.startBlock
entries = append(entries, entry)
// increment the position
pos += size
}
}
return &directory{
entries: entries,
}, nil
}
func (d *directory) toBytes(in uint32) []byte {
// need to group these into chunks that would share a header
var (
b []byte
groups []*directoryEntryGroup
group *directoryEntryGroup
)
for _, e := range d.entries {
// we need a new header if one of the following:
// - we don't have one yet
// - inode block changes
// - inode offset > +/- 32k from the inode in the header,
if group == nil || group.header.startBlock != e.startBlock {
group = &directoryEntryGroup{
header: &directoryHeader{
startBlock: e.startBlock,
inode: in,
},
}
groups = append(groups, group)
}
group.header.count++
group.entries = append(group.entries, e)
}
// now convert all of the chunks to bytes
for _, group := range groups {
b = append(b, group.header.toBytes()...)
for _, e := range group.entries {
b = append(b, e.toBytes(in)...)
}
}
return b
}
func (d *directory) equal(b *directory) bool {
if d == nil && b == nil {
return true
}
if (d == nil && b != nil) || (d != nil && b == nil) {
return false
}
// entries
if len(d.entries) != len(b.entries) {
return false
}
for i, e := range d.entries {
if *e != *b.entries[i] {
return false
}
}
return true
}
// parse the header of a directory
func parseDirectoryHeader(b []byte) (*directoryHeader, error) {
if len(b) < dirHeaderSize {
return nil, fmt.Errorf("header was %d bytes, less than minimum %d", len(b), dirHeaderSize)
}
return &directoryHeader{
count: binary.LittleEndian.Uint32(b[0:4]) + 1,
startBlock: binary.LittleEndian.Uint32(b[4:8]),
inode: binary.LittleEndian.Uint32(b[8:12]),
}, nil
}
func (d *directoryHeader) toBytes() []byte {
b := make([]byte, dirHeaderSize)
binary.LittleEndian.PutUint32(b[0:4], d.count-1)
binary.LittleEndian.PutUint32(b[4:8], d.startBlock)
binary.LittleEndian.PutUint32(b[8:12], d.inode)
return b
}
// parse a raw directory entry
func parseDirectoryEntry(b []byte, in uint32) (*directoryEntryRaw, int, error) {
// ensure we have enough bytes to parse
if len(b) < dirEntryMinSize {
return nil, 0, fmt.Errorf("directory entry was %d bytes, less than minimum %d", len(b), dirEntryMinSize)
}
offset := binary.LittleEndian.Uint16(b[0:2])
inode := uint32(binary.LittleEndian.Uint16(b[2:4])) + in
entryType := binary.LittleEndian.Uint16(b[4:6])
nameSize := binary.LittleEndian.Uint16(b[6:8])
realNameSize := nameSize + 1
// make sure name is legitimate size
if nameSize > dirNameMaxSize {
return nil, 0, fmt.Errorf("name size was %d bytes, greater than maximum %d", nameSize, dirNameMaxSize)
}
if int(realNameSize+dirEntryMinSize) > len(b) {
return nil, 0, fmt.Errorf("dir entry plus size of name is %d, larger than available bytes %d", nameSize+dirEntryMinSize, len(b))
}
// read in the name
name := string(b[8 : 8+realNameSize])
iType := inodeType(entryType)
return &directoryEntryRaw{
offset: offset,
inodeNumber: inode,
inodeType: iType,
isSubdirectory: iType == inodeBasicDirectory || iType == inodeExtendedDirectory,
name: name,
}, int(8 + realNameSize), nil
}
0707010000032E000081A4000000000000000000000001645E367C00000A5D000000000000000000000000000000000000005D00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/directoryentry.go package squashfs
import (
"os"
"time"
)
// FileStat is the extended data underlying a single file, similar to https://golang.org/pkg/syscall/#Stat_t
type FileStat struct {
uid uint32
gid uint32
xattrs map[string]string
}
func (f *FileStat) equal(o *FileStat) bool {
if f.uid != o.uid || f.gid != o.gid {
return false
}
if len(f.xattrs) != len(o.xattrs) {
return false
}
for k, v := range f.xattrs {
ov, ok := o.xattrs[k]
if !ok {
return false
}
if ov != v {
return false
}
}
return true
}
// UID get uid of file
func (f *FileStat) UID() uint32 {
return f.uid
}
// GID get gid of file
func (f *FileStat) GID() uint32 {
return f.gid
}
// Xattrs get extended attributes of file
func (f *FileStat) Xattrs() map[string]string {
return f.xattrs
}
// directoryEntry is a single directory entry
// it combines information from inode and the actual entry
// also fulfills os.FileInfo
//
// Name() string // base name of the file
// Size() int64 // length in bytes for regular files; system-dependent for others
// Mode() FileMode // file mode bits
// ModTime() time.Time // modification time
// IsDir() bool // abbreviation for Mode().IsDir()
// Sys() interface{} // underlying data source (can return nil)
type directoryEntry struct {
isSubdirectory bool
name string
size int64
modTime time.Time
mode os.FileMode
inode inode
sys FileStat
}
func (d *directoryEntry) equal(o *directoryEntry) bool {
if o == nil {
return false
}
if !d.sys.equal(&o.sys) {
return false
}
if d.inode == nil && o.inode == nil {
return true
}
if (d.inode == nil && o.inode != nil) || (d.inode != nil && o.inode == nil) {
return false
}
if !d.inode.equal(o.inode) {
return false
}
return d.isSubdirectory == o.isSubdirectory && d.name == o.name && d.size == o.size && d.modTime == o.modTime && d.mode == o.mode
}
// Name string // base name of the file
func (d *directoryEntry) Name() string {
return d.name
}
// Size int64 // length in bytes for regular files; system-dependent for others
func (d *directoryEntry) Size() int64 {
return d.size
}
// IsDir bool // abbreviation for Mode().IsDir()
func (d *directoryEntry) IsDir() bool {
return d.isSubdirectory
}
// ModTime time.Time // modification time
func (d *directoryEntry) ModTime() time.Time {
return d.modTime
}
// Mode FileMode // file mode bits
func (d *directoryEntry) Mode() os.FileMode {
return d.mode
}
// Sys interface{} // underlying data source (can return nil)
func (d *directoryEntry) Sys() interface{} {
return d.sys
}
0707010000032F000081A4000000000000000000000001645E367C00000117000000000000000000000000000000000000005200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/doc.go // Package squashfs provides support for reading and creating squashfs filesystems
// references:
//
// https://www.kernel.org/doc/Documentation/filesystems/squashfs.txt
// https://dr-emann.github.io/squashfs/
// https://elinux.org/images/3/32/Squashfs-elce.pdf
package squashfs
07070100000330000081A4000000000000000000000001645E367C0000110F000000000000000000000000000000000000005300000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/file.go package squashfs
import (
"fmt"
"io"
"os"
)
// File represents a single file in a squashfs filesystem
//
// it is NOT used when working in a workspace, where we just use the underlying OS
// note that the inode for a file can be the basicFile or extendedFile. We just use extendedFile to
// include all of the data
type File struct {
*extendedFile
isReadWrite bool
isAppend bool
offset int64
filesystem *FileSystem
}
// Read reads up to len(b) bytes from the File.
// It returns the number of bytes read and any error encountered.
// At end of file, Read returns 0, io.EOF
// reads from the last known offset in the file from last read or write
// use Seek() to set at a particular point
func (fl *File) Read(b []byte) (int, error) {
if fl == nil || fl.filesystem == nil {
return 0, os.ErrClosed
}
// squashfs files are *mostly* contiguous, we only need the starting location and size for whole blocks
// if there are fragments, we need the location of those as well
// logic:
// 1- find the uncompressed blocksize from the superblock
// 2- calculate the relative blocks needed for this file
// e.g. if uncompressed blocksize is 100 bytes, and we want from byte 240 for 200 bytes,
// then we need blocks 2,3,4 of this file
// 3- find the compressed blockSizes for this file from inode.blockSizes
// this tells us how many bytes to read for each block from the disk
// 4- find the starting location for the first block for this file from inode.startBlock
// e.g. if starting block is at position 10245, then we want blocks 27,28,29 from the disk
// 5- read in and uncompress the necessary blocks
fs := fl.filesystem
size := int(fl.size()) - int(fl.offset)
location := int64(fl.startBlock)
maxRead := size
// if there is nothing left to read, just return EOF
if size <= 0 {
return 0, io.EOF
}
// we stop when we hit the lesser of
// 1- len(b)
// 2- file end
if len(b) < maxRead {
maxRead = len(b)
}
// just read the requested number of bytes and change our offset
// figure out which block number has the bytes we are looking for
startBlock := int(fl.offset / fs.blocksize)
endBlock := int((fl.offset + int64(maxRead)) / fs.blocksize)
// do we end in fragment territory?
fragments := false
if endBlock >= len(fl.blockSizes) {
fragments = true
endBlock--
}
read := 0
offset := fl.offset
// we need to cycle through all of the blocks to find where the desired one starts
for i, block := range fl.blockSizes {
if i > endBlock || read > maxRead {
break
}
// if we are in the range of desired ones, read it in
if i >= startBlock {
input, err := fs.readBlock(location, block.compressed, block.size)
if err != nil {
return read, fmt.Errorf("error reading data block %d from squashfs: %v", i, err)
}
// we do not need to limit it to the remaining space of b, since copy() only will copy
// to what space it has in b
copy(b[read:], input[offset:])
read += len(input)
fl.offset += int64(read)
offset = 0
}
location += int64(block.size)
}
// did we have a fragment to read?
if fragments {
input, err := fs.readFragment(fl.fragmentBlockIndex, fl.fragmentOffset, fl.size()%fs.blocksize)
if err != nil {
return read, fmt.Errorf("error reading fragment block %d from squashfs: %v", fl.fragmentBlockIndex, err)
}
copy(b[read:], input)
}
fl.offset += int64(maxRead)
var retErr error
if fl.offset >= int64(size) {
retErr = io.EOF
}
return maxRead, retErr
}
// Write writes len(b) bytes to the File.
//
// you cannot write to a finished squashfs, so this returns an error
func (fl *File) Write(p []byte) (int, error) {
return 0, fmt.Errorf("cannot write to a read-only squashfs filesystem")
}
// Seek set the offset to a particular point in the file
func (fl *File) Seek(offset int64, whence int) (int64, error) {
if fl == nil || fl.filesystem == nil {
return 0, os.ErrClosed
}
newOffset := int64(0)
switch whence {
case io.SeekStart:
newOffset = offset
case io.SeekEnd:
newOffset = fl.size() - offset
case io.SeekCurrent:
newOffset = fl.offset + offset
}
if newOffset < 0 {
return fl.offset, fmt.Errorf("cannot set offset %d before start of file", offset)
}
fl.offset = newOffset
return fl.offset, nil
}
// Close close the file
func (fl *File) Close() error {
fl.filesystem = nil
return nil
}
07070100000331000081A4000000000000000000000001645E367C0000B370000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/finalize.go package squashfs
import (
"encoding/binary"
"fmt"
"io"
"os"
"path"
"path/filepath"
"strings"
"time"
"github.com/diskfs/go-diskfs/util"
"github.com/pkg/xattr"
)
type fileType uint8
const (
fileRegular fileType = iota
fileDirectory
fileSymlink
fileBlock
fileChar
fileFifo
fileSocket
)
// FinalizeOptions options to pass to finalize
type FinalizeOptions struct {
// Compressor which compressor to use, including, where relevant, options. Defaults ot CompressorGzip
Compression Compressor
// NonExportable prevent making filesystem NFS exportable. Defaults to false, i.e. make it exportable
NonExportable bool
// NonSparse prevent detecting sparse files. Defaults to false, i.e. detect sparse files
NonSparse bool
// Xattrs whether or not to store extended attributes. Defaults to false
Xattrs bool
// NoCompressInodes whether or not to compress inodes. Defaults to false, i.e. compress inodes
NoCompressInodes bool
// NoCompressData whether or not to compress data blocks. Defaults to false, i.e. compress data
NoCompressData bool
// NoCompressFragments whether or not to compress fragments. Defaults to false, i.e. compress fragments
NoCompressFragments bool
// NoCompressXattrs whether or not to compress extended attrbutes. Defaults to false, i.e. compress xattrs
NoCompressXattrs bool
// NoFragments do not use fragments, but rather dedicated data blocks for all files. Defaults to false, i.e. use fragments
NoFragments bool
// NoPad do not pad filesystem so it is a multiple of 4K. Defaults to false, i.e. pad it
NoPad bool
// FileUID set all files to be owned by the UID provided, default is to leave as in filesystem
FileUID *uint32
// FileGID set all files to be owned by the GID provided, default is to leave as in filesystem
FileGID *uint32
}
// Finalize finalize a read-only filesystem by writing it out to a read-only format
func (fs *FileSystem) Finalize(options FinalizeOptions) error {
if fs.workspace == "" {
return fmt.Errorf("cannot finalize an already finalized filesystem")
}
/*
There is nothing we can find about the order of files/directories, for any of:
- inodes in inode table
- entries in directory table
- data in data section
- fragments in fragment section
to keep it simple, we will follow what mksquashfs on linux does, in the following order:
- superblock at byte 0
- compression options, if any, at byte 96
- file data immediately following compression options (or superblock, if no compression options)
- fragments immediately following file data
- inode table
- directory table
- fragment table
- export table
- uid/gid lookup table
- xattr table
Note that until we actually copy and compress each section, we do not know the position of each subsequent
section. So we have to write one, keep track of it, then the next, etc.
*/
f := fs.file
blocksize := int(fs.blocksize)
comp := compressionNone
if options.Compression != nil {
comp = options.Compression.flavour()
}
// build out file and directory tree
// this returns a slice of *finalizeFileInfo, each of which represents a directory
// or file
fileList, err := walkTree(fs.Workspace())
if err != nil {
return fmt.Errorf("error walking tree: %v", err)
}
// location holds where we are writing in our file
var (
location int64
b []byte
)
location += superblockSize
if options.Compression != nil {
b = options.Compression.optionsBytes()
if len(b) > 0 {
_, _ = f.WriteAt(b, location)
location += int64(len(b))
}
}
// next write the file blocks
compressor := options.Compression
if options.NoCompressData {
compressor = nil
}
// write file data blocks
//
dataWritten, err := writeDataBlocks(fileList, f, fs.workspace, blocksize, compressor, location)
if err != nil {
return fmt.Errorf("error writing file data blocks: %v", err)
}
location += int64(dataWritten)
//
// write file fragments
//
fragmentBlockStart := location
fragmentBlocks, fragsWritten, err := writeFragmentBlocks(fileList, f, fs.workspace, blocksize, options, fragmentBlockStart)
if err != nil {
return fmt.Errorf("error writing file fragment blocks: %v", err)
}
location += fragsWritten
// extract extended attributes, and save them for later; these are written at the very end
// this must be done *before* creating inodes, as inodes reference these
xattrs := extractXattrs(fileList)
// Now we need to write the inode table and directory table. But
// we have a chicken and an egg problem.
//
// * On the one hand, inodes are written to the disk before the directories, so we need to know
// the size of the inode data.
// * On the other hand, inodes for directories point to directories, specifically, the block and offset
// where the pointed-at directory resides in the directory table.
//
// So we need inode table to create directory table, and directory table to create inode table.
//
// Further complicating matters is that the data in the
// directory inodes relies on having the directory data ready. Specifically,
// it includes:
// - index of the block in the directory table where the dir info starts. Note
// that this is not just the directory *table* index, but the *block* index.
// - offset within the block in the directory table where the dir info starts.
// Same notes as previous entry.
// - size of the directory table entries for this directory, all of it. Thus,
// you have to have converted it all to bytes to get the information.
//
// The only possible way to do this is to run one, then the other, then
// modify them. Until you generate both, you just don't know.
//
// Something that eases it a bit is that the block index in directory inodes
// is from the start of the directory table, rather than start of archive.
//
// Order of execution:
// 1. Write the file (not directory) data and fragments to disk.
// 2. Create inodes for the files. We cannot write them yet because we need to
// add the directory entries before compression.
// 3. Convert the directories to a directory table. And no, we cannot just
// calculate it based on the directory size, since some directories have
// one header, some have multiple, so the size of each directory, even
// given the number of files, can change.
// 4. Create inodes for the directories and write them to disk
// 5. Update the directory entries based on the inodes.
// 6. Write directory table to disk
//
// if storing the inodes and directory table entirely in memory becomes
// burdensome, use temporary scratch disk space to cache data in flight
//
// Build inodes for files. They are saved onto the fileList items themselves.
//
// build up a table of uids/gids we can store later
idtable := map[uint32]uint16{}
// get the inodes in order as a slice
if err := createInodes(fileList, idtable, options); err != nil {
return fmt.Errorf("error creating file inodes: %v", err)
}
// convert the inodes to data, while keeping track of where each
// one is, so we can update the directory entries
updateInodeLocations(fileList)
// create the directory table. We already have every inode and its position,
// so we do not need to dip back into the inodes. The only changes will be
// the block/offset references into the directory table, but those sizes do
// not change. However, we will have to break out the headers, so this is not
// completely finalized yet.
directories := createDirectories(fileList[0])
// create the final version of the directory table by creating the headers
// and entries.
populateDirectoryLocations(directories)
if err := updateInodesFromDirectories(directories); err != nil {
return fmt.Errorf("error updating inodes with final directory data: %v", err)
}
// write the inodes to the file
inodesWritten, inodeTableLocation, err := writeInodes(fileList, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing inode data blocks: %v", err)
}
location += int64(inodesWritten)
// write directory data
dirsWritten, dirTableLocation, err := writeDirectories(directories, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing directory data blocks: %v", err)
}
location += int64(dirsWritten)
// write fragment table
/*
The indexCount is used for indexed lookups.
The index is stored at the end of the inode (after the filename) for extended directory
There is one entry for each block after the 0th, so if there is just one block, then there is no index
The filenames in the directory are sorted alphabetically. Each entry gives the first filename found in
the respective block, so if the name found is larger than yours, it is in the previous block
b[0:4] uint32 index - number of bytes where this entry is from the beginning of this directory
b[4:8] uint32 startBlock - number of bytes in the filesystem from the start of the directory table that this block is
b[8:12] uint32 size - size of the name (-1)
b[12:12+size] string name
Here is an example of 1 entry:
f11f 0000 0000 0000 0b00 0000 6669 6c65 6e61 6d65 5f34 3638
b[0:4] index 0x1ff1
b[4:8] startBlock 0x00
b[8:12] size 0x0b (+1 for a total of 0x0c = 12)
b[12:24] name filename_468
*/
// TODO:
/*
FILL IN:
- xattr table
ALSO:
- we have been treating every file like it is a normal file, but need to handle all of the special cases:
- symlink, IPC, block/char device, hardlink
- deduplicate values in xattrs
- utilize options to: not add xattrs; not compress things; etc.
- blockPosition calculations appear to be off
*/
// write the fragment table and its index
fragmentTableWritten, fragmentTableLocation, err := writeFragmentTable(fragmentBlocks, fragmentBlockStart, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing fragment table: %v", err)
}
location += int64(fragmentTableWritten)
// write the export table
var (
exportTableLocation uint64
exportTableWritten int
)
if !options.NonExportable {
exportTableWritten, exportTableLocation, err = writeExportTable(fileList, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing export table: %v", err)
}
location += int64(exportTableWritten)
}
// write the uidgid table
idTableWritten, idTableLocation, err := writeIDTable(idtable, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing uidgid table: %v", err)
}
location += int64(idTableWritten)
// write the xattrs
var xAttrsLocation uint64
if len(xattrs) == 0 {
xAttrsLocation = noXattrSuperblockFlag
} else {
var xAttrsWritten int
xAttrsWritten, xAttrsLocation, err = writeXattrs(xattrs, f, compressor, location)
if err != nil {
return fmt.Errorf("error writing xattrs table: %v", err)
}
location += int64(xAttrsWritten)
}
// update and write the superblock
// keep in mind that the superblock always needs to have a valid compression.
// if there is no compression used, mark it as option gzip, and set all of the
// flags to indicate that nothing is compressed.
if comp == compressionNone {
comp = compressionGzip
options.NoCompressData = true
options.NoCompressInodes = true
options.NoCompressFragments = true
options.NoCompressXattrs = true
}
sb := &superblock{
blocksize: uint32(blocksize),
compression: comp,
inodes: uint32(len(fileList)),
xattrTableStart: xAttrsLocation,
fragmentCount: uint32(len(fragmentBlocks)),
modTime: time.Now(),
size: uint64(location),
versionMajor: 4,
versionMinor: 0,
idTableStart: idTableLocation,
exportTableStart: exportTableLocation,
inodeTableStart: inodeTableLocation,
idCount: uint16(len(idtable)),
directoryTableStart: dirTableLocation,
fragmentTableStart: fragmentTableLocation,
rootInode: &inodeRef{fileList[0].inodeLocation.block, fileList[0].inodeLocation.offset},
superblockFlags: superblockFlags{
uncompressedInodes: options.NoCompressInodes,
uncompressedData: options.NoCompressData,
uncompressedFragments: options.NoCompressFragments,
uncompressedXattrs: options.NoCompressXattrs,
noFragments: options.NoFragments,
noXattrs: !options.Xattrs,
exportable: !options.NonExportable,
},
}
// write the superblock
sbBytes := sb.toBytes()
if _, err := f.WriteAt(sbBytes, 0); err != nil {
return fmt.Errorf("failed to write superblock: %v", err)
}
// finish by setting as finalized
fs.workspace = ""
return nil
}
func copyFileData(from, to util.File, fromOffset, toOffset, blocksize int64, c Compressor) (raw, compressed int, blocks []*blockData, err error) {
buf := make([]byte, blocksize)
blocks = make([]*blockData, 0)
for {
n, err := from.ReadAt(buf, fromOffset+int64(raw))
if err != nil && err != io.EOF {
return raw, compressed, nil, err
}
if n != len(buf) {
break
}
raw += len(buf)
// compress the block if needed
isCompressed := false
if c != nil {
out, err := c.compress(buf)
if err != nil {
return 0, 0, nil, fmt.Errorf("error compressing block: %v", err)
}
if len(out) < len(buf) {
isCompressed = true
buf = out
}
}
blocks = append(blocks, &blockData{size: uint32(len(buf)), compressed: isCompressed})
if _, err := to.WriteAt(buf[:n], toOffset+int64(compressed)); err != nil {
return raw, compressed, blocks, err
}
compressed += len(buf)
}
return raw, compressed, blocks, nil
}
// finalizeFragment write fragment data out to the archive, compressing if relevant.
// Returns the total amount written, whether compressed, and any error.
func finalizeFragment(buf []byte, to util.File, toOffset int64, c Compressor) (raw int, compressed bool, err error) {
// compress the block if needed
if c != nil {
out, err := c.compress(buf)
if err != nil {
return 0, compressed, fmt.Errorf("error compressing fragment block: %v", err)
}
if len(out) < len(buf) {
buf = out
compressed = true
}
}
if _, err := to.WriteAt(buf, toOffset); err != nil {
return 0, compressed, err
}
return len(buf), compressed, nil
}
// walkTree walks the tree and returns a slice of files and directories.
// We do files and directories differently, since they need to be processed
// differently on disk (file data and fragments vs directory table), and
// because the inode data is different.
// The first entry in the return always will be the root
func walkTree(workspace string) ([]*finalizeFileInfo, error) {
cwd, err := os.Getwd()
if err != nil {
return nil, fmt.Errorf("could not get pwd: %v", err)
}
// make everything relative to the workspace
_ = os.Chdir(workspace)
dirMap := make(map[string]*finalizeFileInfo)
fileList := make([]*finalizeFileInfo, 0)
var entry *finalizeFileInfo
_ = filepath.Walk(".", func(fp string, fi os.FileInfo, err error) error {
if err != nil {
return err
}
isRoot := fp == "."
name := fi.Name()
m := fi.Mode()
var fType fileType
switch {
case m&os.ModeSocket == os.ModeSocket:
fType = fileSocket
case m&os.ModeSymlink == os.ModeSymlink:
fType = fileSymlink
case m&os.ModeNamedPipe == os.ModeNamedPipe:
fType = fileFifo
case m&os.ModeDir == os.ModeDir:
fType = fileDirectory
case m&os.ModeDevice == os.ModeDevice && m&os.ModeCharDevice == os.ModeCharDevice:
fType = fileChar
case m&os.ModeDevice == os.ModeDevice && m&os.ModeCharDevice != os.ModeCharDevice:
fType = fileBlock
default:
fType = fileRegular
}
xattrNames, err := xattr.List(fp)
if err != nil {
return fmt.Errorf("unable to list xattrs for %s: %v", fp, err)
}
xattrs := map[string]string{}
for _, name := range xattrNames {
val, err := xattr.Get(fp, name)
if err != nil {
return fmt.Errorf("unable to get xattr %s for %s: %v", name, fp, err)
}
xattrs[name] = string(val)
}
nlink, uid, gid := getFileProperties(fi)
entry = &finalizeFileInfo{
path: fp,
name: name,
isDir: fi.IsDir(),
isRoot: isRoot,
modTime: fi.ModTime(),
mode: m,
fileType: fType,
size: fi.Size(),
xattrs: xattrs,
uid: uid,
gid: gid,
links: nlink,
}
// we will have to save it as its parent
parentDir := filepath.Dir(fp)
parentDirInfo := dirMap[parentDir]
if fi.IsDir() {
entry.children = make([]*finalizeFileInfo, 0, 20)
dirMap[fp] = entry
} else {
// calculate blocks
entry.size = fi.Size()
}
if !isRoot {
parentDirInfo.children = append(parentDirInfo.children, entry)
dirMap[parentDir] = parentDirInfo
}
fileList = append(fileList, entry)
return nil
})
// reset the workspace
_ = os.Chdir(cwd)
return fileList, nil
}
func getTableIdx(m map[uint32]uint16, index uint32) uint16 {
for k, v := range m {
if k == index {
return v
}
}
// if we made it this far it doesn't exist, so add it
m[index] = uint16(len(m))
return m[index]
}
func writeFileDataBlocks(e *finalizeFileInfo, to util.File, ws string, startBlock uint64, blocksize int, compressor Compressor, location int64) (blockCount, compressed int, err error) {
from, err := os.Open(path.Join(ws, e.path))
if err != nil {
return 0, 0, fmt.Errorf("failed to open file for reading %s: %v", e.path, err)
}
defer from.Close()
raw, compressed, blocks, err := copyFileData(from, to, 0, location, int64(blocksize), compressor)
if err != nil {
return 0, 0, fmt.Errorf("error copying file %s: %v", e.Name(), err)
}
if raw%blocksize != 0 {
return 0, 0, fmt.Errorf("copying file %s copied %d which is not a multiple of blocksize %d", e.Name(), raw, blocksize)
}
// save the information we need for usage later in inodes to find the file data
e.dataLocation = location
e.blocks = blocks
e.startBlock = startBlock
// how many blocks did we write?
blockCount = raw / blocksize
return blockCount, compressed, nil
}
func writeMetadataBlock(buf []byte, to util.File, c Compressor, location int64) (int, error) {
// compress the block if needed
isCompressed := false
if c != nil {
out, err := c.compress(buf)
if err != nil {
return 0, fmt.Errorf("error compressing block: %v", err)
}
if len(out) < len(buf) {
isCompressed = true
buf = out
}
}
// the 2-byte (16-bit) header gives the block size
// the top bit is set if uncompressed
size := uint16(len(buf))
if !isCompressed {
size |= 1 << 15
}
header := make([]byte, 2)
binary.LittleEndian.PutUint16(header, size)
buf = append(header, buf...)
if _, err := to.WriteAt(buf, location); err != nil {
return 0, err
}
return len(buf), nil
}
func writeDataBlocks(fileList []*finalizeFileInfo, f util.File, ws string, blocksize int, compressor Compressor, location int64) (int, error) {
allBlocks := 0
allWritten := 0
for _, e := range fileList {
// only copy data for normal files
if e.fileType != fileRegular {
continue
}
blocks, written, err := writeFileDataBlocks(e, f, ws, uint64(allBlocks), blocksize, compressor, location)
if err != nil {
return allWritten, fmt.Errorf("error writing data for %s to file: %v", e.path, err)
}
allBlocks += blocks
allWritten += written
}
return allWritten, nil
}
// writeFragmentBlocks writes all of the fragment blocks to the archive. Returns slice of blocks written, the total bytes written, any error
func writeFragmentBlocks(fileList []*finalizeFileInfo, f util.File, ws string, blocksize int, options FinalizeOptions, location int64) ([]fragmentBlock, int64, error) {
compressor := options.Compression
if options.NoCompressFragments {
compressor = nil
}
fragmentData := make([]byte, 0)
var (
allWritten int64
fragmentBlockIndex uint32
fragmentBlocks []fragmentBlock
)
fileCloseList := make([]*os.File, 0)
defer func() {
for _, f := range fileCloseList {
f.Close()
}
}()
for _, e := range fileList {
// only copy data for regular files
if e.fileType != fileRegular {
continue
}
var (
written int64
err error
)
// how much is there to put in a fragment?
remainder := e.Size() % int64(blocksize)
if remainder == 0 {
continue
}
// would adding this data cause us to write?
if len(fragmentData)+int(remainder) > blocksize {
written, compressed, err := finalizeFragment(fragmentData, f, location, compressor)
if err != nil {
return fragmentBlocks, 0, fmt.Errorf("error writing fragment block %d: %v", fragmentBlockIndex, err)
}
fragmentBlocks = append(fragmentBlocks, fragmentBlock{
size: uint32(written),
compressed: compressed,
location: location,
})
// increment as all writes will be to next block block
fragmentBlockIndex++
fragmentData = fragmentData[:blocksize]
}
e.fragment = &fragmentRef{
block: fragmentBlockIndex,
offset: uint32(len(fragmentData)),
}
// save the fragment data from the file
from, err := os.Open(path.Join(ws, e.path))
if err != nil {
return fragmentBlocks, 0, fmt.Errorf("failed to open file for reading %s: %v", e.path, err)
}
fileCloseList = append(fileCloseList, from)
buf := make([]byte, remainder)
n, err := from.ReadAt(buf, e.Size()-remainder)
if err != nil && err != io.EOF {
return fragmentBlocks, 0, fmt.Errorf("error reading final %d bytes from file %s: %v", remainder, e.Name(), err)
}
if n != len(buf) {
return fragmentBlocks, 0, fmt.Errorf("failed reading final %d bytes from file %s, only read %d", remainder, e.Name(), n)
}
from.Close()
fragmentData = append(fragmentData, buf...)
allWritten += written
if written > 0 {
fragmentBlockIndex++
}
}
// write remaining fragment data
if len(fragmentData) > 0 {
written, compressed, err := finalizeFragment(fragmentData, f, location, compressor)
if err != nil {
return fragmentBlocks, 0, fmt.Errorf("error writing fragment block %d: %v", fragmentBlockIndex, err)
}
fragmentBlocks = append(fragmentBlocks, fragmentBlock{
size: uint32(written),
compressed: compressed,
location: location,
})
// increment as all writes will be to next block block
allWritten += int64(written)
}
return fragmentBlocks, allWritten, nil
}
func writeInodes(files []*finalizeFileInfo, f util.File, compressor Compressor, location int64) (inodesWritten int, finalLocation uint64, err error) {
var (
buf []byte
maxSize = int(metadataBlockSize)
initialLocation = location
)
for _, e := range files {
// keep writing until we run out, or we hit 8KB
buf = append(buf, e.inode.toBytes()...)
if len(buf) > maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return inodesWritten, 0, err
}
// count all we have written
inodesWritten += written
// increment for next write
location += int64(written)
// truncate all except what we wrote
buf = buf[maxSize:]
}
}
// was there anything left?
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return inodesWritten, 0, err
}
inodesWritten += written
}
return inodesWritten, uint64(initialLocation), nil
}
// writeDirectories write all directories out to disk. Assumes it already has been optimized.
func writeDirectories(dirs []*finalizeFileInfo, f util.File, compressor Compressor, location int64) (directoriesWritten int, finalLocation uint64, err error) {
var (
buf []byte
maxSize = int(metadataBlockSize)
initialLocation = location
)
for i, d := range dirs {
if d.directory == nil {
return 0, 0, fmt.Errorf("empty directory info for position %d", i)
}
// keep writing until we run out, or we hit metadata maxSize of 8KB
buf = append(buf, d.directory.toBytes(d.directory.inodeIndex)...)
if len(buf) > maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return directoriesWritten, 0, err
}
// count all we have written
directoriesWritten += written
// increment for next write
location += int64(written)
// truncate all except what we wrote
buf = buf[maxSize:]
}
}
// was there anything left?
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return directoriesWritten, 0, err
}
directoriesWritten += written
}
return directoriesWritten, uint64(initialLocation), nil
}
// writeFragmentTable write the fragment table
//
//nolint:unparam // this does not use fragmentBlocksStart yet, but only because we have not yet added support
func writeFragmentTable(fragmentBlocks []fragmentBlock, fragmentBlocksStart int64, f util.File, compressor Compressor, location int64) (fragmentsWritten int, finalLocation uint64, err error) {
// now write the actual fragment table entries
var (
indexEntries []uint64
)
var (
buf []byte
maxSize = int(metadataBlockSize)
)
for _, block := range fragmentBlocks {
// add an entry
b := make([]byte, 16)
size := block.size
if !block.compressed {
size |= 1 << 24
}
binary.LittleEndian.PutUint64(b[0:8], uint64(block.location))
binary.LittleEndian.PutUint32(b[8:12], size)
buf = append(buf, b...)
if len(buf) >= maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return fragmentsWritten, 0, err
}
// save an entry in the index table
indexEntries = append(indexEntries, uint64(location))
// count all we have written
fragmentsWritten += written
// increment for next write
location += int64(written)
// truncate all except what we wrote
buf = buf[maxSize:]
}
}
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return fragmentsWritten, 0, err
}
// save an entry in the index table
indexEntries = append(indexEntries, uint64(location))
// count all we have written
fragmentsWritten += written
location += int64(written)
}
// finally write the lookup table at the end
buf = make([]byte, len(indexEntries)*8)
for i, e := range indexEntries {
binary.LittleEndian.PutUint64(buf[i*8:i*8+8], e)
}
// just write it out
written, err := f.WriteAt(buf, location)
if err != nil {
return fragmentsWritten, 0, fmt.Errorf("error writing fragment table lookup index: %v", err)
}
fragmentsWritten += written
return fragmentsWritten, uint64(location), nil
}
// writeExportTable write the export table at the given location.
func writeExportTable(files []*finalizeFileInfo, f util.File, compressor Compressor, location int64) (entriesWritten int, finalLocation uint64, err error) {
var (
maxSize = int(metadataBlockSize)
)
// the lookup table is pretty simple. It is just a single array of uint64. So inode 1 is in the first
// entry, inode 2 in the second, etc. (inode 0 is reserved and unused).
// The value of each entry is just the inode reference in the archive.
// An "inode reference" is a 64-bit number structured as follows:
// - upper 16 bits unused
// - next 32 bits position of first byte of inode metadata block that contains this inode, relative to the start of the inode table
// - lowest 16 bits are offset into the uncompressed block
var (
indexEntries []uint64
buf []byte
)
for _, e := range files {
entry := make([]byte, 8)
binary.LittleEndian.PutUint32(entry[2:6], e.inodeLocation.block)
binary.LittleEndian.PutUint16(entry[6:8], e.inodeLocation.offset)
buf = append(buf, entry...)
if len(buf) >= maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return entriesWritten, 0, err
}
// count all we have written
entriesWritten += written
buf = buf[maxSize:]
indexEntries = append(indexEntries, uint64(location))
location += int64(written)
}
}
// any leftover?
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return entriesWritten, 0, err
}
// count all we have written
entriesWritten += written
indexEntries = append(indexEntries, uint64(location))
location += int64(written)
}
// now write the lookup table - 8 bytes for each entry
buf = make([]byte, len(indexEntries)*8)
for i, e := range indexEntries {
binary.LittleEndian.PutUint64(buf[i*8:i*8+8], e)
}
// just write it out
written, err := f.WriteAt(buf, location)
if err != nil {
return entriesWritten, 0, fmt.Errorf("error writing export table lookup index: %v", err)
}
entriesWritten += written
return entriesWritten, uint64(location), nil
}
// writeIDTable write the uidgid table at the given location.
func writeIDTable(idtable map[uint32]uint16, f util.File, compressor Compressor, location int64) (entriesWritten int, finalLocation uint64, err error) {
var (
maxSize = int(metadataBlockSize)
)
// to write the idtable, we need to convert the map of target ID (uid/gid) -> index into an array by index
idArray := make([]uint32, len(idtable))
for k, v := range idtable {
idArray[v] = k
}
// the lookup table is pretty simple. It is just a single array of uint32.
// The value of each entry is just the ID number.
var (
buf []byte
indexEntries []uint64
)
for _, id := range idArray {
entry := make([]byte, 4)
binary.LittleEndian.PutUint32(entry, id)
buf = append(buf, entry...)
if len(buf) >= maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return entriesWritten, 0, err
}
// count all we have written
entriesWritten += written
buf = buf[maxSize:]
indexEntries = append(indexEntries, uint64(location))
location += int64(written)
}
}
// any leftover?
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return entriesWritten, 0, err
}
// count all we have written
entriesWritten += written
indexEntries = append(indexEntries, uint64(location))
location += int64(written)
}
// now write the lookup table - 8 bytes for each entry
buf = make([]byte, len(indexEntries)*8)
for i, e := range indexEntries {
binary.LittleEndian.PutUint64(buf[i*8:i*8+8], e)
}
// just write it out
written, err := f.WriteAt(buf, location)
if err != nil {
return entriesWritten, 0, fmt.Errorf("error writing uidgid table lookup index: %v", err)
}
entriesWritten += written
return entriesWritten, uint64(location), nil
}
// writeXattrs write the xattrs and its lookup table at the given location.
func writeXattrs(xattrs []map[string]string, f util.File, compressor Compressor, location int64) (xattrsWritten int, finalLocation uint64, err error) {
var (
maxSize = int(metadataBlockSize)
offset int
lookupTable []byte
buf []byte
)
// each entry in the xattrs slice is a unique key-value map. It may be referenced by one or more inodes.
// first convert them to key-value written pairs, and save where they are
for _, m := range xattrs {
// process one xattr key-value map
var single []byte
for k, v := range m {
// convert it to the proper type
// the entry
prefix, name, err := xAttrKeyConvert(k)
if err != nil {
return xattrsWritten, 0, err
}
b := make([]byte, 4)
binary.LittleEndian.PutUint16(b[0:2], prefix)
binary.LittleEndian.PutUint16(b[2:4], uint16(len(k)))
b = append(b, []byte(name)...)
single = append(single, b...)
b = make([]byte, 4)
binary.LittleEndian.PutUint32(b[0:4], uint32(len(v)))
b = append(b, []byte(v)...)
single = append(single, b...)
}
// add the index
b := make([]byte, 16)
// bits 16:48 (uint32) hold the block position
binary.LittleEndian.PutUint32(b[2:6], uint32(xattrsWritten))
// bits 48:64 (uint16) hold the offset in the uncompressed block
binary.LittleEndian.PutUint16(b[6:8], uint16(offset))
// bytes 8:12 (uint32) hold the number of pairs
binary.LittleEndian.PutUint32(b[8:12], uint32(len(m)))
// bytes 12:16 (uint32) hold the size of the entire map for this inode
binary.LittleEndian.PutUint32(b[12:16], uint32(len(single)))
// add the lookupTable bytes
lookupTable = append(lookupTable, b...)
// add the actual metadata bytes
buf = append(buf, single...)
// the offset is moved forward
offset += len(single)
if len(buf) > maxSize {
written, err := writeMetadataBlock(buf[:maxSize], f, compressor, location)
if err != nil {
return xattrsWritten, 0, err
}
// count all we have written
xattrsWritten += written
buf = buf[maxSize:]
offset -= maxSize
location += int64(written)
}
}
// if there is anything left at the end
if len(buf) > 0 {
written, err := writeMetadataBlock(buf, f, compressor, location)
if err != nil {
return xattrsWritten, 0, err
}
// count all we have written
xattrsWritten += written
location += int64(written)
}
// hold the id table lookup
var indexEntries []uint64
// write the lookupTable - this too is stored as metadata blocks
var i int
for i = 0; i < len(lookupTable); i += maxSize {
written, err := writeMetadataBlock(lookupTable[i*maxSize:i*maxSize+maxSize], f, compressor, location)
if err != nil {
return xattrsWritten, 0, err
}
indexEntries = append(indexEntries, uint64(location))
// count all we have written
xattrsWritten += written
location += int64(written)
}
// was there any left?
remainder := len(lookupTable) % maxSize
if remainder > 0 {
written, err := writeMetadataBlock(lookupTable[remainder:], f, compressor, location)
if err != nil {
return xattrsWritten, 0, err
}
indexEntries = append(indexEntries, uint64(location))
// count all we have written
xattrsWritten += written
location += int64(written)
}
// finally, we need the ID table
b := make([]byte, 16+8*len(indexEntries))
binary.LittleEndian.PutUint64(b[0:8], uint64(location))
binary.LittleEndian.PutUint32(b[8:12], uint32(len(lookupTable)))
for _, e := range indexEntries {
b2 := make([]byte, 8)
binary.LittleEndian.PutUint64(b2, e)
b = append(b, b2...)
}
// just write it out
written, err := f.WriteAt(b, location)
if err != nil {
return xattrsWritten, 0, fmt.Errorf("error writing xattrs id index: %v", err)
}
xattrsWritten += written
return xattrsWritten, uint64(location), nil
}
func xAttrKeyConvert(key string) (prefixID uint16, prefix string, err error) {
// get the prefix
wholePrefix := strings.SplitN(key, ".", 2)
if len(wholePrefix) != 2 {
return 0, "", fmt.Errorf("invalid xattr key: %s", key)
}
switch wholePrefix[0] {
case "user":
prefixID = 0
case "trusted":
prefixID = 1
case "security":
prefixID = 2
default:
return 0, "", fmt.Errorf("unknown xattr key: %s", key)
}
return prefixID, wholePrefix[1], nil
}
// createInodes create an inode of appropriate type for each file, and attach it to the finalizeFileInfo
func createInodes(fileList []*finalizeFileInfo, idtable map[uint32]uint16, options FinalizeOptions) error {
// get the inodes
var inodeIndex uint32 = 1
// need to keep track of directory position in directory table
// build our inodes for our files - must include all file types
for _, e := range fileList {
var (
in inodeBody
inodeT inodeType
)
switch e.fileType {
case fileRegular:
/*
use an extendedFile if any of the above is true:
- startBlock (from beginning of data section) does not fit in uint32
- fileSize does not fit in uint32
- it is a sparse file
- it has extended attributes
- it has hard links
*/
if e.startBlock|uint32max != uint32max || e.Size()|int64(uint32max) != int64(uint32max) || len(e.xattrs) > 0 || e.links > 0 {
// use extendedFile inode
ef := &extendedFile{
startBlock: e.startBlock,
fileSize: uint64(e.Size()),
blockSizes: e.blocks,
links: e.links,
xAttrIndex: e.xAttrIndex,
}
if e.fragment != nil {
ef.fragmentBlockIndex = e.fragment.block
ef.fragmentOffset = e.fragment.offset
}
in = ef
inodeT = inodeExtendedFile
} else {
// use basicFile
bf := &basicFile{
startBlock: uint32(e.startBlock),
fileSize: uint32(e.Size()),
blockSizes: e.blocks,
}
if e.fragment != nil {
bf.fragmentBlockIndex = e.fragment.block
bf.fragmentOffset = e.fragment.offset
}
in = bf
inodeT = inodeBasicFile
}
case fileSymlink:
/*
use an extendedSymlink if it has extended attributes
- startBlock (from beginning of data section) does not fit in uint32
- fileSize does not fit in uint32
- it is a sparse file
- it has extended attributes
- it has hard links
*/
target, err := os.Readlink(e.path)
if err != nil {
return fmt.Errorf("unable to read target for symlink at %s: %v", e.path, err)
}
if len(e.xattrs) > 0 {
in = &extendedSymlink{
links: e.links,
target: target,
xAttrIndex: e.xAttrIndex,
}
inodeT = inodeExtendedSymlink
} else {
in = &basicSymlink{
links: e.links,
target: target,
}
inodeT = inodeBasicSymlink
}
case fileDirectory:
/*
use an extendedDirectory if any of the following is true:
- the directory itself has extended attributes
- the size of the directory does not fit in a single metadata block, i.e. >8K uncompressed
- it has more than 256 entries
*/
if e.startBlock|uint32max != uint32max || e.Size()|int64(uint32max) != int64(uint32max) || len(e.xattrs) > 0 || e.links > 0 {
// use extendedDirectory inode
in = &extendedDirectory{
startBlock: uint32(e.startBlock),
fileSize: uint32(e.Size()),
links: e.links,
xAttrIndex: e.xAttrIndex,
}
inodeT = inodeExtendedDirectory
} else {
// use basicDirectory
in = &basicDirectory{
startBlock: uint32(e.startBlock),
links: e.links,
fileSize: uint16(e.Size()),
}
inodeT = inodeBasicDirectory
}
case fileBlock:
major, minor, err := getDeviceNumbers(e.path)
if err != nil {
return fmt.Errorf("unable to read major/minor device numbers for block device at %s: %v", e.path, err)
}
if len(e.xattrs) > 0 {
in = &extendedBlock{
extendedDevice{
links: e.links,
major: major,
minor: minor,
xAttrIndex: e.xAttrIndex,
},
}
inodeT = inodeExtendedBlock
} else {
in = &basicBlock{
basicDevice{
links: e.links,
major: major,
minor: minor,
},
}
inodeT = inodeBasicBlock
}
case fileChar:
major, minor, err := getDeviceNumbers(e.path)
if err != nil {
return fmt.Errorf("unable to read major/minor device numbers for char device at %s: %v", e.path, err)
}
if len(e.xattrs) > 0 {
in = &extendedChar{
extendedDevice{
links: e.links,
major: major,
minor: minor,
xAttrIndex: e.xAttrIndex,
},
}
inodeT = inodeExtendedChar
} else {
in = &basicChar{
basicDevice{
links: e.links,
major: major,
minor: minor,
},
}
inodeT = inodeBasicChar
}
case fileFifo:
if len(e.xattrs) > 0 {
in = &extendedFifo{
extendedIPC{
links: e.links,
xAttrIndex: e.xAttrIndex,
},
}
inodeT = inodeExtendedFifo
} else {
in = &basicFifo{
basicIPC{
links: e.links,
},
}
inodeT = inodeBasicFifo
}
case fileSocket:
if len(e.xattrs) > 0 {
in = &extendedSocket{
extendedIPC{
links: e.links,
xAttrIndex: e.xAttrIndex,
},
}
inodeT = inodeExtendedSocket
} else {
in = &basicSocket{
basicIPC{
links: e.links,
},
}
inodeT = inodeBasicSocket
}
}
// set the uid and gid
uid := e.uid
gid := e.gid
if options.FileUID != nil {
uid = *options.FileUID
}
if options.FileGID != nil {
gid = *options.FileGID
}
// get index to the uid and gid
uidIdx := getTableIdx(idtable, uid)
gidIdx := getTableIdx(idtable, gid)
e.inode = &inodeImpl{
header: &inodeHeader{
inodeType: inodeT,
modTime: e.ModTime(),
mode: e.Mode(),
uidIdx: uidIdx,
gidIdx: gidIdx,
index: inodeIndex,
},
body: in,
}
inodeIndex++
}
return nil
}
// extractXattrs take all of the extended attributes on the finalizeFileInfo
// and write them out. Returns a slice of all unique xattr key-value pairs.
func extractXattrs(list []*finalizeFileInfo) []map[string]string {
var (
xattrs []map[string]string
indexMap = map[string]int{}
)
for _, e := range list {
if len(e.xattrs) == 0 {
e.xAttrIndex = noXattrInodeFlag
continue
}
var (
index int
key = hashStringMap(e.xattrs)
)
if pos, ok := indexMap[key]; ok {
// reference already-existing duplicates
index = pos
} else {
index = len(xattrs)
xattrs = append(xattrs, e.xattrs)
// save the unique combination
indexMap[key] = index
}
e.xAttrIndex = uint32(index)
}
return xattrs
}
// hashStringMap make a unique hash out of a string map, to make it easy to compare
func hashStringMap(m map[string]string) string {
// simple algorithm is good enough for this
// just join all of the key-value pairs with =, and separate with ;, so you get
// key1=value1;key2=value2;...
// it isn't perfect, but it doesn't have to be
pairs := make([]string, 0)
for k, v := range m {
pairs = append(pairs, fmt.Sprintf("%s=%s", k, v))
}
return strings.Join(pairs, ";")
}
// fragmentBlock size and compression of a single fragment block
type fragmentBlock struct {
size uint32
compressed bool
location int64
}
// blockPosition position of something inside a data or metadata section.
// Includes the block number relative to the start, and the offset within
// the block.
type blockPosition struct {
block uint32
offset uint16
size int
}
// createDirectories append directory structure to every finalizeFileInfo that is a directory.
// Returns a slice pointing to all finalizeFileInfo that are directories and have been populated.
func createDirectories(e *finalizeFileInfo) []*finalizeFileInfo {
var (
dirs = make([]*finalizeFileInfo, 0)
entries = make([]*directoryEntryRaw, 0)
)
// go through each entry, and create a directory structure for it
// we will cycle through each directory, creating an entry for it
// and its children. A second pass will split into headers
for _, child := range e.children {
blockPos := child.inodeLocation
var iType inodeType
switch child.fileType {
case fileRegular:
iType = inodeBasicFile
case fileSymlink:
iType = inodeBasicSymlink
case fileDirectory:
iType = inodeBasicDirectory
case fileBlock:
iType = inodeBasicBlock
case fileChar:
iType = inodeBasicChar
case fileFifo:
iType = inodeBasicFifo
case fileSocket:
iType = inodeBasicSocket
}
entry := &directoryEntryRaw{
name: child.Name(),
isSubdirectory: child.IsDir(),
startBlock: blockPos.block,
offset: blockPos.offset,
inodeType: iType,
inodeNumber: child.inode.index(),
// we do not yet know the inodeNumber, which is an offset from the one in the header
// it will be filled in later
}
// set the inode type. It doesn't use extended, just the basic ones.
entries = append(entries, entry)
}
e.directory = &directory{
entries: entries,
}
dirs = append(dirs, e)
// do children in a separate loop, so that we get all of the children lined up
for _, child := range e.children {
if child.IsDir() {
dirs = append(dirs, createDirectories(child)...)
}
}
return dirs
}
// updateInodeLocations update each inode with where it will be on disk
// i.e. the inode block, and the offset into the block
func updateInodeLocations(files []*finalizeFileInfo) {
var pos int64
// get block position for each inode
for _, f := range files {
b := f.inode.toBytes()
block, offset := uint32(pos/metadataBlockSize), uint16(pos%metadataBlockSize)
blockPos := block * (standardMetadataBlocksize + 2)
f.inodeLocation = blockPosition{
block: blockPos,
offset: offset,
size: len(b),
}
pos += int64(len(b))
}
}
// populateDirectoryLocations get a map of each directory index and where it will be
// on disk i.e. the directory block, and the offset into the block
func populateDirectoryLocations(directories []*finalizeFileInfo) {
// keeps our reference
pos := 0
// get block position for each inode
for _, d := range directories {
// we start without knowing the inode block/number
// in any case, this func is just here to give us sizes and therefore
// locations inside the directory metadata blocks, not actual writable
// bytes
if d.directory == nil {
continue
}
b := d.directory.toBytes(0)
d.directoryLocation = blockPosition{
block: uint32(pos / int(metadataBlockSize)),
offset: uint16(pos % int(metadataBlockSize)),
size: len(b),
}
pos += len(b)
}
}
// updateInodesFromDirectories update the blockPosition for each directory
// inode.
func updateInodesFromDirectories(files []*finalizeFileInfo) error {
// go through each directory, find its inode, and update it with the
// correct block and offset
for i, d := range files {
if d.directory == nil {
return fmt.Errorf("file at index %d missing directory information", i)
}
index := d.directory.inodeIndex
in := d.inode
inBody := in.getBody()
switch dir := inBody.(type) {
case *basicDirectory:
dir.startBlock = d.directoryLocation.block
dir.offset = d.directoryLocation.offset
dir.fileSize = uint16(d.directoryLocation.size)
case *extendedDirectory:
dir.startBlock = d.directoryLocation.block
dir.offset = d.directoryLocation.offset
dir.fileSize = uint32(d.directoryLocation.size)
default:
return fmt.Errorf("inode at index %d from directory at index %d was unexpected type", index, i)
}
}
return nil
}
07070100000332000081A4000000000000000000000001645E367C000003B1000000000000000000000000000000000000005C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/finalize_unix.go //go:build aix || darwin || dragonfly || freebsd || (js && wasm) || linux || nacl || netbsd || openbsd || solaris
// +build aix darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
//nolint:unconvert // linter gets confused in this file
package squashfs
import (
"os"
"golang.org/x/sys/unix"
)
func getDeviceNumbers(path string) (major, minor uint32, err error) {
stat := unix.Stat_t{}
err = unix.Stat(path, &stat)
if err != nil {
return 0, 0, err
}
return uint32(stat.Rdev / 256), uint32(stat.Rdev % 256), nil
}
func getFileProperties(fi os.FileInfo) (links, uid, gid uint32) {
if sys := fi.Sys(); sys != nil {
if stat, ok := sys.(*unix.Stat_t); ok {
links = uint32(stat.Nlink)
uid = stat.Uid
gid = stat.Gid
}
}
return links, uid, gid
}
//nolint:deadcode // this is here solely so that linter does not complain on darwin about unconvert
func unused() uint32 {
var f uint32 = 25
return uint32(f)
}
07070100000333000081A4000000000000000000000001645E367C000000E2000000000000000000000000000000000000005F00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/finalize_windows.go package squashfs
import (
"os"
"syscall"
)
func getDeviceNumbers(path string) (uint32, uint32, error) {
return 0, 0, syscall.EWINDOWS
}
func getFileProperties(fi os.FileInfo) (uint32, uint32, uint32) {
return 0, 0, 0
}
07070100000334000081A4000000000000000000000001645E367C00000814000000000000000000000000000000000000005F00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/finalizefileinfo.go package squashfs
import (
"os"
"time"
)
// finalizeFileInfo is a file info useful for finalization
// fulfills os.FileInfo
//
// Name() string // base name of the file
// Size() int64 // length in bytes for regular files; system-dependent for others
// Mode() FileMode // file mode bits
// ModTime() time.Time // modification time
// IsDir() bool // abbreviation for Mode().IsDir()
// Sys() interface{} // underlying data source (can return nil)
//
//nolint:structcheck // we are willing to leave unused elements here so that we can know their reference
type finalizeFileInfo struct {
path string
target string
location uint32
recordSize uint8
depth int
name string
size int64
mode os.FileMode
modTime time.Time
isDir bool
isRoot bool
bytes [][]byte
parent *finalizeFileInfo
children []*finalizeFileInfo
content []byte
dataLocation int64
fileType fileType
inode inode
inodeLocation blockPosition
xattrs map[string]string
xAttrIndex uint32
links uint32
blocks []*blockData
startBlock uint64
fragment *fragmentRef
uid uint32
gid uint32
directory *directory
directoryLocation blockPosition
}
func (fi *finalizeFileInfo) Name() string {
return fi.name
}
func (fi *finalizeFileInfo) Size() int64 {
return fi.size
}
func (fi *finalizeFileInfo) Mode() os.FileMode {
return fi.mode
}
func (fi *finalizeFileInfo) ModTime() time.Time {
return fi.modTime
}
func (fi *finalizeFileInfo) IsDir() bool {
return fi.isDir
}
func (fi *finalizeFileInfo) Sys() interface{} {
return nil
}
// add depth to all children
func (fi *finalizeFileInfo) addProperties(depth int) {
fi.depth = depth
for _, e := range fi.children {
e.parent = fi
e.addProperties(depth + 1)
}
}
type fragmentRef struct {
block uint32
offset uint32
}
07070100000335000081A4000000000000000000000001645E367C000004A8000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/fragment.go package squashfs
import (
"encoding/binary"
"fmt"
)
//nolint:deadcode,varcheck,unused // we need these references in the future
const (
fragmentEntriesPerBlock = 512
fragmentEntrySize = 16
)
type fragmentEntry struct {
start uint64
size uint32
compressed bool
}
//nolint:structcheck,deadcode,unused // we need these references in the future
type fragmentTable struct {
entries []*fragmentEntry
}
func (f *fragmentEntry) toBytes() []byte {
b := make([]byte, 16)
binary.LittleEndian.PutUint64(b[0:8], f.start)
size := f.size
if !f.compressed {
size |= (1 << 24)
}
binary.LittleEndian.PutUint32(b[8:12], size)
return b
}
func parseFragmentEntry(b []byte) (*fragmentEntry, error) {
target := 16
if len(b) < target {
return nil, fmt.Errorf("mismatched fragment entry size, received %d bytes, less than minimum %d", len(b), target)
}
start := binary.LittleEndian.Uint64(b[0:8])
size := binary.LittleEndian.Uint32(b[8:12])
unCompFlag := uint32(1 << 24)
compressed := true
if size&unCompFlag == unCompFlag {
compressed = false
}
size &= 0xffffff
return &fragmentEntry{
size: size,
compressed: compressed,
start: start,
}, nil
}
07070100000336000081A4000000000000000000000001645E367C000059DF000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/inode.go package squashfs
import (
"encoding/binary"
"fmt"
"os"
"time"
)
type inodeType uint16
const (
inodeBasicDirectory inodeType = 1
inodeBasicFile inodeType = 2
inodeBasicSymlink inodeType = 3
inodeBasicBlock inodeType = 4
inodeBasicChar inodeType = 5
inodeBasicFifo inodeType = 6
inodeBasicSocket inodeType = 7
inodeExtendedDirectory inodeType = 8
inodeExtendedFile inodeType = 9
inodeExtendedSymlink inodeType = 10
inodeExtendedBlock inodeType = 11
inodeExtendedChar inodeType = 12
inodeExtendedFifo inodeType = 13
inodeExtendedSocket inodeType = 14
)
const (
inodeHeaderSize = 16
inodeDirectoryIndexEntrySize = 3*4 + 1
)
type inodeHeader struct {
inodeType inodeType
uidIdx uint16
gidIdx uint16
modTime time.Time
index uint32
mode os.FileMode
// permissions
}
type inodeBody interface {
toBytes() []byte
size() int64
xattrIndex() (uint32, bool)
equal(inodeBody) bool
}
type inode interface {
toBytes() []byte
equal(inode) bool
size() int64
inodeType() inodeType
index() uint32
getHeader() *inodeHeader
getBody() inodeBody
}
type inodeImpl struct {
header *inodeHeader
body inodeBody
}
func (i *inodeImpl) equal(o inode) bool {
other, ok := o.(*inodeImpl)
if !ok {
return false
}
if (i.header == nil && other.header != nil) || (i.header != nil && other.header == nil) || (i.header != nil && other.header != nil && *i.header != *other.header) {
return false
}
if (i.body == nil && other.body != nil) || (i.body != nil && other.body == nil) || (i.body != nil && other.body != nil && !i.body.equal(other.body)) {
return false
}
return true
}
func (i *inodeImpl) toBytes() []byte {
h := i.header.toBytes()
b := i.body.toBytes()
return append(h, b...)
}
func (i *inodeImpl) inodeType() inodeType {
return i.header.inodeType
}
func (i *inodeImpl) index() uint32 {
return i.header.index
}
// Size return the size of the item reflected by this inode, if it supports it
func (i *inodeImpl) size() int64 {
return i.body.size()
}
func (i *inodeImpl) getHeader() *inodeHeader {
return i.header
}
func (i *inodeImpl) getBody() inodeBody {
return i.body
}
func (i *inodeHeader) toBytes() []byte {
b := make([]byte, inodeHeaderSize)
binary.LittleEndian.PutUint16(b[0:2], uint16(i.inodeType))
binary.LittleEndian.PutUint16(b[2:4], uint16(i.mode))
binary.LittleEndian.PutUint16(b[4:6], i.uidIdx)
binary.LittleEndian.PutUint16(b[6:8], i.gidIdx)
binary.LittleEndian.PutUint32(b[8:12], uint32(i.modTime.Unix()))
binary.LittleEndian.PutUint32(b[12:16], i.index)
return b
}
func parseInodeHeader(b []byte) (*inodeHeader, error) {
target := inodeHeaderSize
if len(b) < target {
return nil, fmt.Errorf("received only %d bytes instead of minimum %d", len(b), target)
}
i := &inodeHeader{
inodeType: inodeType(binary.LittleEndian.Uint16(b[0:2])),
mode: os.FileMode(binary.LittleEndian.Uint16(b[2:4])),
uidIdx: binary.LittleEndian.Uint16(b[4:6]),
gidIdx: binary.LittleEndian.Uint16(b[6:8]),
modTime: time.Unix(int64(binary.LittleEndian.Uint32(b[8:12])), 0),
index: binary.LittleEndian.Uint32(b[12:16]),
}
return i, nil
}
// blockdata used by files and directories
type blockData struct {
size uint32
compressed bool
}
func (b *blockData) toUint32() uint32 {
u := b.size
if !b.compressed {
u |= (1 << 24)
}
return u
}
func parseBlockData(u uint32) *blockData {
var mask uint32 = 1 << 24
return &blockData{
compressed: u&mask != mask,
size: u & 0x00ffffff,
}
}
func parseFileBlockSizes(b []byte, fileSize, blocksize int) []*blockData {
count := fileSize / blocksize
blocks := make([]*blockData, 0)
for j := 0; j < count && j < len(b); j += 4 {
blocks = append(blocks, parseBlockData(binary.LittleEndian.Uint32(b[j:j+4])))
}
return blocks
}
// inodeTypeToSize return the minimum size of the inode body including the header
func inodeTypeToSize(i inodeType) int {
size := inodeTypeToBodySize(i)
if size != 0 {
size += inodeHeaderSize
}
return size
}
// inodeTypeToBodySize return the minimum size of the inode body not including the header
func inodeTypeToBodySize(i inodeType) int {
var size int
switch i {
case inodeBasicDirectory:
size = 16
case inodeExtendedDirectory:
size = 24
case inodeBasicFile:
size = 16
case inodeExtendedFile:
size = 40
case inodeBasicChar:
size = 8
case inodeExtendedChar:
size = 12
case inodeBasicFifo:
size = 4
case inodeExtendedFifo:
size = 8
case inodeBasicSymlink:
size = 9
case inodeExtendedSymlink:
size = 13
case inodeBasicBlock:
size = 8
case inodeExtendedBlock:
size = 12
case inodeBasicSocket:
size = 4
case inodeExtendedSocket:
size = 8
default:
return 0
}
return size
}
/*
All of our 14 inode types
*/
// basicDirectory
type basicDirectory struct {
startBlock uint32
links uint32
fileSize uint16
offset uint16
parentInodeIndex uint32
}
func (i basicDirectory) toBytes() []byte {
b := make([]byte, 16)
binary.LittleEndian.PutUint32(b[0:4], i.startBlock)
binary.LittleEndian.PutUint32(b[4:8], i.links)
binary.LittleEndian.PutUint16(b[8:10], i.fileSize)
binary.LittleEndian.PutUint16(b[10:12], i.offset)
binary.LittleEndian.PutUint32(b[12:16], i.parentInodeIndex)
return b
}
func (i basicDirectory) size() int64 {
return int64(i.fileSize)
}
func (i basicDirectory) xattrIndex() (uint32, bool) {
return 0, false
}
func (i basicDirectory) equal(o inodeBody) bool {
oi, ok := o.(basicDirectory)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseBasicDirectory(b []byte) (*basicDirectory, error) {
target := 16
if len(b) < target {
return nil, fmt.Errorf("received %d bytes, fewer than minimum %d", len(b), target)
}
d := &basicDirectory{
startBlock: binary.LittleEndian.Uint32(b[0:4]),
links: binary.LittleEndian.Uint32(b[4:8]),
fileSize: binary.LittleEndian.Uint16(b[8:10]),
offset: binary.LittleEndian.Uint16(b[10:12]),
parentInodeIndex: binary.LittleEndian.Uint32(b[12:16]),
}
return d, nil
}
// directoryIndex
type directoryIndex struct {
index uint32
block uint32
size uint32
name byte
}
// extendedDirectory
type extendedDirectory struct {
links uint32
fileSize uint32
startBlock uint32
parentInodeIndex uint32
indexCount uint16
offset uint16
xAttrIndex uint32
indexes []*directoryIndex
}
func (i extendedDirectory) toBytes() []byte {
b := make([]byte, 24)
binary.LittleEndian.PutUint32(b[0:4], i.links)
binary.LittleEndian.PutUint32(b[4:8], i.fileSize)
binary.LittleEndian.PutUint32(b[8:12], i.startBlock)
binary.LittleEndian.PutUint32(b[12:16], i.parentInodeIndex)
binary.LittleEndian.PutUint16(b[16:18], i.indexCount)
binary.LittleEndian.PutUint16(b[18:20], i.offset)
binary.LittleEndian.PutUint32(b[20:24], i.xAttrIndex)
return b
}
func (i extendedDirectory) size() int64 {
return int64(i.fileSize)
}
func (i extendedDirectory) xattrIndex() (uint32, bool) {
return i.xAttrIndex, i.xAttrIndex != noXattrInodeFlag
}
func (i extendedDirectory) equal(o inodeBody) bool {
oi, ok := o.(extendedDirectory)
if !ok {
return false
}
if len(i.indexes) != len(oi.indexes) {
return false
}
for c, elm := range i.indexes {
if *elm != *oi.indexes[c] {
return false
}
}
return i.links == oi.links && i.fileSize == oi.fileSize && i.startBlock == oi.startBlock &&
i.parentInodeIndex == oi.parentInodeIndex && i.indexCount == oi.indexCount &&
i.offset == oi.offset && i.xAttrIndex == oi.xAttrIndex
}
func parseExtendedDirectory(b []byte) (*extendedDirectory, int, error) {
var (
target = 24
extra int
)
if len(b) < target {
return nil, 0, fmt.Errorf("received %d bytes, fewer than minimum %d", len(b), target)
}
d := &extendedDirectory{
links: binary.LittleEndian.Uint32(b[0:4]),
fileSize: binary.LittleEndian.Uint32(b[4:8]),
startBlock: binary.LittleEndian.Uint32(b[8:12]),
parentInodeIndex: binary.LittleEndian.Uint32(b[12:16]),
indexCount: binary.LittleEndian.Uint16(b[16:18]),
offset: binary.LittleEndian.Uint16(b[18:20]),
xAttrIndex: binary.LittleEndian.Uint32(b[20:24]),
}
// see how many other bytes we need to read for directory indexes
//
// each entry in indexes is a struct squashfs_dir_index, which is:
// struct squashfs_dir_index {
// unsigned int index;
// unsigned int start_block;
// unsigned int size;
// unsigned char name[0];
// };
// so each is 4 int + 1 char
extra = int(d.indexCount) * inodeDirectoryIndexEntrySize
// do we have enough data left to read those?
if len(b[target:]) >= extra {
indexes, err := parseDirectoryIndexes(b[target:target+extra], int(d.indexCount))
if err != nil {
return d, 0, err
}
d.indexes = indexes
extra = 0
}
return d, extra, nil
}
// parseDirectoryIndexes parse count directoryIndex from the given byte data
func parseDirectoryIndexes(b []byte, count int) ([]*directoryIndex, error) {
var (
indexes []*directoryIndex
expectedSize = count * inodeDirectoryIndexEntrySize
)
if len(b) < expectedSize {
return nil, fmt.Errorf("expected at least %d bytes, received only %d", expectedSize, len(b))
}
for i := 0; i < len(b); i += inodeDirectoryIndexEntrySize {
indexes = append(indexes, &directoryIndex{
index: binary.LittleEndian.Uint32(b[0:4]),
block: binary.LittleEndian.Uint32(b[4:8]),
size: binary.LittleEndian.Uint32(b[8:12]),
name: b[12],
})
}
return indexes, nil
}
// basicFile
type basicFile struct {
startBlock uint32 // block count from the start of the data section where data for this file is stored
fragmentBlockIndex uint32
fragmentOffset uint32
fileSize uint32
blockSizes []*blockData
}
func (i basicFile) equal(o inodeBody) bool {
oi, ok := o.(basicFile)
if !ok {
return false
}
if len(i.blockSizes) != len(oi.blockSizes) {
return false
}
for i, b := range i.blockSizes {
if (b == nil && oi.blockSizes[i] == nil) || (b != nil && oi.blockSizes[i] == nil) {
return false
}
if *b != *oi.blockSizes[i] {
return false
}
}
return i.startBlock == oi.startBlock && i.fragmentOffset == oi.fragmentOffset && i.fragmentBlockIndex == oi.fragmentBlockIndex && i.fileSize == oi.fileSize
}
func (i basicFile) toBytes() []byte {
b := make([]byte, 16+4*len(i.blockSizes))
binary.LittleEndian.PutUint32(b[0:4], i.startBlock)
binary.LittleEndian.PutUint32(b[4:8], i.fragmentBlockIndex)
binary.LittleEndian.PutUint32(b[8:12], i.fragmentOffset)
binary.LittleEndian.PutUint32(b[12:16], i.fileSize)
for j, e := range i.blockSizes {
binary.LittleEndian.PutUint32(b[16+j*4:16+j*4+4], e.toUint32())
}
return b
}
func (i basicFile) size() int64 {
return int64(i.fileSize)
}
func (i basicFile) xattrIndex() (uint32, bool) {
return 0, false
}
func (i basicFile) toExtended() extendedFile {
return extendedFile{
startBlock: uint64(i.startBlock),
fileSize: uint64(i.fileSize),
sparse: 0,
links: 0,
fragmentBlockIndex: i.fragmentBlockIndex,
fragmentOffset: i.fragmentOffset,
xAttrIndex: 0,
blockSizes: i.blockSizes,
}
}
func parseBasicFile(b []byte, blocksize int) (*basicFile, int, error) {
var (
target = 16
extra int
)
if len(b) < target {
return nil, 0, fmt.Errorf("received %d bytes, fewer than minimum %d", len(b), target)
}
fileSize := binary.LittleEndian.Uint32(b[12:16])
d := &basicFile{
startBlock: binary.LittleEndian.Uint32(b[0:4]),
fragmentBlockIndex: binary.LittleEndian.Uint32(b[4:8]),
fragmentOffset: binary.LittleEndian.Uint32(b[8:12]),
fileSize: fileSize,
}
// see how many other bytes we need to read
blockListSize := int(d.fileSize) / blocksize
if int(d.fileSize)%blocksize > 0 && d.fragmentBlockIndex != 0xffffffff {
blockListSize++
}
// do we have enough data left to read those?
extra = blockListSize * 4
if len(b[16:]) >= extra {
d.blockSizes = parseFileBlockSizes(b[16:], int(fileSize), blocksize)
extra = 0
}
return d, extra, nil
}
// extendedFile
type extendedFile struct {
startBlock uint64
fileSize uint64
sparse uint64
links uint32
fragmentBlockIndex uint32
fragmentOffset uint32
xAttrIndex uint32
blockSizes []*blockData
}
func (i extendedFile) equal(o inodeBody) bool {
oi, ok := o.(extendedFile)
if !ok {
return false
}
if len(i.blockSizes) != len(oi.blockSizes) {
return false
}
for i, b := range i.blockSizes {
if (b == nil && oi.blockSizes[i] == nil) || (b != nil && oi.blockSizes[i] == nil) {
return false
}
if *b != *oi.blockSizes[i] {
return false
}
}
return i.startBlock == oi.startBlock &&
i.fragmentOffset == oi.fragmentOffset &&
i.fragmentBlockIndex == oi.fragmentBlockIndex &&
i.fileSize == oi.fileSize &&
i.sparse == oi.sparse &&
i.links == oi.links &&
i.xAttrIndex == oi.xAttrIndex
}
func (i extendedFile) toBytes() []byte {
b := make([]byte, 40+4*len(i.blockSizes))
binary.LittleEndian.PutUint64(b[0:8], i.startBlock)
binary.LittleEndian.PutUint64(b[8:16], i.fileSize)
binary.LittleEndian.PutUint64(b[16:24], i.sparse)
binary.LittleEndian.PutUint32(b[24:28], i.links)
binary.LittleEndian.PutUint32(b[28:32], i.fragmentBlockIndex)
binary.LittleEndian.PutUint32(b[32:36], i.fragmentOffset)
binary.LittleEndian.PutUint32(b[36:40], i.xAttrIndex)
for j, e := range i.blockSizes {
binary.LittleEndian.PutUint32(b[40+j*4:40+j*4+4], e.toUint32())
}
return b
}
func (i extendedFile) size() int64 {
return int64(i.fileSize)
}
func (i extendedFile) xattrIndex() (uint32, bool) {
return i.xAttrIndex, i.xAttrIndex != noXattrInodeFlag
}
func parseExtendedFile(b []byte, blocksize int) (*extendedFile, int, error) {
var (
target = 40
extra int
)
if len(b) < target {
return nil, 0, fmt.Errorf("received %d bytes instead of expected minimal %d", len(b), target)
}
fileSize := binary.LittleEndian.Uint64(b[8:16])
d := &extendedFile{
startBlock: binary.LittleEndian.Uint64(b[0:8]),
fileSize: fileSize,
sparse: binary.LittleEndian.Uint64(b[16:24]),
links: binary.LittleEndian.Uint32(b[24:28]),
fragmentBlockIndex: binary.LittleEndian.Uint32(b[28:32]),
fragmentOffset: binary.LittleEndian.Uint32(b[32:36]),
xAttrIndex: binary.LittleEndian.Uint32(b[36:40]),
}
// see how many other bytes we need to read
blockListSize := int(d.fileSize) / blocksize
if int(d.fileSize)%blocksize > 0 && d.fragmentBlockIndex != 0xffffffff {
blockListSize++
}
// do we have enough data left to read those?
extra = blockListSize * 4
if len(b[16:]) >= extra {
d.blockSizes = parseFileBlockSizes(b[16:], int(fileSize), blocksize)
extra = 0
}
return d, extra, nil
}
// basicSymlink
type basicSymlink struct {
links uint32
target string
}
func (i basicSymlink) toBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], i.links)
binary.LittleEndian.PutUint32(b[4:8], uint32(len(i.target)))
b = append(b, []byte(i.target)...)
return b
}
func (i basicSymlink) size() int64 {
return 0
}
func (i basicSymlink) xattrIndex() (uint32, bool) {
return 0, false
}
func (i basicSymlink) equal(o inodeBody) bool {
oi, ok := o.(basicSymlink)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseBasicSymlink(b []byte) (*basicSymlink, int, error) {
var (
target = 8
extra int
)
if len(b) < target {
return nil, 0, fmt.Errorf("received %d bytes instead of expected minimal %d", len(b), target)
}
s := &basicSymlink{
links: binary.LittleEndian.Uint32(b[0:4]),
}
extra = int(binary.LittleEndian.Uint32(b[4:8]))
if len(b[target:]) >= extra {
s.target = string(b[8 : 8+extra])
extra = 0
}
return s, extra, nil
}
// extendedSymlink
type extendedSymlink struct {
links uint32
target string
xAttrIndex uint32
}
func (i extendedSymlink) toBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], i.links)
binary.LittleEndian.PutUint32(b[4:8], uint32(len(i.target)))
b = append(b, []byte(i.target)...)
b2 := make([]byte, 4)
binary.LittleEndian.PutUint32(b2[0:4], i.xAttrIndex)
b = append(b, b2...)
return b
}
func (i extendedSymlink) size() int64 {
return 0
}
func (i extendedSymlink) xattrIndex() (uint32, bool) {
return i.xAttrIndex, i.xAttrIndex != noXattrInodeFlag
}
func (i extendedSymlink) equal(o inodeBody) bool {
oi, ok := o.(extendedSymlink)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseExtendedSymlink(b []byte) (*extendedSymlink, int, error) {
var (
target = 8
extra int
)
if len(b) < target {
return nil, 0, fmt.Errorf("received %d bytes instead of expected minimal %d", len(b), target)
}
s := &extendedSymlink{
links: binary.LittleEndian.Uint32(b[0:4]),
}
// account for the synlink target, plus 4 bytes for the xattr index after it
extra = int(binary.LittleEndian.Uint32(b[4:8])) + 4
if len(b[target:]) > extra {
s.target = string(b[8 : 8+extra])
s.xAttrIndex = binary.LittleEndian.Uint32(b[8+extra : 8+extra+4])
extra = 0
}
return s, extra, nil
}
type basicDevice struct {
links uint32
major uint32
minor uint32
}
func (i basicDevice) toBytes() []byte {
b := make([]byte, 8)
var devNum = (i.major << 8) | (i.minor & 0xff) | ((i.minor & 0xfff00) << 12)
binary.LittleEndian.PutUint32(b[0:4], i.links)
binary.LittleEndian.PutUint32(b[4:8], devNum)
return b
}
func (i basicDevice) size() int64 {
return 0
}
func (i basicDevice) xattrIndex() (uint32, bool) {
return 0, false
}
func (i basicDevice) equal(o inodeBody) bool {
oi, ok := o.(basicDevice)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseBasicDevice(b []byte) (*basicDevice, error) {
target := 8
if len(b) < target {
return nil, fmt.Errorf("received %d bytes instead of expected %d", len(b), target)
}
devNum := binary.LittleEndian.Uint32(b[4:8])
s := &basicDevice{
links: binary.LittleEndian.Uint32(b[0:4]),
major: (devNum & 0xfff00) >> 8,
minor: (devNum & 0xff) | ((devNum >> 12) & 0xfff00),
}
return s, nil
}
// basicBlock
type basicBlock struct {
basicDevice
}
type basicChar struct {
basicDevice
}
type extendedDevice struct {
links uint32
major uint32
minor uint32
xAttrIndex uint32
}
func (i extendedDevice) toBytes() []byte {
// easiest to use the basic one
basic := &basicDevice{
links: i.links,
major: i.major,
minor: i.minor,
}
b := basic.toBytes()
b2 := make([]byte, 4)
binary.LittleEndian.PutUint32(b2[0:4], i.xAttrIndex)
b = append(b, b2...)
return b
}
func (i extendedDevice) size() int64 {
return 0
}
func (i extendedDevice) xattrIndex() (uint32, bool) {
return i.xAttrIndex, i.xAttrIndex != noXattrInodeFlag
}
func (i extendedDevice) equal(o inodeBody) bool {
oi, ok := o.(extendedDevice)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseExtendedDevice(b []byte) (*extendedDevice, error) {
target := 12
if len(b) < target {
return nil, fmt.Errorf("received %d bytes instead of expected minimal %d", len(b), target)
}
basic, err := parseBasicDevice(b[:8])
if err != nil {
return nil, fmt.Errorf("error parsing block device: %v", err)
}
return &extendedDevice{
links: basic.links,
major: basic.major,
minor: basic.minor,
xAttrIndex: binary.LittleEndian.Uint32(b[8:12]),
}, nil
}
// extendedBlock
type extendedBlock struct {
extendedDevice
}
type extendedChar struct {
extendedDevice
}
type basicIPC struct {
links uint32
}
func (i basicIPC) toBytes() []byte {
b := make([]byte, 4)
binary.LittleEndian.PutUint32(b[0:4], i.links)
return b
}
func (i basicIPC) size() int64 {
return 0
}
func (i basicIPC) xattrIndex() (uint32, bool) {
return 0, false
}
func (i basicIPC) equal(o inodeBody) bool {
oi, ok := o.(basicIPC)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseBasicIPC(b []byte) (*basicIPC, error) {
target := 4
if len(b) < target {
return nil, fmt.Errorf("received %d bytes instead of expected %d", len(b), target)
}
s := &basicIPC{
links: binary.LittleEndian.Uint32(b[0:4]),
}
return s, nil
}
type basicFifo struct {
basicIPC
}
type basicSocket struct {
basicIPC
}
type extendedIPC struct {
links uint32
xAttrIndex uint32
}
func (i extendedIPC) toBytes() []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint32(b[0:4], i.links)
binary.LittleEndian.PutUint32(b[4:8], i.xAttrIndex)
return b
}
func (i extendedIPC) size() int64 {
return 0
}
func (i extendedIPC) xattrIndex() (uint32, bool) {
return i.xAttrIndex, i.xAttrIndex != noXattrInodeFlag
}
func (i extendedIPC) equal(o inodeBody) bool {
oi, ok := o.(extendedIPC)
if !ok {
return false
}
if i != oi {
return false
}
return true
}
func parseExtendedIPC(b []byte) (*extendedIPC, error) {
target := 8
if len(b) < target {
return nil, fmt.Errorf("received %d bytes instead of expected %d", len(b), target)
}
s := &extendedIPC{
links: binary.LittleEndian.Uint32(b[0:4]),
xAttrIndex: binary.LittleEndian.Uint32(b[4:8]),
}
return s, nil
}
type extendedFifo struct {
extendedIPC
}
type extendedSocket struct {
extendedIPC
}
// idTable is an indexed table of IDs
//
//nolint:deadcode // we need these references in the future
type idTable []uint32
// parseInodeBody parse the body of an inode. This only parses the non-variable size part,
// e.g. not the list of directory indexes in an extended directory inode, or
// the list of blocksizes at the end of a basic file inode or extended file inode. For those,
// parseInodeBody will return how many more bytes it needs to read. It is up to the caller
// to provide those bytes in another call.
func parseInodeBody(b []byte, blocksize int, iType inodeType) (inodeBody, int, error) {
// now try to read the rest
var (
body inodeBody
err error
extra int
)
switch iType {
case inodeBasicDirectory:
body, err = parseBasicDirectory(b)
case inodeExtendedDirectory:
body, extra, err = parseExtendedDirectory(b)
case inodeBasicFile:
body, extra, err = parseBasicFile(b, blocksize)
case inodeExtendedFile:
body, extra, err = parseExtendedFile(b, blocksize)
case inodeBasicChar, inodeBasicBlock:
body, err = parseBasicDevice(b)
case inodeExtendedChar, inodeExtendedBlock:
body, err = parseExtendedDevice(b)
case inodeBasicSymlink:
body, extra, err = parseBasicSymlink(b)
case inodeExtendedSymlink:
body, extra, err = parseExtendedSymlink(b)
case inodeBasicFifo, inodeBasicSocket:
body, err = parseBasicIPC(b)
case inodeExtendedFifo, inodeExtendedSocket:
body, err = parseExtendedIPC(b)
default:
err = fmt.Errorf("unknown inode type: %v", iType)
}
return body, extra, err
}
07070100000337000081A4000000000000000000000001645E367C00000F50000000000000000000000000000000000000005C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/metadatablock.go package squashfs
import (
"encoding/binary"
"fmt"
"io"
)
type metadatablock struct {
compressed bool
data []byte
}
const (
minMetadataBlockSize = 3
standardMetadataBlocksize = 8192
)
func getMetadataSize(b []byte) (size uint16, compressed bool, err error) {
if len(b) < 2 {
return 0, false, fmt.Errorf("cannot read size of metadata block with %d bytes, must have minimum %d", len(b), 2)
}
header := binary.LittleEndian.Uint16(b[:2])
size = header & 0x7fff
compressed = header&0x8000 != 0x8000
return size, compressed, nil
}
func parseMetadata(b []byte, c Compressor) (block *metadatablock, err error) {
if len(b) < minMetadataBlockSize {
return nil, fmt.Errorf("metadata block was of len %d, less than minimum %d", len(b), minMetadataBlockSize)
}
size, compressed, err := getMetadataSize(b[:2])
if err != nil {
return nil, fmt.Errorf("error reading metadata header: %v", err)
}
if len(b) < int(2+size) {
return nil, fmt.Errorf("metadata header said size should be %d but was only %d", size, len(b)-2)
}
data := b[2 : 2+size]
if compressed {
data, err = c.decompress(data)
if err != nil {
return nil, fmt.Errorf("decompress error: %v", err)
}
}
return &metadatablock{
compressed: compressed,
data: data,
}, nil
}
func (m *metadatablock) toBytes(c Compressor) ([]byte, error) {
b := make([]byte, 2)
var (
header uint16
data = m.data
err error
)
if !m.compressed {
header |= 0x8000
} else {
data, err = c.compress(m.data)
if err != nil {
return nil, fmt.Errorf("compression error: %v", err)
}
}
header |= uint16(len(data))
binary.LittleEndian.PutUint16(b[:2], header)
b = append(b, data...)
return b, nil
}
func readMetaBlock(r io.ReaderAt, c Compressor, location int64) (data []byte, size uint16, err error) {
// read bytes off the reader to determine how big it is and if compressed
b := make([]byte, 2)
_, _ = r.ReadAt(b, location)
size, compressed, err := getMetadataSize(b)
if err != nil {
return nil, 0, fmt.Errorf("error getting size and compression for metadata block at %d: %v", location, err)
}
b = make([]byte, size)
read, err := r.ReadAt(b, location+2)
if err != nil && err != io.EOF {
return nil, 0, fmt.Errorf("unable to read metadata block of size %d at location %d: %v", size, location, err)
}
if read != len(b) {
return nil, 0, fmt.Errorf("read %d instead of expected %d bytes for metadata block at location %d", read, size, location)
}
data = b
if compressed {
if c == nil {
return nil, 0, fmt.Errorf("metadata block at %d compressed, but no compressor provided", location)
}
data, err = c.decompress(b)
if err != nil {
return nil, 0, fmt.Errorf("decompress error: %v", err)
}
}
return data, size + 2, nil
}
// readMetadata read as many bytes of metadata as required for the given size, with the byteOffset provided as a starting
// point into the first block. Can read multiple blocks if necessary, e.g. if a block is 8192 bytes (standard), and
// requests to read 500 bytes beginning at offset 8000 into the first block.
// it always returns to the end of the block, even if that is greater than the given size. This makes it easy to use more
// data than expected on first read. The consumer is expected to cut it down, if needed
func readMetadata(r io.ReaderAt, c Compressor, firstBlock int64, initialBlockOffset uint32, byteOffset uint16, size int) ([]byte, error) {
var (
b []byte
blockOffset = int(initialBlockOffset)
)
// we know how many blocks, so read them all in
m, read, err := readMetaBlock(r, c, firstBlock+int64(blockOffset))
if err != nil {
return nil, err
}
b = append(b, m[byteOffset:]...)
// do we have any more to read?
for len(b) < size {
blockOffset += int(read)
m, read, err = readMetaBlock(r, c, firstBlock+int64(blockOffset))
if err != nil {
return nil, err
}
b = append(b, m...)
}
return b, nil
}
07070100000338000081A4000000000000000000000001645E367C000065BC000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/squashfs.go package squashfs
import (
"encoding/binary"
"fmt"
"io"
"math"
"os"
"path"
"github.com/diskfs/go-diskfs/filesystem"
"github.com/diskfs/go-diskfs/util"
)
const (
defaultBlockSize = 128 * KB
metadataBlockSize = 8 * KB
minBlocksize = 4 * KB
maxBlocksize = 1 * MB
)
// FileSystem implements the FileSystem interface
type FileSystem struct {
workspace string
superblock *superblock
size int64
start int64
file util.File
blocksize int64
compressor Compressor
fragments []*fragmentEntry
uidsGids []uint32
xattrs *xAttrTable
rootDir inode
}
// Equal compare if two filesystems are equal
func (fs *FileSystem) Equal(a *FileSystem) bool {
localMatch := fs.file == a.file && fs.size == a.size
superblockMatch := fs.superblock.equal(a.superblock)
return localMatch && superblockMatch
}
// Label return the filesystem label
func (fs *FileSystem) Label() string {
return ""
}
func (fs *FileSystem) SetLabel(string) error {
return fmt.Errorf("SquashFS filesystem is read-only")
}
// Workspace get the workspace path
func (fs *FileSystem) Workspace() string {
return fs.workspace
}
// Create creates a squashfs filesystem in a given directory
//
// requires the util.File where to create the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File to create the filesystem,
// and blocksize is is the logical blocksize to use for creating the filesystem
//
// note that you are *not* required to create the filesystem on the entire disk. You could have a disk of size
// 20GB, and create a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for creating filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 128 KB.
func Create(f util.File, size, start, blocksize int64) (*FileSystem, error) {
if blocksize == 0 {
blocksize = defaultBlockSize
}
// make sure it is an allowed blocksize
if err := validateBlocksize(blocksize); err != nil {
return nil, err
}
// create a temporary working area where we can create the filesystem.
// It is only on `Finalize()` that we write it out to the actual disk file
tmpdir, err := os.MkdirTemp("", "diskfs_squashfs")
if err != nil {
return nil, fmt.Errorf("could not create working directory: %v", err)
}
// create root directory
// there is nothing in there
return &FileSystem{
workspace: tmpdir,
start: start,
size: size,
file: f,
blocksize: blocksize,
}, nil
}
// Read reads a filesystem from a given disk.
//
// requires the util.File where to read the filesystem, size is the size of the filesystem in bytes,
// start is how far in bytes from the beginning of the util.File the filesystem is expected to begin,
// and blocksize is is the logical blocksize to use for creating the filesystem
//
// note that you are *not* required to read a filesystem on the entire disk. You could have a disk of size
// 20GB, and a small filesystem of size 50MB that begins 2GB into the disk.
// This is extremely useful for working with filesystems on disk partitions.
//
// Note, however, that it is much easier to do this using the higher-level APIs at github.com/diskfs/go-diskfs
// which allow you to work directly with partitions, rather than having to calculate (and hopefully not make any errors)
// where a partition starts and ends.
//
// If the provided blocksize is 0, it will use the default of 2K bytes
func Read(file util.File, size, start, blocksize int64) (*FileSystem, error) {
var (
read int
err error
)
if blocksize == 0 {
blocksize = defaultBlockSize
}
// make sure it is an allowed blocksize
if err := validateBlocksize(blocksize); err != nil {
return nil, err
}
// load the information from the disk
// read the superblock
b := make([]byte, superblockSize)
read, err = file.ReadAt(b, start)
if err != nil {
return nil, fmt.Errorf("unable to read bytes for superblock: %v", err)
}
if int64(read) != superblockSize {
return nil, fmt.Errorf("read %d bytes instead of expected %d for superblock", read, superblockSize)
}
// parse superblock
s, err := parseSuperblock(b)
if err != nil {
return nil, fmt.Errorf("error parsing superblock: %v", err)
}
// create the compressor function we will use
compress, err := newCompressor(s.compression)
if err != nil {
return nil, fmt.Errorf("unable to create compressor")
}
// load fragments
fragments, err := readFragmentTable(s, file, compress)
if err != nil {
return nil, fmt.Errorf("error reading fragments: %v", err)
}
// read xattrs
var (
xattrs *xAttrTable
)
if !s.noXattrs {
// xattr is right to the end of the disk
xattrs, err = readXattrsTable(s, file, compress)
if err != nil {
return nil, fmt.Errorf("error reading xattr table: %v", err)
}
}
// read uidsgids
uidsgids, err := readUidsGids(s, file, compress)
if err != nil {
return nil, fmt.Errorf("error reading uids/gids: %v", err)
}
fs := &FileSystem{
workspace: "", // no workspace when we do nothing with it
start: start,
size: size,
file: file,
superblock: s,
blocksize: blocksize,
xattrs: xattrs,
compressor: compress,
fragments: fragments,
uidsGids: uidsgids,
}
// for efficiency, read in the root inode right now
rootInode, err := fs.getInode(s.rootInode.block, s.rootInode.offset, inodeBasicDirectory)
if err != nil {
return nil, fmt.Errorf("unable to read root inode")
}
fs.rootDir = rootInode
return fs, nil
}
// Type returns the type code for the filesystem. Always returns filesystem.TypeFat32
func (fs *FileSystem) Type() filesystem.Type {
return filesystem.TypeSquashfs
}
// Mkdir make a directory at the given path. It is equivalent to `mkdir -p`, i.e. idempotent, in that:
//
// * It will make the entire tree path if it does not exist
// * It will not return an error if the path already exists
//
// if readonly and not in workspace, will return an error
func (fs *FileSystem) Mkdir(p string) error {
if fs.workspace == "" {
return fmt.Errorf("cannot write to read-only filesystem")
}
err := os.MkdirAll(path.Join(fs.workspace, p), 0o755)
if err != nil {
return fmt.Errorf("could not create directory %s: %v", p, err)
}
// we are not interesting in returning the entries
return err
}
// ReadDir return the contents of a given directory in a given filesystem.
//
// Returns a slice of os.FileInfo with all of the entries in the directory.
//
// Will return an error if the directory does not exist or is a regular file and not a directory
func (fs *FileSystem) ReadDir(p string) ([]os.FileInfo, error) {
var fi []os.FileInfo
// non-workspace: read from squashfs
// workspace: read from regular filesystem
if fs.workspace != "" {
fullPath := path.Join(fs.workspace, p)
// read the entries
dirEntries, err := os.ReadDir(fullPath)
if err != nil {
return nil, fmt.Errorf("could not read directory %s: %v", p, err)
}
for _, e := range dirEntries {
info, err := e.Info()
if err != nil {
return nil, fmt.Errorf("could not read directory %s: %v", p, err)
}
fi = append(fi, info)
}
} else {
dirEntries, err := fs.readDirectory(p)
if err != nil {
return nil, fmt.Errorf("error reading directory %s: %v", p, err)
}
fi = make([]os.FileInfo, 0, len(dirEntries))
for _, entry := range dirEntries {
fi = append(fi, entry)
}
}
return fi, nil
}
// OpenFile returns an io.ReadWriter from which you can read the contents of a file
// or write contents to the file
//
// accepts normal os.OpenFile flags
//
// returns an error if the file does not exist
func (fs *FileSystem) OpenFile(p string, flag int) (filesystem.File, error) {
var f filesystem.File
var err error
// get the path and filename
dir := path.Dir(p)
filename := path.Base(p)
// if the dir == filename, then it is just /
if dir == filename {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
// cannot open to write or append or create if we do not have a workspace
writeMode := flag&os.O_WRONLY != 0 || flag&os.O_RDWR != 0 || flag&os.O_APPEND != 0 || flag&os.O_CREATE != 0 || flag&os.O_TRUNC != 0 || flag&os.O_EXCL != 0
if fs.workspace == "" {
if writeMode {
return nil, fmt.Errorf("cannot write to read-only filesystem")
}
// get the directory entries
var entries []*directoryEntry
entries, err = fs.readDirectory(dir)
if err != nil {
return nil, fmt.Errorf("could not read directory entries for %s", dir)
}
// we now know that the directory exists, see if the file exists
var targetEntry *directoryEntry
for _, e := range entries {
eName := e.Name()
// cannot do anything with directories
if eName == filename && e.IsDir() {
return nil, fmt.Errorf("cannot open directory %s as file", p)
}
if eName == filename {
// if we got this far, we have found the file
targetEntry = e
break
}
}
// see if the file exists
// if the file does not exist, and is not opened for os.O_CREATE, return an error
if targetEntry == nil {
return nil, fmt.Errorf("target file %s does not exist", p)
}
// get the inode data for this file
// now open the file
// get the inode for the file
var eFile *extendedFile
in := targetEntry.inode
iType := in.inodeType()
body := in.getBody()
//nolint:exhaustive // all other cases fall under default
switch iType {
case inodeBasicFile:
extFile := body.(*basicFile).toExtended()
eFile = &extFile
case inodeExtendedFile:
eFile, _ = body.(*extendedFile)
default:
return nil, fmt.Errorf("inode is of type %d, neither basic nor extended directory", iType)
}
f = &File{
extendedFile: eFile,
isReadWrite: false,
isAppend: false,
offset: 0,
filesystem: fs,
}
} else {
f, err = os.OpenFile(path.Join(fs.workspace, p), flag, 0o644)
if err != nil {
return nil, fmt.Errorf("target file %s does not exist: %v", p, err)
}
}
return f, nil
}
// readDirectory - read directory entry on squashfs only (not workspace)
func (fs *FileSystem) readDirectory(p string) ([]*directoryEntry, error) {
// use the root inode to find the location of the root direectory in the table
entries, err := fs.getDirectoryEntries(p, fs.rootDir)
if err != nil {
return nil, fmt.Errorf("could not read directory at path %s: %v", p, err)
}
return entries, nil
}
func (fs *FileSystem) getDirectoryEntries(p string, in inode) ([]*directoryEntry, error) {
var (
block uint32
offset uint16
size int
)
// break path down into parts and levels
parts := splitPath(p)
iType := in.inodeType()
body := in.getBody()
//nolint:exhaustive // we only are looking for directory types here
switch iType {
case inodeBasicDirectory:
dir, _ := body.(*basicDirectory)
block = dir.startBlock
offset = dir.offset
size = int(dir.fileSize)
case inodeExtendedDirectory:
dir, _ := body.(*extendedDirectory)
block = dir.startBlock
offset = dir.offset
size = int(dir.fileSize)
default:
return nil, fmt.Errorf("inode is of type %d, neither basic nor extended directory", iType)
}
// read the directory data from the directory table
dir, err := fs.getDirectory(block, offset, size)
if err != nil {
return nil, fmt.Errorf("unable to read directory from table: %v", err)
}
entriesRaw := dir.entries
var entries []*directoryEntry
// if this is the directory we are looking for, return the entries
if len(parts) == 0 {
entries, err = fs.hydrateDirectoryEntries(entriesRaw)
if err != nil {
return nil, fmt.Errorf("could not populate directory entries for %s with properties: %v", p, err)
}
return entries, nil
}
// it is not, so dig down one level
// find the entry among the children that has the desired name
for _, entry := range entriesRaw {
// only care if not self or parent entry
checkFilename := entry.name
if checkFilename == parts[0] {
// read the inode for this entry
inode, err := fs.getInode(entry.startBlock, entry.offset, entry.inodeType)
if err != nil {
return nil, fmt.Errorf("error finding inode for %s: %v", p, err)
}
childPath := ""
if len(parts) > 1 {
childPath = path.Join(parts[1:]...)
}
entries, err = fs.getDirectoryEntries(childPath, inode)
if err != nil {
return nil, fmt.Errorf("could not get entries: %v", err)
}
return entries, nil
}
}
// if we made it here, we were not looking for this directory, but did not find it among our children
return nil, fmt.Errorf("could not find path %s", p)
}
func (fs *FileSystem) hydrateDirectoryEntries(entries []*directoryEntryRaw) ([]*directoryEntry, error) {
fullEntries := make([]*directoryEntry, 0)
for _, e := range entries {
// read the inode for this entry
in, err := fs.getInode(e.startBlock, e.offset, e.inodeType)
if err != nil {
return nil, fmt.Errorf("error finding inode for %s: %v", e.name, err)
}
body, header := in.getBody(), in.getHeader()
xattrIndex, has := body.xattrIndex()
xattrs := map[string]string{}
if has && xattrIndex != noXattrInodeFlag {
xattrs, err = fs.xattrs.find(int(xattrIndex))
if err != nil {
return nil, fmt.Errorf("error reading xattrs for %s: %v", e.name, err)
}
}
fullEntries = append(fullEntries, &directoryEntry{
isSubdirectory: e.isSubdirectory,
name: e.name,
size: body.size(),
modTime: header.modTime,
mode: header.mode,
inode: in,
sys: FileStat{
uid: fs.uidsGids[header.uidIdx],
gid: fs.uidsGids[header.gidIdx],
xattrs: xattrs,
},
})
}
return fullEntries, nil
}
// getInode read a single inode, given the block offset, and the offset in the
// block when uncompressed. This may require two reads, one to get the header and discover the type,
// and then another to read the rest. Some inodes even have a variable length, which complicates it
// further.
func (fs *FileSystem) getInode(blockOffset uint32, byteOffset uint16, iType inodeType) (inode, error) {
// get the block
// start by getting the minimum for the proposed type. It very well might be wrong.
size := inodeTypeToSize(iType)
uncompressed, err := readMetadata(fs.file, fs.compressor, int64(fs.superblock.inodeTableStart), blockOffset, byteOffset, size)
if err != nil {
return nil, fmt.Errorf("error reading block at position %d: %v", blockOffset, err)
}
// parse the header to see the type matches
header, err := parseInodeHeader(uncompressed)
if err != nil {
return nil, fmt.Errorf("error parsing inode header: %v", err)
}
if header.inodeType != iType {
iType = header.inodeType
}
// now read the body, which may have a variable size
body, extra, err := parseInodeBody(uncompressed[inodeHeaderSize:], int(fs.blocksize), iType)
if err != nil {
return nil, fmt.Errorf("error parsing inode body: %v", err)
}
// if it returns extra > 0, then it needs that many more bytes to be read, and to be reparsed
if extra > 0 {
size += extra
uncompressed, err = readMetadata(fs.file, fs.compressor, int64(fs.superblock.inodeTableStart), blockOffset, byteOffset, size)
if err != nil {
return nil, fmt.Errorf("error reading block at position %d: %v", blockOffset, err)
}
// no need to revalidate the body type, or check for extra
body, _, err = parseInodeBody(uncompressed[inodeHeaderSize:], int(fs.blocksize), iType)
if err != nil {
return nil, fmt.Errorf("error parsing inode body: %v", err)
}
}
return &inodeImpl{
header: header,
body: body,
}, nil
}
// getDirectory read a single directory, given the block offset, and the offset in the
// block when uncompressed.
func (fs *FileSystem) getDirectory(blockOffset uint32, byteOffset uint16, size int) (*directory, error) {
// get the block
uncompressed, err := readMetadata(fs.file, fs.compressor, int64(fs.superblock.directoryTableStart), blockOffset, byteOffset, size)
if err != nil {
return nil, fmt.Errorf("error reading block at position %d: %v", blockOffset, err)
}
// for parseDirectory, we only want to use precisely the right number of bytes
if len(uncompressed) > size {
uncompressed = uncompressed[:size]
}
// get the inode from the offset into the uncompressed block
return parseDirectory(uncompressed)
}
func (fs *FileSystem) readBlock(location int64, compressed bool, size uint32) ([]byte, error) {
b := make([]byte, size)
read, err := fs.file.ReadAt(b, location)
if err != nil && err != io.EOF {
return nil, fmt.Errorf("error reading block %d: %v", location, err)
}
if read != int(size) {
return nil, fmt.Errorf("read %d bytes instead of expected %d", read, size)
}
if compressed {
b, err = fs.compressor.decompress(b)
if err != nil {
return nil, fmt.Errorf("decompress error: %v", err)
}
}
return b, nil
}
func (fs *FileSystem) readFragment(index, offset uint32, fragmentSize int64) ([]byte, error) {
// get info from the fragment table
// figure out which block of the fragment table we need
// first find where the compressed fragment table entry for the given index is
if len(fs.fragments)-1 < int(index) {
return nil, fmt.Errorf("cannot find fragment block with index %d", index)
}
fragmentInfo := fs.fragments[index]
// figure out the size of the compressed block and if it is compressed
b := make([]byte, fragmentInfo.size)
read, err := fs.file.ReadAt(b, int64(fragmentInfo.start))
if err != nil && err != io.EOF {
return nil, fmt.Errorf("unable to read fragment block %d: %v", index, err)
}
if read != len(b) {
return nil, fmt.Errorf("read %d instead of expected %d bytes for fragment block %d", read, len(b), index)
}
data := b
if fragmentInfo.compressed {
if fs.compressor == nil {
return nil, fmt.Errorf("fragment compressed but do not have valid compressor")
}
data, err = fs.compressor.decompress(b)
if err != nil {
return nil, fmt.Errorf("decompress error: %v", err)
}
}
// now get the data from the offset
return data[offset : int64(offset)+fragmentSize], nil
}
func validateBlocksize(blocksize int64) error {
blocksizeFloat := float64(blocksize)
l2 := math.Log2(blocksizeFloat)
switch {
case blocksize < minBlocksize:
return fmt.Errorf("blocksize %d too small, must be at least %d", blocksize, minBlocksize)
case blocksize > maxBlocksize:
return fmt.Errorf("blocksize %d too large, must be no more than %d", blocksize, maxBlocksize)
case math.Trunc(l2) != l2:
return fmt.Errorf("blocksize %d is not a power of 2", blocksize)
}
return nil
}
func readFragmentTable(s *superblock, file util.File, c Compressor) ([]*fragmentEntry, error) {
// get the first level index, which is just the pointers to the fragment table metadata blocks
blockCount := s.fragmentCount / 512
if s.fragmentCount%512 > 0 {
blockCount++
}
// now read the index - we have as many offsets, each of uint64, as we have blockCount
b := make([]byte, 8*blockCount)
read, err := file.ReadAt(b, int64(s.fragmentTableStart))
if err != nil {
return nil, fmt.Errorf("error reading fragment table index: %v", err)
}
if read != len(b) {
return nil, fmt.Errorf("read %d bytes instead of expected %d bytes of fragment table index", read, len(b))
}
var offsets []int64
for i := 0; i < len(b); i += 8 {
offsets = append(offsets, int64(binary.LittleEndian.Uint64(b[i:i+8])))
}
// offsets now contains all of the fragment block offsets
// load in the actual fragment entries
// read each block and uncompress it
var fragmentTable []*fragmentEntry
for i, offset := range offsets {
uncompressed, _, err := readMetaBlock(file, c, offset)
if err != nil {
return nil, fmt.Errorf("error reading meta block %d at position %d: %v", i, offset, err)
}
// uncompressed should be a multiple of 16 bytes
for j := 0; j < len(uncompressed); j += 16 {
entry, err := parseFragmentEntry(uncompressed[j:])
if err != nil {
return nil, fmt.Errorf("error parsing fragment table entry in block %d position %d: %v", i, j, err)
}
fragmentTable = append(fragmentTable, entry)
}
}
return fragmentTable, nil
}
/*
How the xattr table is laid out
It has three components in the following order
1- xattr metadata
2- xattr id table
3- xattr index
To read the xattr table:
1- Get the start of the index from the superblock
2- read the index header, which contains: metadata start; id count
3- Calculate how many bytes of index data there are: (id count)*(index size)
4- Calculate how many meta blocks of index data there are, as each block is 8K uncompressed
5- Read the indexes immediately following the header. They are uncompressed, 8 bytes each (uint64); one index per id metablock
6- Read the id metablocks based on the indexes and uncompress if needed
7- Read all of the xattr metadata. It starts at the location indicated by the header, and ends at the id table
*/
func readXattrsTable(s *superblock, file util.File, c Compressor) (*xAttrTable, error) {
// first read the header
b := make([]byte, xAttrHeaderSize)
read, err := file.ReadAt(b, int64(s.xattrTableStart))
if err != nil && err != io.EOF {
return nil, fmt.Errorf("unable to read bytes for xattrs metadata ID header: %v", err)
}
if read != len(b) {
return nil, fmt.Errorf("read %d bytes instead of expected %d for xattrs metadata ID header", read, len(b))
}
// find out how many xattr IDs we have and where the metadata starts. The table always starts
// with this information
xAttrStart := binary.LittleEndian.Uint64(b[0:8])
xAttrCount := binary.LittleEndian.Uint32(b[8:12])
// the last 4 bytes are an unused uint32
// if we have none?
if xAttrCount == 0 {
return nil, nil
}
// how many bytes total do we need?
idBytes := xAttrCount * xAttrIDEntrySize
// how many metadata blocks?
idBlocks := ((idBytes - 1) / uint32(metadataBlockSize)) + 1
b = make([]byte, idBlocks*8)
read, err = file.ReadAt(b, int64(s.xattrTableStart)+int64(xAttrHeaderSize))
if err != nil && err != io.EOF {
return nil, fmt.Errorf("unable to read bytes for xattrs metadata ID table: %v", err)
}
if read != len(b) {
return nil, fmt.Errorf("read %d bytes instead of expected %d for xattrs metadata ID table", read, len(b))
}
var (
uncompressed []byte
size uint16
)
bIndex := make([]byte, 0)
// convert those into indexes
for i := 0; i+8-1 < len(b); i += 8 {
locn := binary.LittleEndian.Uint64(b[i : i+8])
uncompressed, _, err = readMetaBlock(file, c, int64(locn))
if err != nil {
return nil, fmt.Errorf("error reading xattr index meta block %d at position %d: %v", i, locn, err)
}
bIndex = append(bIndex, uncompressed...)
}
// now load the actual xAttrs data
xAttrEnd := binary.LittleEndian.Uint64(b[:8])
xAttrData := make([]byte, 0)
for i := xAttrStart; i < xAttrEnd; {
uncompressed, size, err = readMetaBlock(file, c, int64(i))
if err != nil {
return nil, fmt.Errorf("error reading xattr data meta block at position %d: %v", i, err)
}
xAttrData = append(xAttrData, uncompressed...)
i += uint64(size)
}
// now have all of the indexes and metadata loaded
// need to pass it the offset of the beginning of the id table from the beginning of the disk
return parseXattrsTable(xAttrData, bIndex, s.idTableStart, c)
}
//nolint:unparam // this does not use offset or compressor yet, but only because we have not yet added support
func parseXattrsTable(bUIDXattr, bIndex []byte, offset uint64, c Compressor) (*xAttrTable, error) {
// create the ID list
var (
xAttrIDList []*xAttrIndex
)
entrySize := int(xAttrIDEntrySize)
for i := 0; i+entrySize <= len(bIndex); i += entrySize {
entry, err := parseXAttrIndex(bIndex[i:])
if err != nil {
return nil, fmt.Errorf("error parsing xAttr ID table entry in position %d: %v", i, err)
}
xAttrIDList = append(xAttrIDList, entry)
}
return &xAttrTable{
list: xAttrIDList,
data: bUIDXattr,
}, nil
}
/*
How the uids/gids table is laid out
It has two components in the following order
1- list of uids/gids in order, each uint32. These are in metadata blocks of uncompressed 8K size
2- list of indexes to metadata blocks
To read the uids/gids table:
1- Get the start of the index from the superblock
2- Calculate how many bytes of ids there are: (id count)*(id size), where (id size) = 4 bytes (uint32)
3- Calculate how many meta blocks of id data there are, as each block is 8K uncompressed
4- Read the indexes. They are uncompressed, 8 bytes each (uint64); one index per id metablock
5- Read the id metablocks based on the indexes and uncompress if needed
*/
func readUidsGids(s *superblock, file util.File, c Compressor) ([]uint32, error) {
// find out how many xattr IDs we have and where the metadata starts. The table always starts
// with this information
idStart := s.idTableStart
idCount := s.idCount
// if we have none?
if idCount == 0 {
return nil, nil
}
// how many bytes total do we need?
idBytes := idCount * idEntrySize
// how many metadata blocks?
idBlocks := ((idBytes - 1) / uint16(metadataBlockSize)) + 1
b := make([]byte, idBlocks*8)
read, err := file.ReadAt(b, int64(idStart))
if err != nil && err != io.EOF {
return nil, fmt.Errorf("unable to read index bytes for uidgid ID table: %v", err)
}
if read != len(b) {
return nil, fmt.Errorf("read %d bytes instead of expected %d for uidgid ID table", read, len(b))
}
var (
uncompressed []byte
)
data := make([]byte, 0)
// convert those into indexes
for i := 0; i+8-1 < len(b); i += 8 {
locn := binary.LittleEndian.Uint64(b[i : i+8])
uncompressed, _, err = readMetaBlock(file, c, int64(locn))
if err != nil {
return nil, fmt.Errorf("error reading uidgid index meta block %d at position %d: %v", i, locn, err)
}
data = append(data, uncompressed...)
}
// now have all of the data loaded
return parseIDTable(data), nil
}
07070100000339000081A4000000000000000000000001645E367C00001AF8000000000000000000000000000000000000005900000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/superblock.go package squashfs
import (
"encoding/binary"
"fmt"
"math"
"time"
)
const (
superblockMagic uint32 = 0x73717368
superblockMajorVersion uint16 = 4
superblockMinorVersion uint16 = 0
)
type compression uint16
const (
compressionNone compression = 0
compressionGzip compression = 1
compressionLzma compression = 2
compressionLzo compression = 3
compressionXz compression = 4
compressionLz4 compression = 5
compressionZstd compression = 6
)
const (
superblockSize = 96
)
type inodeRef struct {
block uint32
offset uint16
}
func (i *inodeRef) toUint64() uint64 {
var u uint64
u |= (uint64(i.block) << 16)
u |= uint64(i.offset)
return u
}
func parseRootInode(u uint64) *inodeRef {
i := &inodeRef{
block: uint32((u >> 16) & 0xffffffff),
offset: uint16(u & 0xffff),
}
return i
}
type superblockFlags struct {
uncompressedInodes bool
uncompressedData bool
uncompressedFragments bool
noFragments bool
alwaysFragments bool
dedup bool
exportable bool
uncompressedXattrs bool
noXattrs bool
compressorOptions bool
uncompressedIDs bool
}
type superblock struct {
inodes uint32
modTime time.Time
blocksize uint32
fragmentCount uint32
compression compression
idCount uint16
versionMajor uint16
versionMinor uint16
rootInode *inodeRef
size uint64
idTableStart uint64
xattrTableStart uint64
inodeTableStart uint64
directoryTableStart uint64
fragmentTableStart uint64
exportTableStart uint64
superblockFlags
}
func (s *superblock) equal(a *superblock) bool {
// to compare, need to extract the rootInode
inodeEql := *a.rootInode == *s.rootInode
s1 := &superblock{}
a1 := &superblock{}
*s1 = *s
*a1 = *a
s1.rootInode = nil
a1.rootInode = nil
modTime := time.Now()
s1.modTime = modTime
a1.modTime = modTime
sblockEql := *s1 == *a1
return inodeEql && sblockEql
}
func (s *superblockFlags) bytes() []byte {
var flags uint16
if s.uncompressedInodes {
flags |= 0x0001
}
if s.uncompressedData {
flags |= 0x0002
}
if s.uncompressedFragments {
flags |= 0x0008
}
if s.noFragments {
flags |= 0x0010
}
if s.alwaysFragments {
flags |= 0x0020
}
if s.dedup {
flags |= 0x0040
}
if s.exportable {
flags |= 0x0080
}
if s.uncompressedXattrs {
flags |= 0x0100
}
if s.noXattrs {
flags |= 0x0200
}
if s.compressorOptions {
flags |= 0x0400
}
if s.uncompressedIDs {
flags |= 0x0800
}
b := make([]byte, 2)
binary.LittleEndian.PutUint16(b, flags)
return b
}
func parseFlags(b []byte) (*superblockFlags, error) {
targetLength := 2
if len(b) != targetLength {
return nil, fmt.Errorf("received %d bytes instead of expected %d", len(b), targetLength)
}
flags := binary.LittleEndian.Uint16(b)
s := &superblockFlags{
uncompressedInodes: flags&0x0001 == 0x0001,
uncompressedData: flags&0x0002 == 0x0002,
uncompressedFragments: flags&0x0008 == 0x0008,
noFragments: flags&0x0010 == 0x0010,
alwaysFragments: flags&0x0020 == 0x0020,
dedup: flags&0x0040 == 0x0040,
exportable: flags&0x0080 == 0x0080,
uncompressedXattrs: flags&0x0100 == 0x0100,
noXattrs: flags&0x0200 == 0x0200,
compressorOptions: flags&0x0400 == 0x0400,
uncompressedIDs: flags&0x0800 == 0x0800,
}
return s, nil
}
func (s *superblock) toBytes() []byte {
b := make([]byte, superblockSize)
binary.LittleEndian.PutUint32(b[0:4], superblockMagic)
binary.LittleEndian.PutUint32(b[4:8], s.inodes)
binary.LittleEndian.PutUint32(b[8:12], uint32(s.modTime.Unix()))
binary.LittleEndian.PutUint32(b[12:16], s.blocksize)
binary.LittleEndian.PutUint32(b[16:20], s.fragmentCount)
binary.LittleEndian.PutUint16(b[20:22], uint16(s.compression))
binary.LittleEndian.PutUint16(b[22:24], uint16(math.Log2(float64(s.blocksize))))
copy(b[24:26], s.superblockFlags.bytes())
binary.LittleEndian.PutUint16(b[26:28], s.idCount)
binary.LittleEndian.PutUint16(b[28:30], superblockMajorVersion)
binary.LittleEndian.PutUint16(b[30:32], superblockMinorVersion)
binary.LittleEndian.PutUint64(b[32:40], s.rootInode.toUint64())
binary.LittleEndian.PutUint64(b[40:48], s.size)
binary.LittleEndian.PutUint64(b[48:56], s.idTableStart)
binary.LittleEndian.PutUint64(b[56:64], s.xattrTableStart)
binary.LittleEndian.PutUint64(b[64:72], s.inodeTableStart)
binary.LittleEndian.PutUint64(b[72:80], s.directoryTableStart)
binary.LittleEndian.PutUint64(b[80:88], s.fragmentTableStart)
binary.LittleEndian.PutUint64(b[88:96], s.exportTableStart)
return b
}
func parseSuperblock(b []byte) (*superblock, error) {
if len(b) != superblockSize {
return nil, fmt.Errorf("superblock had %d bytes instead of expected %d", len(b), superblockSize)
}
magic := binary.LittleEndian.Uint32(b[0:4])
if magic != superblockMagic {
return nil, fmt.Errorf("superblock had magic of %d instead of expected %d", magic, superblockMagic)
}
majorVersion := binary.LittleEndian.Uint16(b[28:30])
minorVersion := binary.LittleEndian.Uint16(b[30:32])
if majorVersion != superblockMajorVersion || minorVersion != superblockMinorVersion {
return nil, fmt.Errorf("superblock version mismatch, received %d.%d instead of expected %d.%d", majorVersion, minorVersion, superblockMajorVersion, superblockMinorVersion)
}
blocksize := binary.LittleEndian.Uint32(b[12:16])
blocklog := binary.LittleEndian.Uint16(b[22:24])
expectedLog := uint16(math.Log2(float64(blocksize)))
if expectedLog != blocklog {
return nil, fmt.Errorf("superblock block log mismatch, actual %d expected %d", blocklog, expectedLog)
}
flags, err := parseFlags(b[24:26])
if err != nil {
return nil, fmt.Errorf("error parsing flags bytes: %v", err)
}
s := &superblock{
inodes: binary.LittleEndian.Uint32(b[4:8]),
modTime: time.Unix(int64(binary.LittleEndian.Uint32(b[8:12])), 0),
blocksize: blocksize,
fragmentCount: binary.LittleEndian.Uint32(b[16:20]),
compression: compression(binary.LittleEndian.Uint16(b[20:22])),
idCount: binary.LittleEndian.Uint16(b[26:28]),
versionMajor: binary.LittleEndian.Uint16(b[28:30]),
versionMinor: binary.LittleEndian.Uint16(b[30:32]),
rootInode: parseRootInode(binary.LittleEndian.Uint64(b[32:40])),
size: binary.LittleEndian.Uint64(b[40:48]),
idTableStart: binary.LittleEndian.Uint64(b[48:56]),
xattrTableStart: binary.LittleEndian.Uint64(b[56:64]),
inodeTableStart: binary.LittleEndian.Uint64(b[64:72]),
directoryTableStart: binary.LittleEndian.Uint64(b[72:80]),
fragmentTableStart: binary.LittleEndian.Uint64(b[80:88]),
exportTableStart: binary.LittleEndian.Uint64(b[88:96]),
superblockFlags: *flags,
}
return s, nil
}
0707010000033A000081A4000000000000000000000001645E367C0000010A000000000000000000000000000000000000005500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/uidgid.go package squashfs
import "encoding/binary"
const (
idEntrySize = 4
)
func parseIDTable(b []byte) []uint32 {
uidgids := make([]uint32, 0)
for i := 0; i+4-1 < len(b); i += 4 {
uidgids = append(uidgids, binary.LittleEndian.Uint32(b[i:i+4]))
}
return uidgids
}
0707010000033B000081A4000000000000000000000001645E367C000002D4000000000000000000000000000000000000005300000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/util.go package squashfs
import (
"strings"
)
const (
// KB represents one KB
KB int64 = 1024
// MB represents one MB
MB int64 = 1024 * KB
// GB represents one GB
GB int64 = 1024 * MB
// TB represents one TB
TB int64 = 1024 * GB
// max value of uint32
uint32max uint64 = 0xffffffff
)
func universalizePath(p string) string {
// globalize the separator
return strings.ReplaceAll(p, `\`, "/")
}
func splitPath(p string) []string {
ps := universalizePath(p)
// we need to split such that each one ends in "/", except possibly the last one
parts := strings.Split(ps, "/")
// eliminate empty parts
ret := make([]string, 0)
for _, sub := range parts {
if sub != "" {
ret = append(ret, sub)
}
}
return ret
}
0707010000033C000081A4000000000000000000000001645E367C0000096E000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/filesystem/squashfs/xattr.go package squashfs
import (
"encoding/binary"
"fmt"
)
const (
xAttrIDEntrySize uint32 = 16
xAttrHeaderSize uint32 = 16
noXattrInodeFlag uint32 = 0xffffffff
noXattrSuperblockFlag uint64 = 0xffffffffffffffff
)
type xAttrIndex struct {
pos uint64
count uint32
size uint32
}
func parseXAttrIndex(b []byte) (*xAttrIndex, error) {
if len(b) < int(xAttrIDEntrySize) {
return nil, fmt.Errorf("cannot parse xAttr Index of size %d less than minimum %d", len(b), xAttrIDEntrySize)
}
return &xAttrIndex{
pos: binary.LittleEndian.Uint64(b[0:8]),
count: binary.LittleEndian.Uint32(b[8:12]),
size: binary.LittleEndian.Uint32(b[12:16]),
}, nil
}
type xAttrTable struct {
list []*xAttrIndex
data []byte
}
func (x *xAttrTable) find(pos int) (map[string]string, error) {
if pos >= len(x.list) {
return nil, fmt.Errorf("position %d is greater than list size %d", pos, len(x.list))
}
entry := x.list[pos]
b := x.data[entry.pos:]
count := entry.count
ptr := 0
xattrs := map[string]string{}
for i := 0; i < int(count); i++ {
// must be 4 bytes for header
if len(b[pos:]) < 4 {
return nil, fmt.Errorf("insufficient bytes %d to read the xattr at position %d", len(b[ptr:]), ptr)
}
// get the type and size
// xType := binary.LittleEndian.Uint16(b[ptr : ptr+2])
xSize := int(binary.LittleEndian.Uint16(b[ptr+2 : ptr+4]))
nameStart := ptr + 4
valHeaderStart := nameStart + xSize
valStart := valHeaderStart + 4
// make sure we have enough bytes
if len(b[nameStart:]) < xSize {
return nil, fmt.Errorf("xattr header has size %d, but only %d bytes available to read at position %d", xSize, len(b[pos+4:]), ptr)
}
if xSize < 1 {
return nil, fmt.Errorf("no name given for xattr at position %d", ptr)
}
key := string(b[nameStart : nameStart+xSize])
// read the size of the value
if len(b[valHeaderStart:]) < 4 {
return nil, fmt.Errorf("insufficient bytes %d to read the xattr value at position %d", len(b[valHeaderStart:]), ptr)
}
valSize := int(binary.LittleEndian.Uint32(b[valHeaderStart:valStart]))
if len(b[valStart:]) < valSize {
return nil, fmt.Errorf("xattr value has size %d, but only %d bytes available to read at position %d", valSize, len(b[valStart:]), ptr)
}
val := string(b[valStart : valStart+valSize])
xattrs[key] = val
// increment the position pointer
ptr += valStart + valSize
}
return xattrs, nil
}
0707010000033D000041ED000000000000000000000005645E367C00000000000000000000000000000000000000000000004100000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition 0707010000033E000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt 0707010000033F000081A4000000000000000000000001645E367C00000183000000000000000000000000000000000000004F00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt/common.go package gpt
// move all bytes to big endian to fix how GPT stores UUIDs
func bytesToUUIDBytes(in []byte) []byte {
// first 3 sections (4 bytes, 2 bytes, 2 bytes) are little-endian, last 2 section are big-endian
b := make([]byte, 0, 16)
b = append(b, in[0:16]...)
tmpb := b[0:4]
reverseSlice(tmpb)
tmpb = b[4:6]
reverseSlice(tmpb)
tmpb = b[6:8]
reverseSlice(tmpb)
return b
}
07070100000340000081A4000000000000000000000001645E367C0000040F000000000000000000000000000000000000004C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt/doc.go // Package gpt provides an interface to GUID Partition Table (GPT) partitioned disks.
//
// You can use this package to manipulate existing GPT disks, read existing disks, or create entirely
// new partition tables on disks or disk files.
//
// gpt.Table implements the Table interface in github.com/diskfs/go-diskfs/partition
//
// Normally, the best way to interact with a disk is to use the github.com/diskfs/go-diskfs package,
// which, when necessary, will call this one. When creating a new disk or manipulating an existing one,
// You will, however, need to interact with an gpt.Table and gpt.Partition structs.
//
// Here is a simple example of a GPT Table with a single 10MB Linux partition:
//
// table := &gpt.Table{
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// Partitions: []*mbr.Partition{
// {
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// ProtectiveMBR: true,
// GUID: "43E51892-3273-42F7-BCDA-B43B80CDFC48",
// },
// },
// }
package gpt
07070100000341000081A4000000000000000000000001645E367C000021AF000000000000000000000000000000000000005200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt/partition.go package gpt
import (
"encoding/binary"
"fmt"
"io"
"reflect"
"strings"
"unicode/utf16"
"github.com/diskfs/go-diskfs/util"
uuid "github.com/google/uuid"
)
// PartitionEntrySize fixed size of a GPT partition entry
const PartitionEntrySize = 128
// Partition represents the structure of a single partition on the disk
type Partition struct {
Start uint64 // start sector for the partition
End uint64 // end sector for the partition
Size uint64 // size of the partition in bytes
Type Type // parttype for the partition
Name string // name for the partition
GUID string // partition GUID, can be left blank to auto-generate
Attributes uint64 // Attributes flags
logicalSectorSize int
physicalSectorSize int
}
func reverseSlice(s interface{}) {
size := reflect.ValueOf(s).Len()
swap := reflect.Swapper(s)
for i, j := 0, size-1; i < j; i, j = i+1, j-1 {
swap(i, j)
}
}
// toBytes return the 128 bytes for this partition
func (p *Partition) toBytes() ([]byte, error) {
b := make([]byte, PartitionEntrySize)
// if the Type is Unused, just return all zeroes
if p.Type == Unused {
return b, nil
}
// partition type GUID is first 16 bytes
typeGUID, err := uuid.Parse(string(p.Type))
if err != nil {
return nil, fmt.Errorf("unable to parse partition type GUID: %v", err)
}
copy(b[0:16], bytesToUUIDBytes(typeGUID[0:16]))
// partition identifier GUID is next 16 bytes
idGUID, err := uuid.Parse(p.GUID)
if err != nil {
return nil, fmt.Errorf("unable to parse partition identifier GUID: %v", err)
}
copy(b[16:32], bytesToUUIDBytes(idGUID[0:16]))
// next is first LBA and last LBA, uint64 = 8 bytes each
binary.LittleEndian.PutUint64(b[32:40], p.Start)
binary.LittleEndian.PutUint64(b[40:48], p.End)
binary.LittleEndian.PutUint64(b[48:56], p.Attributes)
// now the partition name - it is UTF16LE encoded, max 36 code units for 72 bytes
r := make([]rune, 0, len(p.Name))
// first convert to runes
for _, s := range p.Name {
r = append(r, s)
}
if len(r) > 36 {
return nil, fmt.Errorf("cannot use %s as partition name, has %d Unicode code units, maximum size is 36", p.Name, len(r))
}
// next convert the runes to uint16
nameb := utf16.Encode(r)
// and then convert to little-endian bytes
for i, u := range nameb {
pos := 56 + i*2
binary.LittleEndian.PutUint16(b[pos:pos+2], u)
}
return b, nil
}
// FromBytes create a partition entry from bytes
func partitionFromBytes(b []byte, logicalSectorSize, physicalSectorSize int) (*Partition, error) {
if len(b) != PartitionEntrySize {
return nil, fmt.Errorf("data for partition was %d bytes instead of expected %d", len(b), PartitionEntrySize)
}
// is it all zeroes?
typeGUID, err := uuid.FromBytes(bytesToUUIDBytes(b[0:16]))
if err != nil {
return nil, fmt.Errorf("unable to read partition type GUID: %v", err)
}
typeString := typeGUID.String()
uid, err := uuid.FromBytes(bytesToUUIDBytes(b[16:32]))
if err != nil {
return nil, fmt.Errorf("unable to read partition identifier GUID: %v", err)
}
firstLBA := binary.LittleEndian.Uint64(b[32:40])
lastLBA := binary.LittleEndian.Uint64(b[40:48])
attribs := binary.LittleEndian.Uint64(b[48:56])
// get the partition name
nameb := b[56:]
u := make([]uint16, 0, 72)
for i := 0; i < len(nameb); i += 2 {
// strip any 0s off of the end
entry := binary.LittleEndian.Uint16(nameb[i : i+2])
if entry == 0 {
break
}
u = append(u, entry)
}
r := utf16.Decode(u)
name := string(r)
return &Partition{
Start: firstLBA,
End: lastLBA,
Name: name,
GUID: strings.ToUpper(uid.String()),
Attributes: attribs,
Type: Type(strings.ToUpper(typeString)),
logicalSectorSize: logicalSectorSize,
physicalSectorSize: physicalSectorSize,
}, nil
}
func (p *Partition) GetSize() int64 {
// size already is in Bytes
return int64(p.Size)
}
func (p *Partition) GetStart() int64 {
_, lss := p.sectorSizes()
return int64(p.Start) * int64(lss)
}
// WriteContents fills the partition with the contents provided
// reads from beginning of reader to exactly size of partition in bytes
func (p *Partition) WriteContents(f util.File, contents io.Reader) (uint64, error) {
pss, lss := p.sectorSizes()
total := uint64(0)
// validate start/end/size
calculatedSize := (p.End - p.Start + 1) * uint64(lss)
switch {
case p.Size > 0 && p.Size == calculatedSize:
// all is good
case p.Size == 0 && p.End >= p.Start:
// Size was not set
p.Size = calculatedSize
case p.Size > 0 && p.Size%uint64(lss) == 0 && p.End == 0:
// End was not set
p.End = p.Start + p.Size/uint64(lss) - 1
default:
return total, fmt.Errorf("cannot reconcile partition size %d with start %d / end %d", p.Size, p.Start, p.End)
}
// chunks of physical sector size for efficient writing
b := make([]byte, pss)
// we start at the correct byte location
start := p.Start * uint64(lss)
// loop in physical sector sizes
for {
read, err := contents.Read(b)
if err != nil && err != io.EOF {
return total, fmt.Errorf("could not read contents to pass to partition: %v", err)
}
tmpTotal := uint64(read) + total
if tmpTotal > p.Size {
return total, fmt.Errorf("requested to write at least %d bytes to partition but maximum size is %d", tmpTotal, p.Size)
}
if read > 0 {
var written int
written, err = f.WriteAt(b[:read], int64(start+total))
if err != nil {
return total, fmt.Errorf("error writing to file: %v", err)
}
total += uint64(written)
}
// increment our total
// is this the end of the data?
if err == io.EOF {
break
}
}
// did the total written equal the size of the partition?
if total != p.Size {
return total, fmt.Errorf("write %d bytes to partition but actual size is %d", total, p.Size)
}
return total, nil
}
// ReadContents reads the contents of the partition into a writer
// streams the entire partition to the writer
func (p *Partition) ReadContents(f util.File, out io.Writer) (int64, error) {
pss, _ := p.sectorSizes()
total := int64(0)
// chunks of physical sector size for efficient writing
b := make([]byte, pss)
// we start at the correct byte location
start := p.GetStart()
size := p.GetSize()
// loop in physical sector sizes
for {
read, err := f.ReadAt(b, start+total)
if err != nil && err != io.EOF {
return total, fmt.Errorf("error reading from file: %v", err)
}
if read > 0 {
_, _ = out.Write(b[:read])
}
// increment our total
total += int64(read)
// is this the end of the data?
if err == io.EOF || total >= size {
break
}
}
return total, nil
}
// initEntry adjust the Start/End/Size entries and ensure it has a GUID
func (p *Partition) initEntry(blocksize, starting uint64) error {
part := p
if part.Type == Unused {
return nil
}
var guid uuid.UUID
if part.GUID == "" {
guid, _ = uuid.NewRandom()
} else {
var err error
guid, err = uuid.Parse(part.GUID)
if err != nil {
return fmt.Errorf("invalid UUID: %s", part.GUID)
}
}
part.GUID = strings.ToUpper(guid.String())
// check size matches sectors
// valid possibilities:
// 1- size=0, start>=0, end>start - valid - begin at start, go until end
// 2- size>0, start>=0, end=0 - valid - begin at start for size bytes
// 3- size>0, start=0, end=0 - valid - begin at end of previous partition, go for size bytes
// anything else is an error
size, start, end := part.Size, part.Start, part.End
calculatedSize := (end - start + 1) * blocksize
switch {
case end >= start && size == calculatedSize:
case size == 0 && end >= start:
// provided specific start and end, so calculate size
part.Size = calculatedSize
case size > 0 && size%blocksize == 0 && start > 0 && end == 0:
// provided specific start and size, so calculate end
part.End = start + size/blocksize - 1
case size > 0 && size%blocksize == 0 && start == 0 && end == 0:
// we start right after the end of the previous
start = starting
end = start + size/blocksize - 1
part.Start = start
part.End = end
default:
return fmt.Errorf("invalid partition entry, size %d bytes does not match start sector %d and end sector %d", size, start, end)
}
return nil
}
func (p *Partition) sectorSizes() (physical, logical int) {
physical, logical = p.physicalSectorSize, p.logicalSectorSize
if physical == 0 {
physical = physicalSectorSize
}
if logical == 0 {
logical = logicalSectorSize
}
return physical, logical
}
func (p *Partition) Equal(o *Partition) bool {
return p != nil && o != nil && *p == *o
}
07070100000342000081A4000000000000000000000001645E367C0000471F000000000000000000000000000000000000004E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt/table.go package gpt
import (
"bytes"
"encoding/binary"
"fmt"
"hash/crc32"
"strings"
"github.com/diskfs/go-diskfs/partition/part"
"github.com/diskfs/go-diskfs/util"
uuid "github.com/google/uuid"
)
// gptSize max potential size for partition array reserved 16384
const (
mbrPartitionEntriesStart = 446
mbrPartitionEntriesCount = 4
mbrpartitionEntrySize = 16
// just defaults
physicalSectorSize = 512
logicalSectorSize = 512
)
// Table represents a partition table to be applied to a disk or read from a disk
type Table struct {
Partitions []*Partition // slice of Partition
LogicalSectorSize int // logical size of a sector
PhysicalSectorSize int // physical size of the sector
GUID string // disk GUID, can be left blank to auto-generate
ProtectiveMBR bool // whether or not a protective MBR is in place
partitionArraySize int // how many entries are in the partition array size
partitionEntrySize uint32 // size of the partition entry in the table, usually 128 bytes
partitionFirstLBA uint64 // first LBA of the partition array
partitionEntryChecksum uint32 // checksum of the partition array
primaryHeader uint64 // LBA of primary header, always 1
secondaryHeader uint64 // LBA of secondary header, always last sectors on disk
firstDataSector uint64 // LBA of first data sector
lastDataSector uint64 // LBA of last data sector
initialized bool
}
func getEfiSignature() []byte {
return []byte{0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54}
}
func getEfiRevision() []byte {
return []byte{0x00, 0x00, 0x01, 0x00}
}
func getEfiHeaderSize() []byte {
return []byte{0x5c, 0x00, 0x00, 0x00}
}
func getEfiZeroes() []byte {
return []byte{0x00, 0x00, 0x00, 0x00}
}
func getMbrSignature() []byte {
return []byte{0x55, 0xaa}
}
// check if a byte slice is all zeroes
func zeroMatch(b []byte) bool {
if len(b) < 1 {
return true
}
for _, val := range b {
if val != 0 {
return false
}
}
return true
}
// ensure that a blank table is initialized
func (t *Table) initTable(size int64) {
// default settings
if t.LogicalSectorSize == 0 {
t.LogicalSectorSize = 512
}
if t.PhysicalSectorSize == 0 {
t.PhysicalSectorSize = 512
}
if t.primaryHeader == 0 {
t.primaryHeader = 1
}
if t.GUID == "" {
guid, _ := uuid.NewRandom()
t.GUID = guid.String()
}
if t.partitionArraySize == 0 {
t.partitionArraySize = 128
}
if t.partitionEntrySize == 0 {
t.partitionEntrySize = 128
}
// how many sectors on the disk?
diskSectors := uint64(size) / uint64(t.LogicalSectorSize)
// how many sectors used for partition entries?
partSectors := uint64(t.partitionArraySize) * uint64(t.partitionEntrySize) / uint64(t.LogicalSectorSize)
if t.firstDataSector == 0 {
t.firstDataSector = 2 + partSectors
}
if t.secondaryHeader == 0 {
t.secondaryHeader = diskSectors - 1
}
if t.lastDataSector == 0 {
t.lastDataSector = diskSectors - 1 - partSectors
}
t.initialized = true
}
// Equal check if another table is functionally equal to this one
func (t *Table) Equal(t2 *Table) bool {
if t2 == nil {
return false
}
// neither is nil, so now we need to compare
basicMatch := t.LogicalSectorSize == t2.LogicalSectorSize &&
t.PhysicalSectorSize == t2.PhysicalSectorSize &&
t.partitionEntrySize == t2.partitionEntrySize &&
t.primaryHeader == t2.primaryHeader &&
t.secondaryHeader == t2.secondaryHeader &&
t.firstDataSector == t2.firstDataSector &&
t.lastDataSector == t2.lastDataSector &&
t.partitionArraySize == t2.partitionArraySize &&
t.ProtectiveMBR == t2.ProtectiveMBR &&
t.GUID == t2.GUID
partMatch := comparePartitionArray(t.Partitions, t2.Partitions)
return basicMatch && partMatch
}
func comparePartitionArray(p1, p2 []*Partition) bool {
if (p1 == nil && p2 != nil) || (p2 == nil && p1 != nil) {
return false
}
if p1 == nil && p2 == nil {
return true
}
// neither is nil, so now we need to compare
if len(p1) != len(p2) {
return false
}
matches := true
for i, p := range p1 {
if p.Type == Unused && p2[i].Type == Unused {
continue
}
if *p != *p2[i] {
matches = false
break
}
}
return matches
}
// readProtectiveMBR reads whether or not a protectiveMBR exists in a byte slice
func readProtectiveMBR(b []byte, sectors uint32) bool {
size := len(b)
if size < 512 {
return false
}
// check for MBR signature
if !bytes.Equal(b[size-2:], getMbrSignature()) {
return false
}
// get the partitions
parts := b[mbrPartitionEntriesStart : mbrPartitionEntriesStart+mbrpartitionEntrySize*mbrPartitionEntriesCount]
// should have all except the first partition by zeroes
for i := 1; i < mbrPartitionEntriesCount; i++ {
if !zeroMatch(parts[i*mbrpartitionEntrySize : (i+1)*mbrpartitionEntrySize]) {
return false
}
}
// finally the first one should be a partition of type 0xee that covers the whole disk and has non-bootable
// non-bootable
if parts[0] != 0x00 {
return false
}
// we ignore head/cylinder/sector
// partition type 0xee
if parts[4] != 0xee {
return false
}
if binary.LittleEndian.Uint32(parts[8:12]) != 1 {
return false
}
if binary.LittleEndian.Uint32(parts[12:16]) != sectors {
return false
}
return true
}
// partitionArraySector get the sector that holds the primary or secondary partition array
func (t *Table) partitionArraySector(primary bool) uint64 {
if primary {
return t.primaryHeader + 1
}
return t.secondaryHeader - uint64(t.partitionArraySize)*uint64(t.partitionEntrySize)/uint64(t.LogicalSectorSize)
}
func (t *Table) generateProtectiveMBR() []byte {
b := make([]byte, 512)
// we don't do anything to the first 446 bytes
copy(b[510:], getMbrSignature())
// create the single all disk partition
parts := b[mbrPartitionEntriesStart : mbrPartitionEntriesStart+mbrpartitionEntrySize]
// non-bootable
parts[0] = 0x00
// ignore CHS entirely
// partition type 0xee
parts[4] = 0xee
// ignore CHS entirely
// start LBA 1
binary.LittleEndian.PutUint32(parts[8:12], 1)
// end LBA last omne on disk
binary.LittleEndian.PutUint32(parts[12:16], uint32(t.secondaryHeader))
return b
}
// toPartitionArrayBytes write the bytes for the partition array
func (t *Table) toPartitionArrayBytes() ([]byte, error) {
blocksize := uint64(t.LogicalSectorSize)
firstblock := t.LogicalSectorSize
nextstart := uint64(firstblock)
// go through the partitions, make sure Start/End/Size are correct, and each has a GUID
for i, part := range t.Partitions {
err := part.initEntry(blocksize, nextstart)
if err != nil {
return nil, fmt.Errorf("could not initialize partition %d correctly: %v", i, err)
}
nextstart = part.End + 1
}
// generate the partition bytes
partSize := t.partitionEntrySize * uint32(t.partitionArraySize)
bpart := make([]byte, partSize)
for i, p := range t.Partitions {
// write the primary partition entry
b2, err := p.toBytes()
if err != nil {
return nil, fmt.Errorf("error preparing partition entry %d for writing to disk: %v", i, err)
}
slotStart := i * int(t.partitionEntrySize)
slotEnd := slotStart + int(t.partitionEntrySize)
copy(bpart[slotStart:slotEnd], b2)
}
return bpart, nil
}
// toGPTBytes write just the gpt header to bytes
func (t *Table) toGPTBytes(primary bool) ([]byte, error) {
b := make([]byte, t.LogicalSectorSize)
// 8 bytes "EFI PART" signature - endianness on this?
copy(b[0:8], getEfiSignature())
// 4 bytes revision 1.0
copy(b[8:12], getEfiRevision())
// 4 bytes header size
copy(b[12:16], getEfiHeaderSize())
// 4 bytes CRC32/zlib of header with this field zeroed out - must calculate then come back
copy(b[16:20], []byte{0x00, 0x00, 0x00, 0x00})
// 4 bytes zeroes reserved
copy(b[20:24], getEfiZeroes())
// which LBA are we?
if primary {
binary.LittleEndian.PutUint64(b[24:32], t.primaryHeader)
binary.LittleEndian.PutUint64(b[32:40], t.secondaryHeader)
} else {
binary.LittleEndian.PutUint64(b[24:32], t.secondaryHeader)
binary.LittleEndian.PutUint64(b[32:40], t.primaryHeader)
}
// usable LBAs for partitions
binary.LittleEndian.PutUint64(b[40:48], t.firstDataSector)
binary.LittleEndian.PutUint64(b[48:56], t.lastDataSector)
// 16 bytes disk GUID
var guid uuid.UUID
if t.GUID == "" {
guid, _ = uuid.NewRandom()
} else {
var err error
guid, err = uuid.Parse(t.GUID)
if err != nil {
return nil, fmt.Errorf("invalid UUID: %s", t.GUID)
}
}
copy(b[56:72], bytesToUUIDBytes(guid[0:16]))
// starting LBA of array of partition entries
binary.LittleEndian.PutUint64(b[72:80], t.partitionArraySector(primary))
// how many entries?
binary.LittleEndian.PutUint32(b[80:84], uint32(t.partitionArraySize))
// how big is a single entry?
binary.LittleEndian.PutUint32(b[84:88], 0x80)
// we need a CRC/zlib of the partition entries, so we do those first, then append the bytes
bpart, err := t.toPartitionArrayBytes()
if err != nil {
return nil, fmt.Errorf("error converting partition array to bytes: %v", err)
}
checksum := crc32.ChecksumIEEE(bpart)
binary.LittleEndian.PutUint32(b[88:92], checksum)
// calculate checksum of entire header and place 4 bytes of offset 16 = 0x10
checksum = crc32.ChecksumIEEE(b[0:92])
binary.LittleEndian.PutUint32(b[16:20], checksum)
// zeroes to the end of the sector
for i := 92; i < t.LogicalSectorSize; i++ {
b[i] = 0x00
}
return b, nil
}
func (t *Table) calculatePartitionArrayLocations() (start, size int) {
start = int(t.partitionFirstLBA) * t.LogicalSectorSize
size = t.partitionArraySize * int(t.partitionEntrySize)
return
}
// readPartitionArrayBytes read the bytes for the partition array
func readPartitionArrayBytes(b []byte, entrySize, logicalSectorSize, physicalSectorSize int) ([]*Partition, error) {
parts := make([]*Partition, 0)
for i, c := 0, b; len(c) >= entrySize; c, i = c[entrySize:], i+1 {
bpart := c[:entrySize]
// write the primary partition entry
p, err := partitionFromBytes(bpart, logicalSectorSize, physicalSectorSize)
if err != nil {
return nil, fmt.Errorf("error reading partition entry %d: %v", i, err)
}
// augment partition information
p.Size = (p.End - p.Start + 1) * uint64(logicalSectorSize)
parts = append(parts, p)
}
return parts, nil
}
// tableFromBytes read a partition table from a byte slice
func tableFromBytes(b []byte, logicalBlockSize, physicalBlockSize int) (*Table, error) {
// minimum size - gpt entries + header + LBA0 for (protective) MBR
if len(b) < logicalBlockSize*2 {
return nil, fmt.Errorf("data for partition was %d bytes instead of expected minimum %d", len(b), logicalBlockSize*2)
}
// GPT starts at LBA1
gpt := b[logicalBlockSize:]
// start with fixed headers
efiSignature := gpt[0:8]
efiRevision := gpt[8:12]
efiHeaderSize := gpt[12:16]
efiHeaderCrcBytes := append(make([]byte, 0, 4), gpt[16:20]...)
efiHeaderCrc := binary.LittleEndian.Uint32(efiHeaderCrcBytes)
efiZeroes := gpt[20:24]
primaryHeader := binary.LittleEndian.Uint64(gpt[24:32])
secondaryHeader := binary.LittleEndian.Uint64(gpt[32:40])
firstDataSector := binary.LittleEndian.Uint64(gpt[40:48])
lastDataSector := binary.LittleEndian.Uint64(gpt[48:56])
diskGUID, err := uuid.FromBytes(bytesToUUIDBytes(gpt[56:72]))
if err != nil {
return nil, fmt.Errorf("unable to read guid from disk: %v", err)
}
partitionEntryFirstLBA := binary.LittleEndian.Uint64(gpt[72:80])
partitionEntryCount := binary.LittleEndian.Uint32(gpt[80:84])
partitionEntrySize := binary.LittleEndian.Uint32(gpt[84:88])
partitionEntryChecksum := binary.LittleEndian.Uint32(gpt[88:92])
// once we have the header CRC, zero it out
copy(gpt[16:20], []byte{0x00, 0x00, 0x00, 0x00})
if !bytes.Equal(efiSignature, getEfiSignature()) {
return nil, fmt.Errorf("invalid EFI Signature %v", efiSignature)
}
if !bytes.Equal(efiRevision, getEfiRevision()) {
return nil, fmt.Errorf("invalid EFI Revision %v", efiRevision)
}
if !bytes.Equal(efiHeaderSize, getEfiHeaderSize()) {
return nil, fmt.Errorf("invalid EFI Header size %v", efiHeaderSize)
}
if !bytes.Equal(efiZeroes, getEfiZeroes()) {
return nil, fmt.Errorf("invalid EFI Header, expected zeroes, got %v", efiZeroes)
}
// get the checksum
checksum := crc32.ChecksumIEEE(gpt[0:92])
if efiHeaderCrc != checksum {
return nil, fmt.Errorf("invalid EFI Header Checksum, expected %v, got %v", checksum, efiHeaderCrc)
}
// potential protective MBR is at LBA0
hasProtectiveMBR := readProtectiveMBR(b[:logicalBlockSize], uint32(secondaryHeader))
table := Table{
LogicalSectorSize: logicalBlockSize,
PhysicalSectorSize: physicalBlockSize,
partitionEntrySize: partitionEntrySize,
primaryHeader: primaryHeader,
secondaryHeader: secondaryHeader,
firstDataSector: firstDataSector,
lastDataSector: lastDataSector,
partitionArraySize: int(partitionEntryCount),
partitionFirstLBA: partitionEntryFirstLBA,
ProtectiveMBR: hasProtectiveMBR,
GUID: strings.ToUpper(diskGUID.String()),
partitionEntryChecksum: partitionEntryChecksum,
initialized: true,
}
return &table, nil
}
// Type report the type of table, always "gpt"
func (t *Table) Type() string {
return "gpt"
}
// Write writes a GPT to disk
// Must be passed the util.File to which to write and the size of the disk
func (t *Table) Write(f util.File, size int64) error {
// it is possible that we are given a basic new table that we need to initialize
if !t.initialized {
t.initTable(size)
}
// write the protectiveMBR if any
// write the primary GPT header
// write the primary partition array
// write the secondary partition array
// write the secondary GPT header
var written int
var err error
if t.ProtectiveMBR {
fullMBR := t.generateProtectiveMBR()
protectiveMBR := fullMBR[mbrPartitionEntriesStart:]
written, err = f.WriteAt(protectiveMBR, mbrPartitionEntriesStart)
if err != nil {
return fmt.Errorf("error writing protective MBR to disk: %v", err)
}
if written != len(protectiveMBR) {
return fmt.Errorf("wrote %d bytes of protective MBR instead of %d", written, len(protectiveMBR))
}
}
primaryHeader, err := t.toGPTBytes(true)
if err != nil {
return fmt.Errorf("error converting primary GPT header to byte array: %v", err)
}
written, err = f.WriteAt(primaryHeader, int64(t.LogicalSectorSize))
if err != nil {
return fmt.Errorf("error writing primary GPT to disk: %v", err)
}
if written != len(primaryHeader) {
return fmt.Errorf("wrote %d bytes of primary GPT header instead of %d", written, len(primaryHeader))
}
partitionArray, err := t.toPartitionArrayBytes()
if err != nil {
return fmt.Errorf("error converting primary GPT partitions to byte array: %v", err)
}
written, err = f.WriteAt(partitionArray, int64(t.LogicalSectorSize*int(t.partitionArraySector(true))))
if err != nil {
return fmt.Errorf("error writing primary partition arrayto disk: %v", err)
}
if written != len(partitionArray) {
return fmt.Errorf("wrote %d bytes of primary partition array instead of %d", written, len(primaryHeader))
}
written, err = f.WriteAt(partitionArray, int64(t.LogicalSectorSize)*int64(t.partitionArraySector(false)))
if err != nil {
return fmt.Errorf("error writing secondary partition array to disk: %v", err)
}
if written != len(partitionArray) {
return fmt.Errorf("wrote %d bytes of secondary partition array instead of %d", written, len(primaryHeader))
}
secondaryHeader, err := t.toGPTBytes(false)
if err != nil {
return fmt.Errorf("error converting secondary GPT header to byte array: %v", err)
}
written, err = f.WriteAt(secondaryHeader, int64(t.secondaryHeader)*int64(t.LogicalSectorSize))
if err != nil {
return fmt.Errorf("error writing secondary GPT to disk: %v", err)
}
if written != len(secondaryHeader) {
return fmt.Errorf("wrote %d bytes of secondary GPT header instead of %d", written, len(secondaryHeader))
}
return nil
}
// Read read a partition table from a disk
// must be passed the util.File from which to read, and the logical and physical block sizes
//
// if successful, returns a gpt.Table struct
// returns errors if fails at any stage reading the disk or processing the bytes on disk as a GPT
func Read(f util.File, logicalBlockSize, physicalBlockSize int) (*Table, error) {
// read the data off of the disk - first block is the compatibility MBR, ssecond is the GPT table
b := make([]byte, logicalBlockSize*2)
read, err := f.ReadAt(b, 0)
if err != nil {
return nil, fmt.Errorf("error reading GPT from file: %w", err)
}
if read != len(b) {
return nil, fmt.Errorf("read only %d bytes of GPT from file instead of expected %d", read, len(b))
}
// get the gpt table
gptTable, err := tableFromBytes(b, logicalBlockSize, physicalBlockSize)
if err != nil {
return nil, fmt.Errorf("error reading GPT table: %w", err)
}
start, size := gptTable.calculatePartitionArrayLocations()
b = make([]byte, size)
read, err = f.ReadAt(b, int64(start))
if read != len(b) {
return nil, fmt.Errorf("read only %d bytes of GPT from file instead of expected %d", read, len(b))
}
if err != nil {
return nil, fmt.Errorf("error reading partitions from file: %w", err)
}
// we need a CRC/zlib of the partition entries, so we do those first, then append the bytes
checksum := crc32.ChecksumIEEE(b)
if gptTable.partitionEntryChecksum != checksum {
return nil, fmt.Errorf("invalid EFI Partition Entry Checksum, expected %v, got %v", checksum, gptTable.partitionEntryChecksum)
}
parts, err := readPartitionArrayBytes(b, int(gptTable.partitionEntrySize), logicalBlockSize, physicalBlockSize)
if err != nil {
return nil, fmt.Errorf("error parsing partition data: %w", err)
}
gptTable.Partitions = parts
// get the partition table
return gptTable, nil
}
// GetPartitions get the partitions
func (t *Table) GetPartitions() []part.Partition {
// each Partition matches the part.Partition interface, but golang does not accept passing them in a slice
parts := make([]part.Partition, len(t.Partitions))
for i, p := range t.Partitions {
parts[i] = p
}
return parts
}
07070100000343000081A4000000000000000000000001645E367C00001E08000000000000000000000000000000000000004E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/gpt/types.go package gpt
// Type constants for the GUID for type of partition, see https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_entries
type Type string
// List of GUID partition types
const (
Unused Type = "00000000-0000-0000-0000-000000000000"
EFISystemPartition Type = "C12A7328-F81F-11D2-BA4B-00A0C93EC93B"
MBRPartitionScheme Type = "024DEE41-33E7-11D3-9D69-0008C781F39F"
IntelFastFlash Type = "D3BFE2DE-3DAF-11DF-BA40-E3A556D89593"
BIOSBoot Type = "21686148-6449-6E6F-744E-656564454649"
SonyBootPartition Type = "F4019732-066E-4E12-8273-346C5641494F"
LenovoBootPartition Type = "BFBFAFE7-A34F-448A-9A5B-6213EB736C22"
PowerPCPRePBoot Type = "9E1A2D38-C612-4316-AA26-8B49521E5A8B"
ONIEBoot Type = "7412F7D5-A156-4B13-81DC-867174929325"
ONIEConfig Type = "D4E6E2CD-4469-46F3-B5CB-1BFF57AFC149"
MicrosoftReserved Type = "E3C9E316-0B5C-4DB8-817D-F92DF00215AE"
MicrosoftBasicData Type = "EBD0A0A2-B9E5-4433-87C0-68B6B72699C7"
MicrosoftLDMMetadata Type = "5808C8AA-7E8F-42E0-85D2-E1E90434CFB3"
MicrosoftLDMData Type = "AF9B60A0-1431-4F62-BC68-3311714A69AD"
MicrosoftWindowsRecovery Type = "DE94BBA4-06D1-4D40-A16A-BFD50179D6AC"
IBMGeneralParallelFs Type = "37AFFC90-EF7D-4E96-91C3-2D7AE055B174"
MicrosoftStorageSpaces Type = "E75CAF8F-F680-4CEE-AFA3-B001E56EFC2D"
HPUXData Type = "75894C1E-3AEB-11D3-B7C1-7B03A0000000"
HPUXService Type = "E2A1E728-32E3-11D6-A682-7B03A0000000"
LinuxSwap Type = "0657FD6D-A4AB-43C4-84E5-0933C84B4F4F"
LinuxFilesystem Type = "0FC63DAF-8483-4772-8E79-3D69D8477DE4"
LinuxServerData Type = "3B8F8425-20E0-4F3B-907F-1A25A76F98E8"
LinuxRootX86 Type = "44479540-F297-41B2-9AF7-D131D5F0458A"
LinuxRootArm Type = "69DAD710-2CE4-4E3C-B16C-21A1D49ABED3"
LinuxRootX86_64 Type = "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709"
LinuxRootArm64 Type = "B921B045-1DF0-41C3-AF44-4C6F280D3FAE"
LinuxRootIA64 Type = "993D8D3D-F80E-4225-855A-9DAF8ED7EA97"
LinuxReserved Type = "8DA63339-0007-60C0-C436-083AC8230908"
LinuxHome Type = "933AC7E1-2EB4-4F13-B844-0E14E2AEF915"
LinuxRAID Type = "A19D880F-05FC-4D3B-A006-743F0F84911E"
LinuxExtendedBoot Type = "BC13C2FF-59E6-4262-A352-B275FD6F7172"
LinuxLVM Type = "E6D6D379-F507-44C2-A23C-238F2A3DF928"
LinuxDMCrypt Type = "7FFEC5C9-2D00-49B7-8941-3EA10A5586B7"
LinuxLUKS Type = "CA7D7CCB-63ED-4C53-861C-1742536059CC"
FreeBSDData Type = "516E7CB4-6ECF-11D6-8FF8-00022D09712B"
FreeBSDBoot Type = "83BD6B9D-7F41-11DC-BE0B-001560B84F0F"
FreeBSDSwap Type = "516E7CB5-6ECF-11D6-8FF8-00022D09712B"
FreeBSDNANDFS Type = "74BA7DD9-A689-11E1-BD04-00E081286ACF"
FreeBSDUFS Type = "516E7CB6-6ECF-11D6-8FF8-00022D09712B"
FreeBSDZFS Type = "516E7CBA-6ECF-11D6-8FF8-00022D09712B"
FreeBSDVinum Type = "516E7CB8-6ECF-11D6-8FF8-00022D09712B"
AppleHFS Type = "48465300-0000-11AA-AA11-00306543ECAC"
AppleUFS Type = "55465300-0000-11AA-AA11-00306543ECAC"
AppleAPFS Type = "7C3457EF-0000-11AA-AA11-00306543ECAC"
AppleRAID Type = "52414944-0000-11AA-AA11-00306543ECAC"
AppleRAIDOffline Type = "52414944-5F4F-11AA-AA11-00306543ECAC"
AppleBoot Type = "426F6F74-0000-11AA-AA11-00306543ECAC"
AppleLabel Type = "4C616265-6C00-11AA-AA11-00306543ECAC"
AppleTVRecovery Type = "5265636F-7665-11AA-AA11-00306543ECAC"
AppleCoreStorage Type = "53746F72-6167-11AA-AA11-00306543ECAC"
DragonflyLabel32 Type = "9D087404-1CA5-11DC-8817-01301BB8A9F5"
DragonflySwap Type = "9D58FDBD-1CA5-11DC-8817-01301BB8A9F5"
DragonflyUFS Type = "9D94CE7C-1CA5-11DC-8817-01301BB8A9F5"
DragonflyVINUM Type = "9DD4478F-1CA5-11DC-8817-01301BB8A9F5"
DragonflyCCD Type = "DBD5211B-1CA5-11DC-8817-01301BB8A9F5"
DragonflyLabel64 Type = "3D48CE54-1D16-11DC-8696-01301BB8A9F5"
DragonflyLegacy Type = "BD215AB2-1D16-11DC-8696-01301BB8A9F5"
DragonflyHAMMER Type = "61DC63AC-6E38-11DC-8513-01301BB8A9F5"
DragonflyHAMMER2 Type = "5CBB9AD1-862D-11DC-A94D-01301BB8A9F5"
SolarisBoot Type = "6A82CB45-1DD2-11B2-99A6-080020736631"
SolarisRoot Type = "6A85CF4D-1DD2-11B2-99A6-080020736631"
SolarisUsrAndAppleZFS Type = "6A898CC3-1DD2-11B2-99A6-080020736631"
SolarisSwap Type = "6A87C46F-1DD2-11B2-99A6-080020736631"
SolarisBackup Type = "6A8B642B-1DD2-11B2-99A6-080020736631"
SolarisVar Type = "6A8EF2E9-1DD2-11B2-99A6-080020736631"
SolarisHome Type = "6A90BA39-1DD2-11B2-99A6-080020736631"
SolarisAlternateSector Type = "6A9283A5-1DD2-11B2-99A6-080020736631"
SolarisReserved1 Type = "6A945A3B-1DD2-11B2-99A6-080020736631"
SolarisReserved2 Type = "6A9630D1-1DD2-11B2-99A6-080020736631"
SolarisReserved3 Type = "6A980767-1DD2-11B2-99A6-080020736631"
SolarisReserved4 Type = "6A96237F-1DD2-11B2-99A6-080020736631"
SolarisReserved5 Type = "6A8D2AC7-1DD2-11B2-99A6-080020736631"
NetBSDSwap Type = "49F48D32-B10E-11DC-B99B-0019D1879648"
NetBSDFFS Type = "49F48D5A-B10E-11DC-B99B-0019D1879648"
NetBSDLFS Type = "49F48D82-B10E-11DC-B99B-0019D1879648"
NetBSDConcatenated Type = "2DB519C4-B10E-11DC-B99B-0019D1879648"
NetBSDEncrypted Type = "2DB519EC-B10E-11DC-B99B-0019D1879648"
NetBSDRAID Type = "49F48DAA-B10E-11DC-B99B-0019D1879648"
ChromeOSFirmware Type = "CAB6E88E-ABF3-4102-A07A-D4BB9BE3C1D3"
ChromeOSKernel Type = "FE3A2A5D-4F32-41A7-B725-ACCC3285A309"
ChromeOSRootFs Type = "3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC"
ChromeOSReserved Type = "2E0A753D-9E48-43B0-8337-B15192CB1B5E"
MidnightBSDData Type = "85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7"
MidnightBSDBoot Type = "85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7"
MidnightBSDSwap Type = "85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7"
MidnightBSDUFS Type = "0394EF8B-237E-11E1-B4B3-E89A8F7FC3A7"
MidnightBSDZFS Type = "85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7"
MidnightBSDVinum Type = "85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7"
CephJournal Type = "45B0969E-9B03-4F30-B4C6-B4B80CEFF106"
CephEncryptedJournal Type = "45B0969E-9B03-4F30-B4C6-5EC00CEFF106"
CephOSD Type = "4FBD7E29-9D25-41B8-AFD0-062C0CEFF05D"
CephCryptOSD Type = "4FBD7E29-9D25-41B8-AFD0-5EC00CEFF05D"
CephDiskInCreation Type = "89C57F98-2FE5-4DC0-89C1-F3AD0CEFF2BE"
CephCryptDiskInCreation Type = "89C57F98-2FE5-4DC0-89C1-5EC00CEFF2BE"
VMwareVMFS Type = "AA31E02A-400F-11DB-9590-000C2911D1B8"
VMwareDiagnostic Type = "9D275380-40AD-11DB-BF97-000C2911D1B8"
VMwareVirtualSAN Type = "381CFCCC-7288-11E0-92EE-000C2911D0B2"
VMwareVirsto Type = "77719A0C-A4A0-11E3-A47E-000C29745A24"
VMwareReserved Type = "9198EFFC-31C0-11DB-8F78-000C2911D1B8"
OpenBSDData Type = "824CC7A0-36A8-11E3-890A-952519AD3F61"
QNX6FileSystem Type = "CEF5A9AD-73BC-4601-89F3-CDEEEEE321A1"
Plan9Partition Type = "C91818F9-8025-47AF-89D2-F030D7000C2C"
HiFiveUnleashedFSBL Type = "5B193300-FC78-40CD-8002-E86C45580B47"
HiFiveUnleashedBBL Type = "2E54B353-1271-4842-806F-E436D6AF6985"
)
07070100000344000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004500000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/mbr 07070100000345000081A4000000000000000000000001645E367C000003DD000000000000000000000000000000000000004C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/mbr/doc.go // Package mbr provides an interface to Master Boot Record (MBR) partitioned disks.
//
// You can use this package to manipulate existing MBR disks, read existing disks, or create entirely
// new partition tables on disks or disk files.
//
// mbr.Table implements the Table interface in github.com/diskfs/go-diskfs/partition
//
// Normally, the best way to interact with a disk is to use the github.com/diskfs/go-diskfs package,
// which, when necessary, will call this one. When creating a new disk or manipulating an existing one,
// You will, however, need to interact with an mbr.Table and mbr.Partition structs.
//
// Here is a simple example of an MBR Table with a single 10MB Linux partition:
//
// table := &mbr.Table{
// LogicalSectorSize: 512,
// PhysicalSectorSize: 512,
// Partitions: []*mbr.Partition{
// {
// Bootable: false,
// Type: Linux,
// Start: 2048,
// Size: 20480,
// },
// },
// }
package mbr
07070100000346000081A4000000000000000000000001645E367C00001691000000000000000000000000000000000000005200000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/mbr/partition.go package mbr
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"io"
"github.com/diskfs/go-diskfs/util"
)
// Partition represents the structure of a single partition on the disk
// note that start and end cylinder, head, sector (CHS) are ignored, for the most part.
// godiskfs works with disks that support [Logical Block Addressing (LBA)](https://en.wikipedia.org/wiki/Logical_block_addressing)
type Partition struct {
Bootable bool
Type Type //
Start uint32 // Start first absolute LBA sector for partition
Size uint32 // Size number of sectors in partition
StartCylinder byte
StartHead byte
StartSector byte
EndCylinder byte
EndHead byte
EndSector byte
// we need this for calculations
logicalSectorSize int
physicalSectorSize int
}
// PartitionEqualBytes compares if the bytes for 2 partitions are equal, ignoring CHS start and end
func PartitionEqualBytes(b1, b2 []byte) bool {
if (b1 == nil && b2 != nil) || (b2 == nil && b1 != nil) {
return false
}
if b1 == nil && b2 == nil {
return true
}
if len(b1) != len(b2) {
return false
}
return b1[0] == b2[0] &&
b1[4] == b2[4] &&
bytes.Equal(b1[8:12], b2[8:12]) &&
bytes.Equal(b1[12:16], b2[12:16])
}
// Equal compares if another partition is equal to this one, ignoring CHS start and end
func (p *Partition) Equal(p2 *Partition) bool {
if p2 == nil {
return false
}
return p.Bootable == p2.Bootable &&
p.Type == p2.Type &&
p.Start == p2.Start &&
p.Size == p2.Size
}
func (p *Partition) GetSize() int64 {
_, lss := p.sectorSizes()
return int64(p.Size) * int64(lss)
}
func (p *Partition) GetStart() int64 {
_, lss := p.sectorSizes()
return int64(p.Start) * int64(lss)
}
// toBytes return the 16 bytes for this partition
func (p *Partition) toBytes() []byte {
b := make([]byte, partitionEntrySize)
if p.Bootable {
b[0] = 0x80
} else {
b[0] = 0x00
}
b[1] = p.StartHead
b[2] = p.StartSector
b[3] = p.StartCylinder
b[4] = byte(p.Type)
b[5] = p.EndHead
b[6] = p.EndSector
b[7] = p.EndCylinder
binary.LittleEndian.PutUint32(b[8:12], p.Start)
binary.LittleEndian.PutUint32(b[12:16], p.Size)
return b
}
// partitionFromBytes create a partition entry from 16 bytes
//
//nolint:unparam // this always receives logicalSectorSize=512, but since it can be different, we want to leave it as a param
func partitionFromBytes(b []byte, logicalSectorSize, physicalSectorSize int) (*Partition, error) {
if len(b) != partitionEntrySize {
return nil, fmt.Errorf("data for partition was %d bytes instead of expected %d", len(b), partitionEntrySize)
}
var bootable bool
switch b[0] {
case 0x00:
bootable = false
case 0x80:
bootable = true
default:
return nil, errors.New("invalid partition")
}
return &Partition{
Bootable: bootable,
StartHead: b[1],
StartSector: b[2],
StartCylinder: b[3],
Type: Type(b[4]),
EndHead: b[5],
EndSector: b[6],
EndCylinder: b[7],
Start: binary.LittleEndian.Uint32(b[8:12]),
Size: binary.LittleEndian.Uint32(b[12:16]),
logicalSectorSize: logicalSectorSize,
physicalSectorSize: physicalSectorSize,
}, nil
}
// WriteContents fills the partition with the contents provided
// reads from beginning of reader to exactly size of partition in bytes
func (p *Partition) WriteContents(f util.File, contents io.Reader) (uint64, error) {
pss, lss := p.sectorSizes()
total := uint64(0)
// chunks of physical sector size for efficient writing
b := make([]byte, pss)
// we start at the correct byte location
start := p.Start * uint32(lss)
size := p.Size * uint32(lss)
// loop in physical sector sizes
for {
read, err := contents.Read(b)
if err != nil && err != io.EOF {
return total, fmt.Errorf("could not read contents to pass to partition: %v", err)
}
tmpTotal := uint64(read) + total
if tmpTotal > uint64(size) {
return total, fmt.Errorf("requested to write at least %d bytes to partition but maximum size is %d", tmpTotal, size)
}
var written int
if read > 0 {
written, err = f.WriteAt(b[:read], int64(start)+int64(total))
if err != nil {
return total, fmt.Errorf("error writing to file: %v", err)
}
// increment our total
total += uint64(written)
}
// is this the end of the data?
if err == io.EOF {
break
}
}
// did the total written equal the size of the partition?
if total != uint64(size) {
return total, fmt.Errorf("write %d bytes to partition but actual size is %d", total, size)
}
return total, nil
}
// readContents reads the contents of the partition into a writer
// streams the entire partition to the writer
func (p *Partition) ReadContents(f util.File, out io.Writer) (int64, error) {
pss, lss := p.sectorSizes()
total := int64(0)
// chunks of physical sector size for efficient writing
b := make([]byte, pss)
// we start at the correct byte location
start := p.Start * uint32(lss)
size := p.Size * uint32(lss)
// loop in physical sector sizes
for {
read, err := f.ReadAt(b, int64(start)+total)
if err != nil && err != io.EOF {
return total, fmt.Errorf("error reading from file: %v", err)
}
if read > 0 {
_, _ = out.Write(b[:read])
}
// increment our total
total += int64(read)
// is this the end of the data?
if err == io.EOF || total >= int64(size) {
break
}
}
return total, nil
}
// sectorSizes get the sector sizes for this partition, falling back to the defaults if 0
func (p *Partition) sectorSizes() (physical, logical int) {
physical = p.physicalSectorSize
if physical == 0 {
physical = physicalSectorSize
}
logical = p.logicalSectorSize
if logical == 0 {
logical = logicalSectorSize
}
return physical, logical
}
07070100000347000081A4000000000000000000000001645E367C000012FC000000000000000000000000000000000000004E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/mbr/table.go package mbr
import (
"bytes"
"fmt"
"github.com/diskfs/go-diskfs/partition/part"
"github.com/diskfs/go-diskfs/util"
)
// Table represents an MBR partition table to be applied to a disk or read from a disk
type Table struct {
Partitions []*Partition
LogicalSectorSize int // logical size of a sector
PhysicalSectorSize int // physical size of the sector
initialized bool
}
const (
mbrSize = 512
logicalSectorSize = 512
physicalSectorSize = 512
partitionEntriesStart = 446
partitionEntriesCount = 4
signatureStart = 510
)
// partitionEntrySize standard size of an MBR partition
const partitionEntrySize = 16
func getMbrSignature() []byte {
return []byte{0x55, 0xaa}
}
// compare 2 partition arrays
func comparePartitionArray(p1, p2 []*Partition) bool {
if (p1 == nil && p2 != nil) || (p2 == nil && p1 != nil) {
return false
}
if p1 == nil && p2 == nil {
return true
}
// neither is nil, so now we need to compare
if len(p1) != len(p2) {
return false
}
matches := true
for i, p := range p1 {
if p == nil && p2 != nil || !p.Equal(p2[i]) {
matches = false
break
}
}
return matches
}
// ensure that a blank table is initialized
func (t *Table) initTable() {
// default settings
if t.LogicalSectorSize == 0 {
t.LogicalSectorSize = 512
}
if t.PhysicalSectorSize == 0 {
t.PhysicalSectorSize = 512
}
t.initialized = true
}
// Equal check if another table is equal to this one, ignoring CHS start and end for the partitions
func (t *Table) Equal(t2 *Table) bool {
if t2 == nil {
return false
}
// neither is nil, so now we need to compare
basicMatch := t.LogicalSectorSize == t2.LogicalSectorSize &&
t.PhysicalSectorSize == t2.PhysicalSectorSize
partMatch := comparePartitionArray(t.Partitions, t2.Partitions)
return basicMatch && partMatch
}
// tableFromBytes read a partition table from a byte slice
func tableFromBytes(b []byte) (*Table, error) {
// check length
if len(b) != mbrSize {
return nil, fmt.Errorf("data for partition was %d bytes instead of expected %d", len(b), mbrSize)
}
mbrSignature := b[signatureStart:]
// validate signature
if !bytes.Equal(mbrSignature, getMbrSignature()) {
return nil, fmt.Errorf("invalid MBR Signature %v", mbrSignature)
}
parts := make([]*Partition, 0, partitionEntriesCount)
count := int(partitionEntriesCount)
for i := 0; i < count; i++ {
// write the primary partition entry
start := partitionEntriesStart + i*partitionEntrySize
end := start + partitionEntrySize
p, err := partitionFromBytes(b[start:end], logicalSectorSize, physicalSectorSize)
if err != nil {
return nil, fmt.Errorf("error reading partition entry %d: %v", i, err)
}
parts = append(parts, p)
}
table := &Table{
Partitions: parts,
LogicalSectorSize: logicalSectorSize,
PhysicalSectorSize: 512,
}
return table, nil
}
// Type report the type of table, always the string "mbr"
func (t *Table) Type() string {
return "mbr"
}
// Read read a partition table from a disk, given the logical block size and physical block size
func Read(f util.File, logicalBlockSize, physicalBlockSize int) (*Table, error) {
// read the data off of the disk
b := make([]byte, mbrSize)
read, err := f.ReadAt(b, 0)
if err != nil {
return nil, fmt.Errorf("error reading MBR from file: %v", err)
}
if read != len(b) {
return nil, fmt.Errorf("read only %d bytes of MBR from file instead of expected %d", read, len(b))
}
return tableFromBytes(b)
}
// ToBytes convert Table to byte slice suitable to be flashed to a disk
// If successful, always will return a byte slice of size exactly 512
func (t *Table) toBytes() []byte {
b := make([]byte, 0, mbrSize-partitionEntriesStart)
// write the partitions
for i := 0; i < partitionEntriesCount; i++ {
if i < len(t.Partitions) {
btmp := t.Partitions[i].toBytes()
b = append(b, btmp...)
} else {
b = append(b, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}...)
}
}
// signature
b = append(b, getMbrSignature()...)
return b
}
// Write writes a given MBR Table to disk.
// Must be passed the util.File to write to and the size of the disk
func (t *Table) Write(f util.File, size int64) error {
b := t.toBytes()
written, err := f.WriteAt(b, partitionEntriesStart)
if err != nil {
return fmt.Errorf("error writing partition table to disk: %v", err)
}
if written != len(b) {
return fmt.Errorf("partition table wrote %d bytes to disk instead of the expected %d", written, len(b))
}
return nil
}
func (t *Table) GetPartitions() []part.Partition {
// each Partition matches the part.Partition interface, but golang does not accept passing them in a slice
parts := make([]part.Partition, len(t.Partitions))
for i, p := range t.Partitions {
parts[i] = p
}
return parts
}
07070100000348000081A4000000000000000000000001645E367C00000384000000000000000000000000000000000000004E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/mbr/types.go package mbr
// Type constants for the GUID for type of partition, see https://en.wikipedia.org/wiki/GUID_Partition_Table#Partition_entries
type Type byte
// List of GUID partition types
const (
Empty Type = 0x00
Fat12 Type = 0x01
XenixRoot Type = 0x02
XenixUsr Type = 0x03
Fat16 Type = 0x04
ExtendedCHS Type = 0x05
Fat16b Type = 0x06
NTFS Type = 0x07
CommodoreFAT Type = 0x08
Fat32CHS Type = 0x0b
Fat32LBA Type = 0x0c
Fat16bLBA Type = 0x0e
ExtendedLBA Type = 0x0f
LinuxSwap Type = 0x82
Linux Type = 0x83
LinuxExtended Type = 0x85
LinuxLVM Type = 0x8e
Iso9660 Type = 0x96
MacOSXUFS Type = 0xa8
MacOSXBoot Type = 0xab
HFS Type = 0xaf
Solaris8Boot Type = 0xbe
GPTProtective Type = 0xee
EFISystem Type = 0xef
VMWareFS Type = 0xfb
VMWareSwap Type = 0xfc
)
07070100000349000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004600000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/part 0707010000034A000081A4000000000000000000000001645E367C00000127000000000000000000000000000000000000005300000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/part/partition.go package part
import (
"io"
"github.com/diskfs/go-diskfs/util"
)
// Partition reference to an individual partition on disk
type Partition interface {
GetSize() int64
GetStart() int64
ReadContents(util.File, io.Writer) (int64, error)
WriteContents(util.File, io.Reader) (uint64, error)
}
0707010000034B000081A4000000000000000000000001645E367C0000030A000000000000000000000000000000000000004E00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/partition.go // Package partition provides ability to work with individual partitions.
// All useful implementations are subpackages of this package, e.g. github.com/diskfs/go-diskfs/gpt
package partition
import (
"fmt"
"github.com/diskfs/go-diskfs/partition/gpt"
"github.com/diskfs/go-diskfs/partition/mbr"
"github.com/diskfs/go-diskfs/util"
)
// Read read a partition table from a disk
func Read(f util.File, logicalBlocksize, physicalBlocksize int) (Table, error) {
// just try each type
gptTable, err := gpt.Read(f, logicalBlocksize, physicalBlocksize)
if err == nil {
return gptTable, nil
}
mbrTable, err := mbr.Read(f, logicalBlocksize, physicalBlocksize)
if err == nil {
return mbrTable, nil
}
// we are out
return nil, fmt.Errorf("unknown disk partition type")
}
0707010000034C000081A4000000000000000000000001645E367C0000010D000000000000000000000000000000000000004A00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/partition/table.go package partition
import (
"github.com/diskfs/go-diskfs/partition/part"
"github.com/diskfs/go-diskfs/util"
)
// Table reference to a partitioning table on disk
type Table interface {
Type() string
Write(util.File, int64) error
GetPartitions() []part.Partition
}
0707010000034D000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000003C00000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/util 0707010000034E000081A4000000000000000000000001645E367C00000174000000000000000000000000000000000000004400000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/util/file.go // Package util common utilities or other elements shared across github.com/diskfs/go-diskfs packages
package util
import "io"
// File interface that can be read from and written to.
// Normally implemented as actual os.File, but useful as a separate interface so can easily
// use alternate implementations.
type File interface {
io.ReaderAt
io.WriterAt
io.Seeker
}
0707010000034F000081A4000000000000000000000001645E367C00000077000000000000000000000000000000000000004700000000elemental-cli-0.3.1/vendor/github.com/diskfs/go-diskfs/util/version.go package util
const (
// AppNameVersion name and URL to app
AppNameVersion = "https://github.com/diskfs/go-diskfs"
)
07070100000350000041ED000000000000000000000003645E367C00000000000000000000000000000000000000000000003300000000elemental-cli-0.3.1/vendor/github.com/distribution 07070100000351000041ED000000000000000000000004645E367C00000000000000000000000000000000000000000000004000000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution 07070100000352000081A4000000000000000000000001645E367C00002C3D000000000000000000000000000000000000004800000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/LICENSE Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
07070100000353000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004A00000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/reference 07070100000354000081A4000000000000000000000001645E367C0000047C000000000000000000000000000000000000005500000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/reference/helpers.go package reference
import "path"
// IsNameOnly returns true if reference only contains a repo name.
func IsNameOnly(ref Named) bool {
if _, ok := ref.(NamedTagged); ok {
return false
}
if _, ok := ref.(Canonical); ok {
return false
}
return true
}
// FamiliarName returns the familiar name string
// for the given named, familiarizing if needed.
func FamiliarName(ref Named) string {
if nn, ok := ref.(normalizedNamed); ok {
return nn.Familiar().Name()
}
return ref.Name()
}
// FamiliarString returns the familiar string representation
// for the given reference, familiarizing if needed.
func FamiliarString(ref Reference) string {
if nn, ok := ref.(normalizedNamed); ok {
return nn.Familiar().String()
}
return ref.String()
}
// FamiliarMatch reports whether ref matches the specified pattern.
// See https://godoc.org/path#Match for supported patterns.
func FamiliarMatch(pattern string, ref Reference) (bool, error) {
matched, err := path.Match(pattern, FamiliarString(ref))
if namedRef, isNamed := ref.(Named); isNamed && !matched {
matched, _ = path.Match(pattern, FamiliarName(namedRef))
}
return matched, err
}
07070100000355000081A4000000000000000000000001645E367C00001792000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/reference/normalize.go package reference
import (
"errors"
"fmt"
"strings"
"github.com/docker/distribution/digestset"
"github.com/opencontainers/go-digest"
)
var (
legacyDefaultDomain = "index.docker.io"
defaultDomain = "docker.io"
officialRepoName = "library"
defaultTag = "latest"
)
// normalizedNamed represents a name which has been
// normalized and has a familiar form. A familiar name
// is what is used in Docker UI. An example normalized
// name is "docker.io/library/ubuntu" and corresponding
// familiar name of "ubuntu".
type normalizedNamed interface {
Named
Familiar() Named
}
// ParseNormalizedNamed parses a string into a named reference
// transforming a familiar name from Docker UI to a fully
// qualified reference. If the value may be an identifier
// use ParseAnyReference.
func ParseNormalizedNamed(s string) (Named, error) {
if ok := anchoredIdentifierRegexp.MatchString(s); ok {
return nil, fmt.Errorf("invalid repository name (%s), cannot specify 64-byte hexadecimal strings", s)
}
domain, remainder := splitDockerDomain(s)
var remoteName string
if tagSep := strings.IndexRune(remainder, ':'); tagSep > -1 {
remoteName = remainder[:tagSep]
} else {
remoteName = remainder
}
if strings.ToLower(remoteName) != remoteName {
return nil, errors.New("invalid reference format: repository name must be lowercase")
}
ref, err := Parse(domain + "/" + remainder)
if err != nil {
return nil, err
}
named, isNamed := ref.(Named)
if !isNamed {
return nil, fmt.Errorf("reference %s has no name", ref.String())
}
return named, nil
}
// ParseDockerRef normalizes the image reference following the docker convention. This is added
// mainly for backward compatibility.
// The reference returned can only be either tagged or digested. For reference contains both tag
// and digest, the function returns digested reference, e.g. docker.io/library/busybox:latest@
// sha256:7cc4b5aefd1d0cadf8d97d4350462ba51c694ebca145b08d7d41b41acc8db5aa will be returned as
// docker.io/library/busybox@sha256:7cc4b5aefd1d0cadf8d97d4350462ba51c694ebca145b08d7d41b41acc8db5aa.
func ParseDockerRef(ref string) (Named, error) {
named, err := ParseNormalizedNamed(ref)
if err != nil {
return nil, err
}
if _, ok := named.(NamedTagged); ok {
if canonical, ok := named.(Canonical); ok {
// The reference is both tagged and digested, only
// return digested.
newNamed, err := WithName(canonical.Name())
if err != nil {
return nil, err
}
newCanonical, err := WithDigest(newNamed, canonical.Digest())
if err != nil {
return nil, err
}
return newCanonical, nil
}
}
return TagNameOnly(named), nil
}
// splitDockerDomain splits a repository name to domain and remotename string.
// If no valid domain is found, the default domain is used. Repository name
// needs to be already validated before.
func splitDockerDomain(name string) (domain, remainder string) {
i := strings.IndexRune(name, '/')
if i == -1 || (!strings.ContainsAny(name[:i], ".:") && name[:i] != "localhost") {
domain, remainder = defaultDomain, name
} else {
domain, remainder = name[:i], name[i+1:]
}
if domain == legacyDefaultDomain {
domain = defaultDomain
}
if domain == defaultDomain && !strings.ContainsRune(remainder, '/') {
remainder = officialRepoName + "/" + remainder
}
return
}
// familiarizeName returns a shortened version of the name familiar
// to to the Docker UI. Familiar names have the default domain
// "docker.io" and "library/" repository prefix removed.
// For example, "docker.io/library/redis" will have the familiar
// name "redis" and "docker.io/dmcgowan/myapp" will be "dmcgowan/myapp".
// Returns a familiarized named only reference.
func familiarizeName(named namedRepository) repository {
repo := repository{
domain: named.Domain(),
path: named.Path(),
}
if repo.domain == defaultDomain {
repo.domain = ""
// Handle official repositories which have the pattern "library/"
if split := strings.Split(repo.path, "/"); len(split) == 2 && split[0] == officialRepoName {
repo.path = split[1]
}
}
return repo
}
func (r reference) Familiar() Named {
return reference{
namedRepository: familiarizeName(r.namedRepository),
tag: r.tag,
digest: r.digest,
}
}
func (r repository) Familiar() Named {
return familiarizeName(r)
}
func (t taggedReference) Familiar() Named {
return taggedReference{
namedRepository: familiarizeName(t.namedRepository),
tag: t.tag,
}
}
func (c canonicalReference) Familiar() Named {
return canonicalReference{
namedRepository: familiarizeName(c.namedRepository),
digest: c.digest,
}
}
// TagNameOnly adds the default tag "latest" to a reference if it only has
// a repo name.
func TagNameOnly(ref Named) Named {
if IsNameOnly(ref) {
namedTagged, err := WithTag(ref, defaultTag)
if err != nil {
// Default tag must be valid, to create a NamedTagged
// type with non-validated input the WithTag function
// should be used instead
panic(err)
}
return namedTagged
}
return ref
}
// ParseAnyReference parses a reference string as a possible identifier,
// full digest, or familiar name.
func ParseAnyReference(ref string) (Reference, error) {
if ok := anchoredIdentifierRegexp.MatchString(ref); ok {
return digestReference("sha256:" + ref), nil
}
if dgst, err := digest.Parse(ref); err == nil {
return digestReference(dgst), nil
}
return ParseNormalizedNamed(ref)
}
// ParseAnyReferenceWithSet parses a reference string as a possible short
// identifier to be matched in a digest set, a full digest, or familiar name.
func ParseAnyReferenceWithSet(ref string, ds *digestset.Set) (Reference, error) {
if ok := anchoredShortIdentifierRegexp.MatchString(ref); ok {
dgst, err := ds.Lookup(ref)
if err == nil {
return digestReference(dgst), nil
}
} else {
if dgst, err := digest.Parse(ref); err == nil {
return digestReference(dgst), nil
}
}
return ParseNormalizedNamed(ref)
}
07070100000356000081A4000000000000000000000001645E367C00002B8E000000000000000000000000000000000000005700000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/reference/reference.go // Package reference provides a general type to represent any way of referencing images within the registry.
// Its main purpose is to abstract tags and digests (content-addressable hash).
//
// Grammar
//
// reference := name [ ":" tag ] [ "@" digest ]
// name := [domain '/'] path-component ['/' path-component]*
// domain := domain-component ['.' domain-component]* [':' port-number]
// domain-component := /([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])/
// port-number := /[0-9]+/
// path-component := alpha-numeric [separator alpha-numeric]*
// alpha-numeric := /[a-z0-9]+/
// separator := /[_.]|__|[-]*/
//
// tag := /[\w][\w.-]{0,127}/
//
// digest := digest-algorithm ":" digest-hex
// digest-algorithm := digest-algorithm-component [ digest-algorithm-separator digest-algorithm-component ]*
// digest-algorithm-separator := /[+.-_]/
// digest-algorithm-component := /[A-Za-z][A-Za-z0-9]*/
// digest-hex := /[0-9a-fA-F]{32,}/ ; At least 128 bit digest value
//
// identifier := /[a-f0-9]{64}/
// short-identifier := /[a-f0-9]{6,64}/
package reference
import (
"errors"
"fmt"
"strings"
"github.com/opencontainers/go-digest"
)
const (
// NameTotalLengthMax is the maximum total number of characters in a repository name.
NameTotalLengthMax = 255
)
var (
// ErrReferenceInvalidFormat represents an error while trying to parse a string as a reference.
ErrReferenceInvalidFormat = errors.New("invalid reference format")
// ErrTagInvalidFormat represents an error while trying to parse a string as a tag.
ErrTagInvalidFormat = errors.New("invalid tag format")
// ErrDigestInvalidFormat represents an error while trying to parse a string as a tag.
ErrDigestInvalidFormat = errors.New("invalid digest format")
// ErrNameContainsUppercase is returned for invalid repository names that contain uppercase characters.
ErrNameContainsUppercase = errors.New("repository name must be lowercase")
// ErrNameEmpty is returned for empty, invalid repository names.
ErrNameEmpty = errors.New("repository name must have at least one component")
// ErrNameTooLong is returned when a repository name is longer than NameTotalLengthMax.
ErrNameTooLong = fmt.Errorf("repository name must not be more than %v characters", NameTotalLengthMax)
// ErrNameNotCanonical is returned when a name is not canonical.
ErrNameNotCanonical = errors.New("repository name must be canonical")
)
// Reference is an opaque object reference identifier that may include
// modifiers such as a hostname, name, tag, and digest.
type Reference interface {
// String returns the full reference
String() string
}
// Field provides a wrapper type for resolving correct reference types when
// working with encoding.
type Field struct {
reference Reference
}
// AsField wraps a reference in a Field for encoding.
func AsField(reference Reference) Field {
return Field{reference}
}
// Reference unwraps the reference type from the field to
// return the Reference object. This object should be
// of the appropriate type to further check for different
// reference types.
func (f Field) Reference() Reference {
return f.reference
}
// MarshalText serializes the field to byte text which
// is the string of the reference.
func (f Field) MarshalText() (p []byte, err error) {
return []byte(f.reference.String()), nil
}
// UnmarshalText parses text bytes by invoking the
// reference parser to ensure the appropriately
// typed reference object is wrapped by field.
func (f *Field) UnmarshalText(p []byte) error {
r, err := Parse(string(p))
if err != nil {
return err
}
f.reference = r
return nil
}
// Named is an object with a full name
type Named interface {
Reference
Name() string
}
// Tagged is an object which has a tag
type Tagged interface {
Reference
Tag() string
}
// NamedTagged is an object including a name and tag.
type NamedTagged interface {
Named
Tag() string
}
// Digested is an object which has a digest
// in which it can be referenced by
type Digested interface {
Reference
Digest() digest.Digest
}
// Canonical reference is an object with a fully unique
// name including a name with domain and digest
type Canonical interface {
Named
Digest() digest.Digest
}
// namedRepository is a reference to a repository with a name.
// A namedRepository has both domain and path components.
type namedRepository interface {
Named
Domain() string
Path() string
}
// Domain returns the domain part of the Named reference
func Domain(named Named) string {
if r, ok := named.(namedRepository); ok {
return r.Domain()
}
domain, _ := splitDomain(named.Name())
return domain
}
// Path returns the name without the domain part of the Named reference
func Path(named Named) (name string) {
if r, ok := named.(namedRepository); ok {
return r.Path()
}
_, path := splitDomain(named.Name())
return path
}
func splitDomain(name string) (string, string) {
match := anchoredNameRegexp.FindStringSubmatch(name)
if len(match) != 3 {
return "", name
}
return match[1], match[2]
}
// SplitHostname splits a named reference into a
// hostname and name string. If no valid hostname is
// found, the hostname is empty and the full value
// is returned as name
// DEPRECATED: Use Domain or Path
func SplitHostname(named Named) (string, string) {
if r, ok := named.(namedRepository); ok {
return r.Domain(), r.Path()
}
return splitDomain(named.Name())
}
// Parse parses s and returns a syntactically valid Reference.
// If an error was encountered it is returned, along with a nil Reference.
// NOTE: Parse will not handle short digests.
func Parse(s string) (Reference, error) {
matches := ReferenceRegexp.FindStringSubmatch(s)
if matches == nil {
if s == "" {
return nil, ErrNameEmpty
}
if ReferenceRegexp.FindStringSubmatch(strings.ToLower(s)) != nil {
return nil, ErrNameContainsUppercase
}
return nil, ErrReferenceInvalidFormat
}
if len(matches[1]) > NameTotalLengthMax {
return nil, ErrNameTooLong
}
var repo repository
nameMatch := anchoredNameRegexp.FindStringSubmatch(matches[1])
if len(nameMatch) == 3 {
repo.domain = nameMatch[1]
repo.path = nameMatch[2]
} else {
repo.domain = ""
repo.path = matches[1]
}
ref := reference{
namedRepository: repo,
tag: matches[2],
}
if matches[3] != "" {
var err error
ref.digest, err = digest.Parse(matches[3])
if err != nil {
return nil, err
}
}
r := getBestReferenceType(ref)
if r == nil {
return nil, ErrNameEmpty
}
return r, nil
}
// ParseNamed parses s and returns a syntactically valid reference implementing
// the Named interface. The reference must have a name and be in the canonical
// form, otherwise an error is returned.
// If an error was encountered it is returned, along with a nil Reference.
// NOTE: ParseNamed will not handle short digests.
func ParseNamed(s string) (Named, error) {
named, err := ParseNormalizedNamed(s)
if err != nil {
return nil, err
}
if named.String() != s {
return nil, ErrNameNotCanonical
}
return named, nil
}
// WithName returns a named object representing the given string. If the input
// is invalid ErrReferenceInvalidFormat will be returned.
func WithName(name string) (Named, error) {
if len(name) > NameTotalLengthMax {
return nil, ErrNameTooLong
}
match := anchoredNameRegexp.FindStringSubmatch(name)
if match == nil || len(match) != 3 {
return nil, ErrReferenceInvalidFormat
}
return repository{
domain: match[1],
path: match[2],
}, nil
}
// WithTag combines the name from "name" and the tag from "tag" to form a
// reference incorporating both the name and the tag.
func WithTag(name Named, tag string) (NamedTagged, error) {
if !anchoredTagRegexp.MatchString(tag) {
return nil, ErrTagInvalidFormat
}
var repo repository
if r, ok := name.(namedRepository); ok {
repo.domain = r.Domain()
repo.path = r.Path()
} else {
repo.path = name.Name()
}
if canonical, ok := name.(Canonical); ok {
return reference{
namedRepository: repo,
tag: tag,
digest: canonical.Digest(),
}, nil
}
return taggedReference{
namedRepository: repo,
tag: tag,
}, nil
}
// WithDigest combines the name from "name" and the digest from "digest" to form
// a reference incorporating both the name and the digest.
func WithDigest(name Named, digest digest.Digest) (Canonical, error) {
if !anchoredDigestRegexp.MatchString(digest.String()) {
return nil, ErrDigestInvalidFormat
}
var repo repository
if r, ok := name.(namedRepository); ok {
repo.domain = r.Domain()
repo.path = r.Path()
} else {
repo.path = name.Name()
}
if tagged, ok := name.(Tagged); ok {
return reference{
namedRepository: repo,
tag: tagged.Tag(),
digest: digest,
}, nil
}
return canonicalReference{
namedRepository: repo,
digest: digest,
}, nil
}
// TrimNamed removes any tag or digest from the named reference.
func TrimNamed(ref Named) Named {
domain, path := SplitHostname(ref)
return repository{
domain: domain,
path: path,
}
}
func getBestReferenceType(ref reference) Reference {
if ref.Name() == "" {
// Allow digest only references
if ref.digest != "" {
return digestReference(ref.digest)
}
return nil
}
if ref.tag == "" {
if ref.digest != "" {
return canonicalReference{
namedRepository: ref.namedRepository,
digest: ref.digest,
}
}
return ref.namedRepository
}
if ref.digest == "" {
return taggedReference{
namedRepository: ref.namedRepository,
tag: ref.tag,
}
}
return ref
}
type reference struct {
namedRepository
tag string
digest digest.Digest
}
func (r reference) String() string {
return r.Name() + ":" + r.tag + "@" + r.digest.String()
}
func (r reference) Tag() string {
return r.tag
}
func (r reference) Digest() digest.Digest {
return r.digest
}
type repository struct {
domain string
path string
}
func (r repository) String() string {
return r.Name()
}
func (r repository) Name() string {
if r.domain == "" {
return r.path
}
return r.domain + "/" + r.path
}
func (r repository) Domain() string {
return r.domain
}
func (r repository) Path() string {
return r.path
}
type digestReference digest.Digest
func (d digestReference) String() string {
return digest.Digest(d).String()
}
func (d digestReference) Digest() digest.Digest {
return digest.Digest(d)
}
type taggedReference struct {
namedRepository
tag string
}
func (t taggedReference) String() string {
return t.Name() + ":" + t.tag
}
func (t taggedReference) Tag() string {
return t.tag
}
type canonicalReference struct {
namedRepository
digest digest.Digest
}
func (c canonicalReference) String() string {
return c.Name() + "@" + c.digest.String()
}
func (c canonicalReference) Digest() digest.Digest {
return c.digest
}
07070100000357000081A4000000000000000000000001645E367C00001492000000000000000000000000000000000000005400000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/reference/regexp.go package reference
import "regexp"
var (
// alphaNumericRegexp defines the alpha numeric atom, typically a
// component of names. This only allows lower case characters and digits.
alphaNumericRegexp = match(`[a-z0-9]+`)
// separatorRegexp defines the separators allowed to be embedded in name
// components. This allow one period, one or two underscore and multiple
// dashes.
separatorRegexp = match(`(?:[._]|__|[-]*)`)
// nameComponentRegexp restricts registry path component names to start
// with at least one letter or number, with following parts able to be
// separated by one period, one or two underscore and multiple dashes.
nameComponentRegexp = expression(
alphaNumericRegexp,
optional(repeated(separatorRegexp, alphaNumericRegexp)))
// domainComponentRegexp restricts the registry domain component of a
// repository name to start with a component as defined by DomainRegexp
// and followed by an optional port.
domainComponentRegexp = match(`(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])`)
// DomainRegexp defines the structure of potential domain components
// that may be part of image names. This is purposely a subset of what is
// allowed by DNS to ensure backwards compatibility with Docker image
// names.
DomainRegexp = expression(
domainComponentRegexp,
optional(repeated(literal(`.`), domainComponentRegexp)),
optional(literal(`:`), match(`[0-9]+`)))
// TagRegexp matches valid tag names. From docker/docker:graph/tags.go.
TagRegexp = match(`[\w][\w.-]{0,127}`)
// anchoredTagRegexp matches valid tag names, anchored at the start and
// end of the matched string.
anchoredTagRegexp = anchored(TagRegexp)
// DigestRegexp matches valid digests.
DigestRegexp = match(`[A-Za-z][A-Za-z0-9]*(?:[-_+.][A-Za-z][A-Za-z0-9]*)*[:][[:xdigit:]]{32,}`)
// anchoredDigestRegexp matches valid digests, anchored at the start and
// end of the matched string.
anchoredDigestRegexp = anchored(DigestRegexp)
// NameRegexp is the format for the name component of references. The
// regexp has capturing groups for the domain and name part omitting
// the separating forward slash from either.
NameRegexp = expression(
optional(DomainRegexp, literal(`/`)),
nameComponentRegexp,
optional(repeated(literal(`/`), nameComponentRegexp)))
// anchoredNameRegexp is used to parse a name value, capturing the
// domain and trailing components.
anchoredNameRegexp = anchored(
optional(capture(DomainRegexp), literal(`/`)),
capture(nameComponentRegexp,
optional(repeated(literal(`/`), nameComponentRegexp))))
// ReferenceRegexp is the full supported format of a reference. The regexp
// is anchored and has capturing groups for name, tag, and digest
// components.
ReferenceRegexp = anchored(capture(NameRegexp),
optional(literal(":"), capture(TagRegexp)),
optional(literal("@"), capture(DigestRegexp)))
// IdentifierRegexp is the format for string identifier used as a
// content addressable identifier using sha256. These identifiers
// are like digests without the algorithm, since sha256 is used.
IdentifierRegexp = match(`([a-f0-9]{64})`)
// ShortIdentifierRegexp is the format used to represent a prefix
// of an identifier. A prefix may be used to match a sha256 identifier
// within a list of trusted identifiers.
ShortIdentifierRegexp = match(`([a-f0-9]{6,64})`)
// anchoredIdentifierRegexp is used to check or match an
// identifier value, anchored at start and end of string.
anchoredIdentifierRegexp = anchored(IdentifierRegexp)
// anchoredShortIdentifierRegexp is used to check if a value
// is a possible identifier prefix, anchored at start and end
// of string.
anchoredShortIdentifierRegexp = anchored(ShortIdentifierRegexp)
)
// match compiles the string to a regular expression.
var match = regexp.MustCompile
// literal compiles s into a literal regular expression, escaping any regexp
// reserved characters.
func literal(s string) *regexp.Regexp {
re := match(regexp.QuoteMeta(s))
if _, complete := re.LiteralPrefix(); !complete {
panic("must be a literal")
}
return re
}
// expression defines a full expression, where each regular expression must
// follow the previous.
func expression(res ...*regexp.Regexp) *regexp.Regexp {
var s string
for _, re := range res {
s += re.String()
}
return match(s)
}
// optional wraps the expression in a non-capturing group and makes the
// production optional.
func optional(res ...*regexp.Regexp) *regexp.Regexp {
return match(group(expression(res...)).String() + `?`)
}
// repeated wraps the regexp in a non-capturing group to get one or more
// matches.
func repeated(res ...*regexp.Regexp) *regexp.Regexp {
return match(group(expression(res...)).String() + `+`)
}
// group wraps the regexp in a non-capturing group.
func group(res ...*regexp.Regexp) *regexp.Regexp {
return match(`(?:` + expression(res...).String() + `)`)
}
// capture wraps the expression in a capturing group.
func capture(res ...*regexp.Regexp) *regexp.Regexp {
return match(`(` + expression(res...).String() + `)`)
}
// anchored anchors the regular expression by adding start and end delimiters.
func anchored(res ...*regexp.Regexp) *regexp.Regexp {
return match(`^` + expression(res...).String() + `$`)
}
07070100000358000041ED000000000000000000000002645E367C00000000000000000000000000000000000000000000004500000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/uuid 07070100000359000081A4000000000000000000000001645E367C00000C1B000000000000000000000000000000000000004D00000000elemental-cli-0.3.1/vendor/github.com/distribution/distribution/uuid/uuid.go // Package uuid provides simple UUID generation. Only version 4 style UUIDs
// can be generated.
//
// Please see http://tools.ietf.org/html/rfc4122 for details on UUIDs.
package uuid
import (
"crypto/rand"
"fmt"
"io"
"os"
"syscall"
"time"
)
const (
// Bits is the number of bits in a UUID
Bits = 128
// Size is the number of bytes in a UUID
Size = Bits / 8
format = "%08x-%04x-%04x-%04x-%012x"
)
var (
// ErrUUIDInvalid indicates a parsed string is not a valid uuid.
ErrUUIDInvalid = fmt.Errorf("invalid uuid")
// Loggerf can be used to override the default logging destination. Such
// log messages in this library should be logged at warning or higher.
Loggerf = func(format string, args ...interface{}) {}
)
// UUID represents a UUID value. UUIDs can be compared and set to other values
// and accessed by byte.
type UUID [Size]byte
// Generate creates a new, version 4 uuid.
func Generate() (u UUID) {
const (
// ensures we backoff for less than 450ms total. Use the following to
// select new value, in units of 10ms:
// n*(n+1)/2 = d -> n^2 + n - 2d -> n = (sqrt(8d + 1) - 1)/2
maxretries = 9
backoff = time.Millisecond * 10
)
var (
totalBackoff time.Duration
count int
retries int
)
for {
// This should never block but the read may fail. Because of this,
// we just try to read the random number generator until we get
// something. This is a very rare condition but may happen.
b := time.Duration(retries) * backoff
time.Sleep(b)
totalBackoff += b
n, err := io.ReadFull(rand.Reader, u[count:])
if err != nil {
if retryOnError(err) && retries < maxretries {
count += n
retries++
Loggerf("error generating version 4 uuid, retrying: %v", err)
continue
}
// Any other errors represent a system problem. What did someone
// do to /dev/urandom?
panic(fmt.Errorf("error reading random number generator, retried for %v: %v", totalBackoff.String(), err))
}
break
}
u[6] = (u[6] & 0x0f) | 0x40 // set version byte
u[8] = (u[8] & 0x3f) | 0x80 // set high order byte 0b10{8,9,a,b}
return u
}
// Parse attempts to extract a uuid from the string or returns an error.
func Parse(s string) (u UUID, err error) {
if len(s) != 36 {
return UUID{}, ErrUUIDInvalid
}
// create stack addresses for each section of the uuid.
p := make([][]byte, 5)
if _, err := fmt.Sscanf(s, format, &p[0], &p[1], &p[2], &p[3], &p[4]); err != nil {
return u, err
}
copy(u[0:4], p[0])
copy(u[4:6], p[1])
copy(u[6:8], p[2])
copy(u[8:10], p[3])
copy(u[10:16], p[4])
return
}
func (u UUID) String() string {
return fmt.Sprintf(format, u[:4], u[4:6], u[6:8], u[8:10], u[10:])
}
// retryOnError tries to detect whether or not retrying would be fruitful.
func retryOnError(err error) bool {
switch err := err.(type) {
case *os.PathError:
return retryOnError(err.Err) // unpack the target error
case syscall.Errno:
if err == syscall.EPERM {
// EPERM represents an entropy pool exhaustion, a condition under
// which we backoff and retry.
return true
}
}
return false
}
0707010000035A000041ED000000000000000000000008645E367C00000000000000000000000000000000000000000000002D00000000elemental-cli-0.3.1/vendor/github.com/docker 0707010000035B000041ED000000000000000000000003645E367C00000000000000000000000000000000000000000000003100000000elemental-cli-0.3.1/vendor/github.com/docker/cli 0707010000035C000081A4000000000000000000000001645E367C00007F05000000000000000000000000000000000000003900000000elemental-cli-0.3.1/vendor/github.com/docker/cli/AUTHORS # File @generated by scripts/docs/generate-authors.sh. DO NOT EDIT.
# This file lists all contributors to the repository.
# See scripts/docs/generate-authors.sh to make modifications.
Aanand Prasad
Aaron L. Xu
Aaron Lehmann
Aaron.L.Xu
Abdur Rehman
Abhinandan Prativadi
Abin Shahab
Abreto FU
Ace Tang
Addam Hardy
Adolfo Ochagavía
Adrian Plata
Adrien Duermael
Adrien Folie
Ahmet Alp Balkan
Aidan Feldman
Aidan Hobson Sayers
AJ Bowen
Akhil Mohan
Akihiro Suda
Akim Demaille
Alan Thompson
Albert Callarisa
Alberto Roura
Albin Kerouanton
Aleksa Sarai
Aleksander Piotrowski
Alessandro Boch
Alex Couture-Beil
Alex Mavrogiannis
Alex Mayer
Alexander Boyd
Alexander Larsson
Alexander Morozov
Alexander Ryabov
Alexandre González
Alexey Igrychev
Alexis Couvreur
Alfred Landrum
Alicia Lauerman
Allen Sun
Alvin Deng
Amen Belayneh
Amey Shrivastava <72866602+AmeyShrivastava@users.noreply.github.com>
Amir Goldstein
Amit Krishnan
Amit Shukla
Amy Lindburg
Anca Iordache
Anda Xu
Andrea Luzzardi
Andreas Köhler
Andres G. Aragoneses
Andres Leon Rangel
Andrew France
Andrew Hsu
Andrew Macpherson
Andrew McDonnell
Andrew Po
Andrey Petrov
Andrii Berehuliak
André Martins
Andy Goldstein
Andy Rothfusz
Anil Madhavapeddy
Ankush Agarwal
Anne Henmi
Anton Polonskiy
Antonio Murdaca
Antonis Kalipetis
Anusha Ragunathan
Ao Li
Arash Deshmeh
Arko Dasgupta
Arnaud Porterie
Arnaud Rebillout
Arthur Peka
Ashwini Oruganti
Azat Khuyiyakhmetov
Bardia Keyoumarsi
Barnaby Gray
Bastiaan Bakker
BastianHofmann
Ben Bodenmiller
Ben Bonnefoy
Ben Creasy
Ben Firshman
Benjamin Boudreau
Benjamin Böhmke
Benjamin Nater
Benoit Sigoure
Bhumika Bayani
Bill Wang
Bin Liu
Bingshen Wang
Bishal Das
Boaz Shuster
Bogdan Anton
Boris Pruessmann
Brad Baker
Bradley Cicenas
Brandon Mitchell
Brandon Philips
Brent Salisbury
Bret Fisher
Brian (bex) Exelbierd
Brian Goff
Brian Wieder
Bruno Sousa
Bryan Bess
Bryan Boreham
Bryan Murphy
bryfry
Cameron Spear
Cao Weiwei
Carlo Mion
Carlos Alexandro Becker
Carlos de Paula
Ce Gao
Cedric Davies
Cezar Sa Espinola
Chad Faragher
Chao Wang
Charles Chan
Charles Law
Charles Smith
Charlie Drage
Charlotte Mach
ChaYoung You
Chee Hau Lim
Chen Chuanliang
Chen Hanxiao
Chen Mingjie
Chen Qiu
Chris Couzens
Chris Gavin
Chris Gibson
Chris McKinnel
Chris Snow
Chris Vermilion
Chris Weyl
Christian Persson
Christian Stefanescu
Christophe Robin
Christophe Vidal
Christopher Biscardi
Christopher Crone
Christopher Jones
Christopher Svensson
Christy Norman
Chun Chen
Clinton Kitson
Coenraad Loubser
Colin Hebert
Collin Guarino