ddn.lib.dar

Compression algorithm enum (mirrors libdar::compression).

Hash/checksum algorithm used for sidecar files during archive creation.

This enum corresponds to the shim's dar_hash_algo values and controls which .sha256/.sha1/etc. sidecar file is produced for the first slice.

Crypto algorithm enum (mirrors libdar::crypto_algo).

Used to specify the encryption algorithm for archive creation and reading.

Low-level list entry structure matching the C shim's dar_list_entry. Extended with ownership, timestamps, compression, and attribute flags.

Function type for calculating signature block length based on file size.

Callback type for warning/info messages from libdar.

Callback type for file treatment progress (file being processed).

Callback type for displaying messages (user_interaction version, non-@nogc).

Callback type for yes/no questions (pause).

Callback type to get a string answer from the user.

Callback type to get a secure string answer from the user (for passwords/secrets).

Opaque user interaction handle for full libdar user_interaction support.

Mask types corresponding to libdar mask classes.

Secure password container that avoids GC copies and zeroizes memory on destruction.

This type allocates a C buffer to hold the password bytes, exposes a pointer for FFI, and wipes the memory before freeing it.

Canonical error codes returned by the shim functions.

Values mirror common conditions and map to specific libdar exception types. Zero means success.

Exception thrown by low-level binding upon shim errors. Serves as a base class for more specific DAR exceptions.

Enhanced with context fields that help diagnose failures.

Base class for argument-related errors (invalid/null parameters).

Invalid state or handle misuse.

Generic catch-all error.

I/O related error (open/create/write failures).

Out-of-memory condition reported by libdar (Ememory).

Range error (Erange) — value out of expected range.

Feature not available (Efeature) — requested feature not compiled in or supported.

Hardware error (Ehardware) — disk or device failure.

User abort (Euser_abort) — operation cancelled by user.

Data error (Edata) — data corruption or integrity failure.

Compilation mismatch (Ecompilation) — library/application version incompatibility.

System error (Esystem) — OS-level error.

Network authentication error (Enet_auth) — remote authentication failure.

Internal bug (Ebug) — should not happen, indicates a bug in libdar.

Thread cancellation (Ethread_cancel) — operation cancelled due to thread termination.

Infinint arithmetic error (Einfinint) — arbitrary precision integer error.

Limited integer overflow (Elimitint) — integer overflow in limited precision mode.

Script execution error (Escript) — error executing user script/hook.

Opaque archive handle with destructor that calls the shim destroy function. Implemented as a class to avoid accidental double-destruction due to struct copying.

Entry type for archive listings.

Complete set of entry types matching libdar's internal representation. These correspond to the type characters used by libdar internally:

• 'f' = FILE (regular file)
• 'd' = DIR (directory)
• 'l' = SYMLINK (symbolic link)
• 'c' = CHAR_DEVICE (character device)
• 'b' = BLOCK_DEVICE (block device)
• 's' = UNIX_SOCKET (Unix domain socket)
• 'p' = NAMED_PIPE (named pipe / FIFO)
• 'o' = DOOR (Solaris-specific door)
• 'x' = REMOVED (removed entry marker in incremental archives)

D-side list entry used by callbacks and helpers.

Extended with ownership, timestamps, compression, and attribute flags.

Result of comparing two archives.

Enhanced diff result counters.

Change detection policy for incremental backups.

Incremental backup mode.

IncrementalOptions controls how incremental/differential backups are created.

This class is a RAII wrapper over the shim incremental options and lets you define a reference archive, change detection policy, snapshot file, and the desired incremental mode.

Diff difference kinds

Result of testing (verifying) an archive.

TestOptions controls archive integrity testing behavior.

This class mirrors a subset of libdar's archive_options_test allowing you to select what to check and which entries to include in testing.

Example:

auto ro = ReadOptions.create();
ro.setExtension("dar");
auto h = openArchiveRead(outDir, "sample", "dar", ro);

auto to = TestOptions.create();
to.setCompareData(true);
to.addInclude("a.txt"); // only test a.txt
auto res = testArchive(h, to);
assert(res.filesChecked == 1);

Archive summary containing metadata about an archive.

This struct provides information about the archive's structure, size, compression, encryption, and other properties. Obtain it via getArchiveSummary().

