rardecode

By default, rardecode uses the standard OS filesystem. You can provide a custom fs.FS implementation using the FileSystem option. This is useful if your RAR volumes are stored in memory, in a cloud bucket, or within a virtual filesystem.

Note: The provided fs.FS must be able to resolve the paths constructed by the volumeManager (which combines the directory and the volume filename).

// Example using a custom filesystem
myFS := myCustomFSImplementation{}
opts := []rardecode.Option{
    rardecode.FileSystem(myFS),
}

When using RarFS.ReadFile(name), the library enforces a maximum file size to prevent excessive memory consumption. If the file being read is larger than the configured limit, the method returns ErrFileTooLargeForReadFile.

To increase this limit, you must configure the MaxReadFileSize() option when calling OpenFS.

var ErrFileTooLargeForReadFile = errors.New("rardecode: file too large for ReadFile")

For non-solid files, you can call Open() on a File object (obtained via List) to get an io.ReadCloser for the file's contents.

Warning: Open() is not supported for Solid files because their contents depend on the decoding of preceding files. To access contents of Solid files, use OpenReader and iterate using Next().

files, _ := rardecode.List("archive.rar")
for _, f := range files {
    if !f.Solid {
        rc, err := f.Open()
        if err != nil {
            // handle error
        }
        // Read from rc...
        rc.Close()
    }
}

Use List to retrieve a slice of *File objects representing all files within a RAR archive specified by name. This is useful for inspecting archive contents without manually iterating through the reader.

files, err := rardecode.List("archive.rar")
if err != nil {
    // handle error
}
for _, f := range files {
    fmt.Println(f.Name)
}

Use NewReader to create a Reader for sequential access to files in a single-volume RAR archive. Note that NewReader does not support multi-volume archives; for multi-volume support, use OpenReader instead.

// r is an io.Reader containing the RAR archive data
rdr, err := rardecode.NewReader(r)
if err != nil {
    // handle error
}
// Use rdr.Next() to iterate through files

Use OpenReader to open a RAR archive specified by its name. This returns a ReadCloser, which supports multi-volume archives and allows you to close the underlying resources. Use the Volumes() method on the returned ReadCloser to see which volume filenames have been used during decoding.

// name is the path to the RAR file
rc, err := rardecode.OpenReader("archive.rar")
if err != nil {
    // handle error
}
defer rc.Close()

// Access volumes used so far
volumes := rc.Volumes()

The Sub(dir string) (fs.FS, error) method returns a new fs.FS that is rooted at the specified directory. This is useful for scoping operations to a specific subdirectory within the RAR archive.

subFS, err := rfs.Sub("folder/subfolder")
if err != nil {
    log.Fatal(err)
}
// subFS is now rooted at "folder/subfolder"

Use OpenFS to create a RarFS instance, which implements the standard Go io/fs.FS interface. This allows you to interact with the contents of a RAR archive using standard library filesystem functions. You can pass optional Option arguments to configure the opening process.

Returns a pointer to RarFS or an error if the archive cannot be opened or parsed.

fs, err := rardecode.OpenFS("archive.rar")
if err != nil {
    log.Fatal(err)
}
// Use fs as a standard io/fs.FS

The following constants define the Host Operating System and Link Types used in FileHeader.

// HostOS types
const (
	HostOSUnknown = 0
	HostOSMSDOS   = 1
	HostOSOS2     = 2
	HostOSWindows = 3
	HostOSUnix    = 4
	HostOSMacOS   = 5
	HostOSBeOS    = 6
)

// Link types
const (
	LinkTypeNone            = 0
	LinkTypeUnixSymlink     = 1
	LinkTypeWindowsSymlink  = 2
	LinkTypeWindowsJunction = 3
	LinkTypeHardLink        = 4
	LinkTypeFileCopy        = 5
)