Operation statistics containing counters from archive operations.

This struct provides detailed statistics about files processed during backup, extraction, or test operations. Obtain it via the *WithStats variants of archive functions.

All fields are cumulative counters representing the number of items or bytes processed during the operation.

MergeOptions RAII wrapper mapping to shim merge options.

Represents an entry in the database listing.

Opaque database handle with destructor calling the shim destroy function.

RAII wrapper around xform handle.

ReadOptions RAII wrapper for minimal read options in the shim.

DiffOptions RAII wrapper controlling comparison behavior.

ExtractOptions RAII wrapper mapping to libdar::archive_options_extract.

IsolateOptions RAII wrapper mapping to libdar::archive_options_isolate.

RepairOptions RAII wrapper mapping to repair options for xform-based repair. Supports overwrite policy, slicing parameters, slice permission and ownership.

CreateOptions RAII wrapper for minimal create options in the shim.

FilterOptions RAII wrapper for file filtering during archive operations.

Supports include/exclude glob patterns for filenames and paths, as well as size-based filtering. Use with createArchiveFiltered() to create archives that only include files matching the specified criteria.

Example:

auto fo = FilterOptions.create();
fo.addInclude("*.txt");        // Include all .txt files
fo.addInclude("*.md");         // Also include .md files
fo.addExclude("*.bak");        // Exclude backup files
fo.addExcludePath("cache");    // Exclude cache directories

auto co = CreateOptions.create();
auto arc = createArchiveFiltered("/home/user", "/backups", "docs", "dar", co, fo);

DarSlave: RAII wrapper for remote archive serving via pipes.

The dar_slave feature enables serving archive data through pipes for remote/network archive access. A slave process reads orders from an input pipe and sends archive data through an output pipe to a dar master process.

This is useful for:

• Network archive access (archive on remote machine, dar on local)
• Tape/sequential media access
• Privilege separation (archive reader with different permissions)

Example:

// Create slave using named pipes
auto slave = DarSlave.create("/archives", "backup", "dar", "input_fifo", "output_fifo");
// Run blocks until master disconnects
slave.run();

Mask: RAII wrapper for libdar's mask class hierarchy.

Masks are used to filter files during archive operations. This class provides access to libdar's complete mask class hierarchy including:

• bool_mask — always true or always false
• simple_mask — glob patterns (shell wildcards like *.txt)
• regular_mask — POSIX regular expressions
• not_mask — negation of another mask
• et_mask — AND combination of multiple masks
• ou_mask — OR combination of multiple masks
• simple_path_mask — path-based matching (subdir relationships)
• same_path_mask — exact path matching
• exclude_dir_mask — directory exclusion

Example:

// Create a glob mask for .txt files
auto txtMask = Mask.glob("*.txt");
assert(txtMask.isCovered("file.txt"));
assert(!txtMask.isCovered("file.doc"));

// Create an OR combination
auto orMask = Mask.orMask();
orMask.add(Mask.glob("*.txt"));
orMask.add(Mask.glob("*.md"));
assert(orMask.isCovered("readme.md"));

// Create a NOT mask
auto notBak = Mask.notMask(Mask.glob("*.bak"));
assert(notBak.isCovered("file.txt"));
assert(!notBak.isCovered("file.bak"));

UserInteractionHandle: RAII wrapper for libdar's user_interaction class.

This class provides access to libdar's full user interaction mechanism, allowing custom implementations of all user interaction methods:

• message — display information/warning messages
• pause — ask yes/no questions
• getString — prompt for arbitrary string input
• getSecuString — prompt for sensitive input like passwords

Example:

// Create a blind user interaction (non-interactive)
auto ui = UserInteractionHandle.createBlind();
assert(ui.isValid);

// Create with custom callbacks (for interactive applications)
extern(C) void myMessage(const char* msg, void* ctx) nothrow { /+ display msg +/ }
extern(C) int myPause(const char* msg, void* ctx) nothrow { return 0; /+ no +/ }
extern(C) char* myGetString(const char* msg, int echo, void* ctx) nothrow { return null; }
extern(C) char* myGetSecuString(const char* msg, int echo, void* ctx) nothrow { return null; }

auto customUI = UserInteractionHandle.create(&myMessage, &myPause, &myGetString, &myGetSecuString, null);