wimlib.h

Go to the documentation of this file.

 
#ifndef _WIMLIB_H
#define _WIMLIB_H
 
#include <stdio.h>
#include <stddef.h>
#ifndef __cplusplus
#  if defined(_MSC_VER) && _MSC_VER < 1800 /* VS pre-2013? */
     typedef unsigned char bool;
#  else
#    include <stdbool.h>
#  endif
#endif
#include <stdint.h>
#include <time.h>
 
#ifdef BUILDING_WIMLIB
  /*
   * On i386, gcc assumes that the stack is 16-byte aligned at function entry.
   * However, some compilers (e.g. MSVC) and programming languages (e.g. Delphi)
   * only guarantee 4-byte alignment when calling functions.  This is mainly an
   * issue on Windows, but it can occur on Linux too.  Work around this ABI
   * incompatibility by realigning the stack pointer when entering the library.
   * This prevents crashes in SSE/AVX code.
   */
#  if defined(__GNUC__) && defined(__i386__)
#    define WIMLIB_ALIGN_STACK  __attribute__((force_align_arg_pointer))
#  else
#    define WIMLIB_ALIGN_STACK
#  endif
#  ifdef _WIN32
#    define WIMLIBAPI __declspec(dllexport) WIMLIB_ALIGN_STACK
#  else
#    define WIMLIBAPI __attribute__((visibility("default"))) WIMLIB_ALIGN_STACK
#  endif
#else
#  define WIMLIBAPI
#endif
 
#define WIMLIB_MAJOR_VERSION 1
 
#define WIMLIB_MINOR_VERSION 14
 
#define WIMLIB_PATCH_VERSION 4
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * To represent file timestamps, wimlib's API originally used the POSIX 'struct
 * timespec'.  This was a mistake because when building wimlib for 32-bit
 * Windows with MinGW we ended up originally using 32-bit time_t which isn't
 * year 2038-safe, and therefore we had to later add fields like
 * 'creation_time_high' to hold the high 32 bits of each timestamp.  Moreover,
 * old Visual Studio versions did not define struct timespec, while newer ones
 * define it but with 64-bit tv_sec.  So to at least avoid a missing or
 * incompatible 'struct timespec' definition, define the correct struct
 * ourselves when this header is included on Windows.
 */
#ifdef _WIN32
struct wimlib_timespec {
    /* Seconds since start of UNIX epoch (January 1, 1970) */
#ifdef _WIN64
    int64_t tv_sec;
#else
    int32_t tv_sec;
#endif
    /* Nanoseconds (0-999999999) */
    int32_t tv_nsec;
};
#else
#  define wimlib_timespec  timespec  /* standard definition */
#endif
 
#ifndef WIMLIB_WIMSTRUCT_DECLARED
typedef struct WIMStruct WIMStruct;
#define WIMLIB_WIMSTRUCT_DECLARED
#endif
 
#ifdef _WIN32
typedef wchar_t wimlib_tchar;
#else
typedef char wimlib_tchar;
#endif
 
#ifdef _WIN32
#  define WIMLIB_WIM_PATH_SEPARATOR '\\'
#  define WIMLIB_WIM_PATH_SEPARATOR_STRING L"\\"
#else
#  define WIMLIB_WIM_PATH_SEPARATOR '/'
#  define WIMLIB_WIM_PATH_SEPARATOR_STRING "/"
#endif
 
#define WIMLIB_WIM_ROOT_PATH WIMLIB_WIM_PATH_SEPARATOR_STRING
 
#define WIMLIB_IS_WIM_ROOT_PATH(path) \
        ((path)[0] == WIMLIB_WIM_PATH_SEPARATOR &&  \
         (path)[1] == 0)
 
#define WIMLIB_GUID_LEN 16
 
enum wimlib_compression_type {
    WIMLIB_COMPRESSION_TYPE_NONE = 0,
 
    WIMLIB_COMPRESSION_TYPE_XPRESS = 1,
 
    WIMLIB_COMPRESSION_TYPE_LZX = 2,
 
    WIMLIB_COMPRESSION_TYPE_LZMS = 3,
};
 
enum wimlib_progress_msg {
 
    WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_BEGIN = 0,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_TREE_BEGIN = 1,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_FILE_STRUCTURE = 3,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_STREAMS = 4,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN = 5,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_METADATA = 6,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_IMAGE_END = 7,
 
    WIMLIB_PROGRESS_MSG_EXTRACT_TREE_END = 8,
 
    WIMLIB_PROGRESS_MSG_SCAN_BEGIN = 9,
 
    WIMLIB_PROGRESS_MSG_SCAN_DENTRY = 10,
 
    WIMLIB_PROGRESS_MSG_SCAN_END = 11,
 
    WIMLIB_PROGRESS_MSG_WRITE_STREAMS = 12,
 
    WIMLIB_PROGRESS_MSG_WRITE_METADATA_BEGIN = 13,
 
    WIMLIB_PROGRESS_MSG_WRITE_METADATA_END = 14,
 
    WIMLIB_PROGRESS_MSG_RENAME = 15,
 
    WIMLIB_PROGRESS_MSG_VERIFY_INTEGRITY = 16,
 
    WIMLIB_PROGRESS_MSG_CALC_INTEGRITY = 17,
 
    WIMLIB_PROGRESS_MSG_SPLIT_BEGIN_PART = 19,
 
    WIMLIB_PROGRESS_MSG_SPLIT_END_PART = 20,
 
    WIMLIB_PROGRESS_MSG_UPDATE_BEGIN_COMMAND = 21,
 
    WIMLIB_PROGRESS_MSG_UPDATE_END_COMMAND = 22,
 
    WIMLIB_PROGRESS_MSG_REPLACE_FILE_IN_WIM = 23,
 
    WIMLIB_PROGRESS_MSG_WIMBOOT_EXCLUDE = 24,
 
    WIMLIB_PROGRESS_MSG_UNMOUNT_BEGIN = 25,
 
    WIMLIB_PROGRESS_MSG_DONE_WITH_FILE = 26,
 
    WIMLIB_PROGRESS_MSG_BEGIN_VERIFY_IMAGE = 27,
 
    WIMLIB_PROGRESS_MSG_END_VERIFY_IMAGE = 28,
 
    WIMLIB_PROGRESS_MSG_VERIFY_STREAMS = 29,
 
    WIMLIB_PROGRESS_MSG_TEST_FILE_EXCLUSION = 30,
 
    WIMLIB_PROGRESS_MSG_HANDLE_ERROR = 31,
};
 
enum wimlib_progress_status {
 
    WIMLIB_PROGRESS_STATUS_CONTINUE = 0,
 
    WIMLIB_PROGRESS_STATUS_ABORT    = 1,
};
 
union wimlib_progress_info {
 
    struct wimlib_progress_info_write_streams {
 
        uint64_t total_bytes;
 
        uint64_t total_streams;
 
        uint64_t completed_bytes;
 
        uint64_t completed_streams;
 
        uint32_t num_threads;
 
        int32_t  compression_type;
 
        uint32_t total_parts;
 
        uint32_t completed_parts;
 
        uint64_t completed_compressed_bytes;
    } write_streams;
 
    struct wimlib_progress_info_scan {
 
        const wimlib_tchar *source;
 
        const wimlib_tchar *cur_path;
 
        enum {
            WIMLIB_SCAN_DENTRY_OK = 0,
 
            WIMLIB_SCAN_DENTRY_EXCLUDED = 1,
 
            WIMLIB_SCAN_DENTRY_UNSUPPORTED = 2,
 
            WIMLIB_SCAN_DENTRY_FIXED_SYMLINK = 3,
 
            WIMLIB_SCAN_DENTRY_NOT_FIXED_SYMLINK = 4,
        } status;
 
        union {
            const wimlib_tchar *wim_target_path;
 
            const wimlib_tchar *symlink_target;
        };
 
        uint64_t num_dirs_scanned;
 
        uint64_t num_nondirs_scanned;
 
        uint64_t num_bytes_scanned;
    } scan;
 
    struct wimlib_progress_info_extract {
 
        uint32_t image;
 
        uint32_t extract_flags;
 
        const wimlib_tchar *wimfile_name;
 
        const wimlib_tchar *image_name;
 
        const wimlib_tchar *target;
 
        const wimlib_tchar *reserved;
 
        uint64_t total_bytes;
 
        uint64_t completed_bytes;
 
        uint64_t total_streams;
 
        uint64_t completed_streams;
 
        uint32_t part_number;
 
        uint32_t total_parts;
 
        uint8_t guid[WIMLIB_GUID_LEN];
 
        uint64_t current_file_count;
 
        uint64_t end_file_count;
    } extract;
 
    struct wimlib_progress_info_rename {
        const wimlib_tchar *from;
 
        const wimlib_tchar *to;
    } rename;
 
    struct wimlib_progress_info_update {
        const struct wimlib_update_command *command;
 
        size_t completed_commands;
 
        size_t total_commands;
    } update;
 
    struct wimlib_progress_info_integrity {
 
        uint64_t total_bytes;
 
        uint64_t completed_bytes;
 
        uint32_t total_chunks;
 
        uint32_t completed_chunks;
 
        uint32_t chunk_size;
 
        const wimlib_tchar *filename;
    } integrity;
 
    struct wimlib_progress_info_split {
        uint64_t total_bytes;
 
        uint64_t completed_bytes;
 
        unsigned cur_part_number;
 
        unsigned total_parts;
 
        wimlib_tchar *part_name;
    } split;
 
    struct wimlib_progress_info_replace {
        const wimlib_tchar *path_in_wim;
    } replace;
 
    struct wimlib_progress_info_wimboot_exclude {
        const wimlib_tchar *path_in_wim;
 
        const wimlib_tchar *extraction_path;
    } wimboot_exclude;
 
    struct wimlib_progress_info_unmount {
        const wimlib_tchar *mountpoint;
 
        const wimlib_tchar *mounted_wim;
 
        uint32_t mounted_image;
 
        uint32_t mount_flags;
 
        uint32_t unmount_flags;
    } unmount;
 
    struct wimlib_progress_info_done_with_file {
        const wimlib_tchar *path_to_file;
    } done_with_file;
 
    struct wimlib_progress_info_verify_image {
        const wimlib_tchar *wimfile;
        uint32_t total_images;
        uint32_t current_image;
    } verify_image;
 
    struct wimlib_progress_info_verify_streams {
        const wimlib_tchar *wimfile;
        uint64_t total_streams;
        uint64_t total_bytes;
        uint64_t completed_streams;
        uint64_t completed_bytes;
    } verify_streams;
 
    struct wimlib_progress_info_test_file_exclusion {
 
        const wimlib_tchar *path;
 
        bool will_exclude;
    } test_file_exclusion;
 
    struct wimlib_progress_info_handle_error {
 
        const wimlib_tchar *path;
 
        int error_code;
 
        bool will_ignore;
    } handle_error;
};
 
typedef enum wimlib_progress_status
    (*wimlib_progress_func_t)(enum wimlib_progress_msg msg_type,
                  union wimlib_progress_info *info,
                  void *progctx);
 
struct wimlib_capture_source {
    wimlib_tchar *fs_source_path;
 
    wimlib_tchar *wim_target_path;
 
    long reserved;
};
 
#define WIMLIB_CHANGE_READONLY_FLAG     0x00000001
 
#define WIMLIB_CHANGE_GUID          0x00000002
 
#define WIMLIB_CHANGE_BOOT_INDEX        0x00000004
 
#define WIMLIB_CHANGE_RPFIX_FLAG        0x00000008
 
struct wimlib_wim_info {
 
    uint8_t guid[WIMLIB_GUID_LEN];
 
    uint32_t image_count;
 
    uint32_t boot_index;
 
    uint32_t wim_version;
 
    uint32_t chunk_size;
 
    uint16_t part_number;
 
    uint16_t total_parts;
 
    int32_t compression_type;
 
    uint64_t total_bytes;
 
    uint32_t has_integrity_table : 1;
 
    uint32_t opened_from_file : 1;
 
    uint32_t is_readonly : 1;
 
    uint32_t has_rpfix : 1;
 
    uint32_t is_marked_readonly : 1;
 
    uint32_t spanned : 1;
 
    uint32_t write_in_progress : 1;
 
    uint32_t metadata_only : 1;
 
    uint32_t resource_only : 1;
 
    uint32_t pipable : 1;
    uint32_t reserved_flags : 22;
    uint32_t reserved[9];
};
 
struct wimlib_resource_entry {
 
    uint64_t uncompressed_size;
 
    uint64_t compressed_size;
 
    uint64_t offset;
 
    uint8_t sha1_hash[20];
 
    uint32_t part_number;
 
    uint32_t reference_count;
 
    uint32_t is_compressed : 1;
 
    uint32_t is_metadata : 1;
 
    uint32_t is_free : 1;
    uint32_t is_spanned : 1;
 
    uint32_t is_missing : 1;
 
    uint32_t packed : 1;
 
    uint32_t reserved_flags : 26;
 
    uint64_t raw_resource_offset_in_wim;
 
    uint64_t raw_resource_compressed_size;
 
    uint64_t raw_resource_uncompressed_size;
 
    uint64_t reserved[1];
};
 
struct wimlib_stream_entry {
 
    const wimlib_tchar *stream_name;
 
    struct wimlib_resource_entry resource;
 
    uint64_t reserved[4];
};
 
struct wimlib_object_id {
    uint8_t object_id[WIMLIB_GUID_LEN];
    uint8_t birth_volume_id[WIMLIB_GUID_LEN];
    uint8_t birth_object_id[WIMLIB_GUID_LEN];
    uint8_t domain_id[WIMLIB_GUID_LEN];
};
 
struct wimlib_dir_entry {
    const wimlib_tchar *filename;
 
    const wimlib_tchar *dos_name;
 
    const wimlib_tchar *full_path;
 
    size_t depth;
 
    const char *security_descriptor;
 
    size_t security_descriptor_size;
 
#define WIMLIB_FILE_ATTRIBUTE_READONLY            0x00000001
#define WIMLIB_FILE_ATTRIBUTE_HIDDEN              0x00000002
#define WIMLIB_FILE_ATTRIBUTE_SYSTEM              0x00000004
#define WIMLIB_FILE_ATTRIBUTE_DIRECTORY           0x00000010
#define WIMLIB_FILE_ATTRIBUTE_ARCHIVE             0x00000020
#define WIMLIB_FILE_ATTRIBUTE_DEVICE              0x00000040
#define WIMLIB_FILE_ATTRIBUTE_NORMAL              0x00000080
#define WIMLIB_FILE_ATTRIBUTE_TEMPORARY           0x00000100
#define WIMLIB_FILE_ATTRIBUTE_SPARSE_FILE         0x00000200
#define WIMLIB_FILE_ATTRIBUTE_REPARSE_POINT       0x00000400
#define WIMLIB_FILE_ATTRIBUTE_COMPRESSED          0x00000800
#define WIMLIB_FILE_ATTRIBUTE_OFFLINE             0x00001000
#define WIMLIB_FILE_ATTRIBUTE_NOT_CONTENT_INDEXED 0x00002000
#define WIMLIB_FILE_ATTRIBUTE_ENCRYPTED           0x00004000
#define WIMLIB_FILE_ATTRIBUTE_VIRTUAL             0x00010000
    uint32_t attributes;
 
#define WIMLIB_REPARSE_TAG_RESERVED_ZERO    0x00000000
#define WIMLIB_REPARSE_TAG_RESERVED_ONE     0x00000001
#define WIMLIB_REPARSE_TAG_MOUNT_POINT      0xA0000003
#define WIMLIB_REPARSE_TAG_HSM          0xC0000004
#define WIMLIB_REPARSE_TAG_HSM2         0x80000006
#define WIMLIB_REPARSE_TAG_DRIVER_EXTENDER  0x80000005
#define WIMLIB_REPARSE_TAG_SIS          0x80000007
#define WIMLIB_REPARSE_TAG_DFS          0x8000000A
#define WIMLIB_REPARSE_TAG_DFSR         0x80000012
#define WIMLIB_REPARSE_TAG_FILTER_MANAGER   0x8000000B
#define WIMLIB_REPARSE_TAG_WOF          0x80000017
#define WIMLIB_REPARSE_TAG_SYMLINK      0xA000000C
    uint32_t reparse_tag;
 
    uint32_t num_links;
 
    uint32_t num_named_streams;
 
    uint64_t hard_link_group_id;
 
    struct wimlib_timespec creation_time;
 
    struct wimlib_timespec last_write_time;
 
    struct wimlib_timespec last_access_time;
 
    uint32_t unix_uid;
 
    uint32_t unix_gid;
 
    uint32_t unix_mode;
 
    uint32_t unix_rdev;
 
    /* The object ID of this file, if any.  Only valid if
     * object_id.object_id is not all zeroes.  */
    struct wimlib_object_id object_id;
 
    int32_t creation_time_high;
 
    int32_t last_write_time_high;
 
    int32_t last_access_time_high;
 
    int32_t reserved2;
 
    uint64_t reserved[4];
 
    struct wimlib_stream_entry streams[];
};
 
typedef int (*wimlib_iterate_dir_tree_callback_t)(const struct wimlib_dir_entry *dentry,
                          void *user_ctx);
 
typedef int (*wimlib_iterate_lookup_table_callback_t)(const struct wimlib_resource_entry *resource,
                              void *user_ctx);
 
#define WIMLIB_ITERATE_DIR_TREE_FLAG_RECURSIVE 0x00000001
 
#define WIMLIB_ITERATE_DIR_TREE_FLAG_CHILDREN  0x00000002
 
#define WIMLIB_ITERATE_DIR_TREE_FLAG_RESOURCES_NEEDED  0x00000004
 
 
#define WIMLIB_ADD_FLAG_NTFS            0x00000001
 
#define WIMLIB_ADD_FLAG_DEREFERENCE     0x00000002
 
#define WIMLIB_ADD_FLAG_VERBOSE         0x00000004
 
#define WIMLIB_ADD_FLAG_BOOT            0x00000008
 
#define WIMLIB_ADD_FLAG_UNIX_DATA       0x00000010
 
#define WIMLIB_ADD_FLAG_NO_ACLS         0x00000020
 
#define WIMLIB_ADD_FLAG_STRICT_ACLS     0x00000040
 
#define WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE     0x00000080
 
#define WIMLIB_ADD_FLAG_RPFIX           0x00000100
 
#define WIMLIB_ADD_FLAG_NORPFIX         0x00000200
 
#define WIMLIB_ADD_FLAG_NO_UNSUPPORTED_EXCLUDE  0x00000400
 
#define WIMLIB_ADD_FLAG_WINCONFIG       0x00000800
 
#define WIMLIB_ADD_FLAG_WIMBOOT         0x00001000
 
#define WIMLIB_ADD_FLAG_NO_REPLACE      0x00002000
 
#define WIMLIB_ADD_FLAG_TEST_FILE_EXCLUSION 0x00004000
 
#define WIMLIB_ADD_FLAG_SNAPSHOT        0x00008000
 
#define WIMLIB_ADD_FLAG_FILE_PATHS_UNNEEDED 0x00010000
 
#define WIMLIB_DELETE_FLAG_FORCE            0x00000001
 
#define WIMLIB_DELETE_FLAG_RECURSIVE            0x00000002
 
#define WIMLIB_EXPORT_FLAG_BOOT             0x00000001
 
#define WIMLIB_EXPORT_FLAG_NO_NAMES         0x00000002
 
#define WIMLIB_EXPORT_FLAG_NO_DESCRIPTIONS      0x00000004
 
#define WIMLIB_EXPORT_FLAG_GIFT             0x00000008
 
#define WIMLIB_EXPORT_FLAG_WIMBOOT          0x00000010
 
#define WIMLIB_EXTRACT_FLAG_NTFS            0x00000001
 
#define WIMLIB_EXTRACT_FLAG_RECOVER_DATA        0x00000002
 
#define WIMLIB_EXTRACT_FLAG_UNIX_DATA           0x00000020
 
#define WIMLIB_EXTRACT_FLAG_NO_ACLS         0x00000040
 
#define WIMLIB_EXTRACT_FLAG_STRICT_ACLS         0x00000080
 
#define WIMLIB_EXTRACT_FLAG_RPFIX           0x00000100
 
#define WIMLIB_EXTRACT_FLAG_NORPFIX         0x00000200
 
#define WIMLIB_EXTRACT_FLAG_TO_STDOUT           0x00000400
 
#define WIMLIB_EXTRACT_FLAG_REPLACE_INVALID_FILENAMES   0x00000800
 
#define WIMLIB_EXTRACT_FLAG_ALL_CASE_CONFLICTS      0x00001000
 
#define WIMLIB_EXTRACT_FLAG_STRICT_TIMESTAMPS       0x00002000
 
#define WIMLIB_EXTRACT_FLAG_STRICT_SHORT_NAMES          0x00004000
 
#define WIMLIB_EXTRACT_FLAG_STRICT_SYMLINKS             0x00008000
 
#define WIMLIB_EXTRACT_FLAG_GLOB_PATHS          0x00040000
 
#define WIMLIB_EXTRACT_FLAG_STRICT_GLOB         0x00080000
 
#define WIMLIB_EXTRACT_FLAG_NO_ATTRIBUTES       0x00100000
 
#define WIMLIB_EXTRACT_FLAG_NO_PRESERVE_DIR_STRUCTURE   0x00200000
 
#define WIMLIB_EXTRACT_FLAG_WIMBOOT         0x00400000
 
#define WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS4K        0x01000000
 
#define WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS8K        0x02000000
 
#define WIMLIB_EXTRACT_FLAG_COMPACT_XPRESS16K       0x04000000
 
#define WIMLIB_EXTRACT_FLAG_COMPACT_LZX         0x08000000
 
#define WIMLIB_MOUNT_FLAG_READWRITE         0x00000001
 
#define WIMLIB_MOUNT_FLAG_DEBUG             0x00000002
 
#define WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_NONE     0x00000004
 
#define WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_XATTR    0x00000008
 
#define WIMLIB_MOUNT_FLAG_STREAM_INTERFACE_WINDOWS  0x00000010
 
#define WIMLIB_MOUNT_FLAG_UNIX_DATA         0x00000020
 
#define WIMLIB_MOUNT_FLAG_ALLOW_OTHER           0x00000040
 
#define WIMLIB_OPEN_FLAG_CHECK_INTEGRITY        0x00000001
 
#define WIMLIB_OPEN_FLAG_ERROR_IF_SPLIT         0x00000002
 
#define WIMLIB_OPEN_FLAG_WRITE_ACCESS           0x00000004
 
#define WIMLIB_UNMOUNT_FLAG_CHECK_INTEGRITY     0x00000001
 
#define WIMLIB_UNMOUNT_FLAG_COMMIT          0x00000002
 
#define WIMLIB_UNMOUNT_FLAG_REBUILD         0x00000004
 
#define WIMLIB_UNMOUNT_FLAG_RECOMPRESS          0x00000008
 
#define WIMLIB_UNMOUNT_FLAG_FORCE           0x00000010
 
#define WIMLIB_UNMOUNT_FLAG_NEW_IMAGE           0x00000020
 
#define WIMLIB_UPDATE_FLAG_SEND_PROGRESS        0x00000001
 
#define WIMLIB_WRITE_FLAG_CHECK_INTEGRITY       0x00000001
 
#define WIMLIB_WRITE_FLAG_NO_CHECK_INTEGRITY        0x00000002
 
#define WIMLIB_WRITE_FLAG_PIPABLE           0x00000004
 
#define WIMLIB_WRITE_FLAG_NOT_PIPABLE           0x00000008
 
#define WIMLIB_WRITE_FLAG_RECOMPRESS            0x00000010
 
#define WIMLIB_WRITE_FLAG_FSYNC             0x00000020
 
#define WIMLIB_WRITE_FLAG_REBUILD           0x00000040
 
#define WIMLIB_WRITE_FLAG_SOFT_DELETE           0x00000080
 
#define WIMLIB_WRITE_FLAG_IGNORE_READONLY_FLAG      0x00000100
 
#define WIMLIB_WRITE_FLAG_SKIP_EXTERNAL_WIMS        0x00000200
 
#define WIMLIB_WRITE_FLAG_STREAMS_OK            0x00000400
 
#define WIMLIB_WRITE_FLAG_RETAIN_GUID           0x00000800
 
#define WIMLIB_WRITE_FLAG_SOLID             0x00001000
 
#define WIMLIB_WRITE_FLAG_SEND_DONE_WITH_FILE_MESSAGES  0x00002000
 
#define WIMLIB_WRITE_FLAG_NO_SOLID_SORT         0x00004000
 
#define WIMLIB_WRITE_FLAG_UNSAFE_COMPACT        0x00008000
 
#define WIMLIB_INIT_FLAG_ASSUME_UTF8            0x00000001
 
#define WIMLIB_INIT_FLAG_DONT_ACQUIRE_PRIVILEGES    0x00000002
 
#define WIMLIB_INIT_FLAG_STRICT_CAPTURE_PRIVILEGES  0x00000004
 
#define WIMLIB_INIT_FLAG_STRICT_APPLY_PRIVILEGES    0x00000008
 
#define WIMLIB_INIT_FLAG_DEFAULT_CASE_SENSITIVE     0x00000010
 
#define WIMLIB_INIT_FLAG_DEFAULT_CASE_INSENSITIVE   0x00000020
 
#define WIMLIB_REF_FLAG_GLOB_ENABLE     0x00000001
 
#define WIMLIB_REF_FLAG_GLOB_ERR_ON_NOMATCH 0x00000002
 
enum wimlib_update_op {
    WIMLIB_UPDATE_OP_ADD = 0,
 
    WIMLIB_UPDATE_OP_DELETE = 1,
 
    WIMLIB_UPDATE_OP_RENAME = 2,
};
 
struct wimlib_add_command {
    wimlib_tchar *fs_source_path;
 
    wimlib_tchar *wim_target_path;
 
    wimlib_tchar *config_file;
 
    int add_flags;
};
 
struct wimlib_delete_command {
 
    wimlib_tchar *wim_path;
 
    int delete_flags;
};
 
struct wimlib_rename_command {
 
    wimlib_tchar *wim_source_path;
 
    wimlib_tchar *wim_target_path;
 
    int rename_flags;
};
 
struct wimlib_update_command {
 
    enum wimlib_update_op op;
 
    union {
        struct wimlib_add_command add;
        struct wimlib_delete_command delete_; /* Underscore is for C++
                             compatibility.  */
        struct wimlib_rename_command rename;
    };
};
 
enum wimlib_error_code {
    WIMLIB_ERR_SUCCESS                            = 0,
    WIMLIB_ERR_ALREADY_LOCKED                     = 1,
    WIMLIB_ERR_DECOMPRESSION                      = 2,
    WIMLIB_ERR_FUSE                               = 6,
    WIMLIB_ERR_GLOB_HAD_NO_MATCHES                = 8,
    WIMLIB_ERR_IMAGE_COUNT                        = 10,
    WIMLIB_ERR_IMAGE_NAME_COLLISION               = 11,
    WIMLIB_ERR_INSUFFICIENT_PRIVILEGES            = 12,
    WIMLIB_ERR_INTEGRITY                          = 13,
    WIMLIB_ERR_INVALID_CAPTURE_CONFIG             = 14,
    WIMLIB_ERR_INVALID_CHUNK_SIZE                 = 15,
    WIMLIB_ERR_INVALID_COMPRESSION_TYPE           = 16,
    WIMLIB_ERR_INVALID_HEADER                     = 17,
    WIMLIB_ERR_INVALID_IMAGE                      = 18,
    WIMLIB_ERR_INVALID_INTEGRITY_TABLE            = 19,
    WIMLIB_ERR_INVALID_LOOKUP_TABLE_ENTRY         = 20,
    WIMLIB_ERR_INVALID_METADATA_RESOURCE          = 21,
    WIMLIB_ERR_INVALID_OVERLAY                    = 23,
    WIMLIB_ERR_INVALID_PARAM                      = 24,
    WIMLIB_ERR_INVALID_PART_NUMBER                = 25,
    WIMLIB_ERR_INVALID_PIPABLE_WIM                = 26,
    WIMLIB_ERR_INVALID_REPARSE_DATA               = 27,
    WIMLIB_ERR_INVALID_RESOURCE_HASH              = 28,
    WIMLIB_ERR_INVALID_UTF16_STRING               = 30,
    WIMLIB_ERR_INVALID_UTF8_STRING                = 31,
    WIMLIB_ERR_IS_DIRECTORY                       = 32,
    WIMLIB_ERR_IS_SPLIT_WIM                       = 33,
    WIMLIB_ERR_LINK                               = 35,
    WIMLIB_ERR_METADATA_NOT_FOUND                 = 36,
    WIMLIB_ERR_MKDIR                              = 37,
    WIMLIB_ERR_MQUEUE                             = 38,
    WIMLIB_ERR_NOMEM                              = 39,
    WIMLIB_ERR_NOTDIR                             = 40,
    WIMLIB_ERR_NOTEMPTY                           = 41,
    WIMLIB_ERR_NOT_A_REGULAR_FILE                 = 42,
    WIMLIB_ERR_NOT_A_WIM_FILE                     = 43,
    WIMLIB_ERR_NOT_PIPABLE                        = 44,
    WIMLIB_ERR_NO_FILENAME                        = 45,
    WIMLIB_ERR_NTFS_3G                            = 46,
    WIMLIB_ERR_OPEN                               = 47,
    WIMLIB_ERR_OPENDIR                            = 48,
    WIMLIB_ERR_PATH_DOES_NOT_EXIST                = 49,
    WIMLIB_ERR_READ                               = 50,
    WIMLIB_ERR_READLINK                           = 51,
    WIMLIB_ERR_RENAME                             = 52,
    WIMLIB_ERR_REPARSE_POINT_FIXUP_FAILED         = 54,
    WIMLIB_ERR_RESOURCE_NOT_FOUND                 = 55,
    WIMLIB_ERR_RESOURCE_ORDER                     = 56,
    WIMLIB_ERR_SET_ATTRIBUTES                     = 57,
    WIMLIB_ERR_SET_REPARSE_DATA                   = 58,
    WIMLIB_ERR_SET_SECURITY                       = 59,
    WIMLIB_ERR_SET_SHORT_NAME                     = 60,
    WIMLIB_ERR_SET_TIMESTAMPS                     = 61,
    WIMLIB_ERR_SPLIT_INVALID                      = 62,
    WIMLIB_ERR_STAT                               = 63,
    WIMLIB_ERR_UNEXPECTED_END_OF_FILE             = 65,
    WIMLIB_ERR_UNICODE_STRING_NOT_REPRESENTABLE   = 66,
    WIMLIB_ERR_UNKNOWN_VERSION                    = 67,
    WIMLIB_ERR_UNSUPPORTED                        = 68,
    WIMLIB_ERR_UNSUPPORTED_FILE                   = 69,
    WIMLIB_ERR_WIM_IS_READONLY                    = 71,
    WIMLIB_ERR_WRITE                              = 72,
    WIMLIB_ERR_XML                                = 73,
    WIMLIB_ERR_WIM_IS_ENCRYPTED                   = 74,
    WIMLIB_ERR_WIMBOOT                            = 75,
    WIMLIB_ERR_ABORTED_BY_PROGRESS                = 76,
    WIMLIB_ERR_UNKNOWN_PROGRESS_STATUS            = 77,
    WIMLIB_ERR_MKNOD                              = 78,
    WIMLIB_ERR_MOUNTED_IMAGE_IS_BUSY              = 79,
    WIMLIB_ERR_NOT_A_MOUNTPOINT                   = 80,
    WIMLIB_ERR_NOT_PERMITTED_TO_UNMOUNT           = 81,
    WIMLIB_ERR_FVE_LOCKED_VOLUME                  = 82,
    WIMLIB_ERR_UNABLE_TO_READ_CAPTURE_CONFIG      = 83,
    WIMLIB_ERR_WIM_IS_INCOMPLETE                  = 84,
    WIMLIB_ERR_COMPACTION_NOT_POSSIBLE            = 85,
    WIMLIB_ERR_IMAGE_HAS_MULTIPLE_REFERENCES      = 86,
    WIMLIB_ERR_DUPLICATE_EXPORTED_IMAGE           = 87,
    WIMLIB_ERR_CONCURRENT_MODIFICATION_DETECTED   = 88,
    WIMLIB_ERR_SNAPSHOT_FAILURE                   = 89,
    WIMLIB_ERR_INVALID_XATTR                      = 90,
    WIMLIB_ERR_SET_XATTR                          = 91,
};
 
 
#define WIMLIB_NO_IMAGE     0
 
#define WIMLIB_ALL_IMAGES   (-1)
 
WIMLIBAPI int
wimlib_add_empty_image(WIMStruct *wim,
               const wimlib_tchar *name,
               int *new_idx_ret);
 
WIMLIBAPI int
wimlib_add_image(WIMStruct *wim,
         const wimlib_tchar *source,
         const wimlib_tchar *name,
         const wimlib_tchar *config_file,
         int add_flags);
 
WIMLIBAPI int
wimlib_add_image_multisource(WIMStruct *wim,
                 const struct wimlib_capture_source *sources,
                 size_t num_sources,
                 const wimlib_tchar *name,
                 const wimlib_tchar *config_file,
                 int add_flags);
 
WIMLIBAPI int
wimlib_add_tree(WIMStruct *wim, int image,
        const wimlib_tchar *fs_source_path,
        const wimlib_tchar *wim_target_path, int add_flags);
 
WIMLIBAPI int
wimlib_create_new_wim(enum wimlib_compression_type ctype, WIMStruct **wim_ret);
 
WIMLIBAPI int
wimlib_delete_image(WIMStruct *wim, int image);
 
WIMLIBAPI int
wimlib_delete_path(WIMStruct *wim, int image,
           const wimlib_tchar *path, int delete_flags);
 
WIMLIBAPI int
wimlib_export_image(WIMStruct *src_wim, int src_image,
            WIMStruct *dest_wim,
            const wimlib_tchar *dest_name,
            const wimlib_tchar *dest_description,
            int export_flags);
 
WIMLIBAPI int
wimlib_extract_image(WIMStruct *wim, int image,
             const wimlib_tchar *target, int extract_flags);
 
WIMLIBAPI int
wimlib_extract_image_from_pipe(int pipe_fd,
                   const wimlib_tchar *image_num_or_name,
                   const wimlib_tchar *target, int extract_flags);
 
WIMLIBAPI int
wimlib_extract_image_from_pipe_with_progress(int pipe_fd,
                         const wimlib_tchar *image_num_or_name,
                         const wimlib_tchar *target,
                         int extract_flags,
                         wimlib_progress_func_t progfunc,
                         void *progctx);
 
WIMLIBAPI int
wimlib_extract_pathlist(WIMStruct *wim, int image,
            const wimlib_tchar *target,
            const wimlib_tchar *path_list_file,
            int extract_flags);
 
WIMLIBAPI int
wimlib_extract_paths(WIMStruct *wim,
             int image,
             const wimlib_tchar *target,
             const wimlib_tchar * const *paths,
             size_t num_paths,
             int extract_flags);
 
WIMLIBAPI int
wimlib_extract_xml_data(WIMStruct *wim, FILE *fp);
 
WIMLIBAPI void
wimlib_free(WIMStruct *wim);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_compression_type_string(enum wimlib_compression_type ctype);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_error_string(enum wimlib_error_code code);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_image_description(const WIMStruct *wim, int image);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_image_name(const WIMStruct *wim, int image);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_image_property(const WIMStruct *wim, int image,
              const wimlib_tchar *property_name);
 
WIMLIBAPI uint32_t
wimlib_get_version(void);
 
WIMLIBAPI const wimlib_tchar *
wimlib_get_version_string(void);
 
WIMLIBAPI int
wimlib_get_wim_info(WIMStruct *wim, struct wimlib_wim_info *info);
 
WIMLIBAPI int
wimlib_get_xml_data(WIMStruct *wim, void **buf_ret, size_t *bufsize_ret);
 
WIMLIBAPI int
wimlib_global_init(int init_flags);
 
WIMLIBAPI void
wimlib_global_cleanup(void);
 
WIMLIBAPI bool
wimlib_image_name_in_use(const WIMStruct *wim, const wimlib_tchar *name);
 
WIMLIBAPI int
wimlib_iterate_dir_tree(WIMStruct *wim, int image, const wimlib_tchar *path,
            int flags,
            wimlib_iterate_dir_tree_callback_t cb, void *user_ctx);
 
WIMLIBAPI int
wimlib_iterate_lookup_table(WIMStruct *wim, int flags,
                wimlib_iterate_lookup_table_callback_t cb,
                void *user_ctx);
 
WIMLIBAPI int
wimlib_join(const wimlib_tchar * const *swms,
        unsigned num_swms,
        const wimlib_tchar *output_path,
        int swm_open_flags,
        int wim_write_flags);
 
WIMLIBAPI int
wimlib_join_with_progress(const wimlib_tchar * const *swms,
              unsigned num_swms,
              const wimlib_tchar *output_path,
              int swm_open_flags,
              int wim_write_flags,
              wimlib_progress_func_t progfunc,
              void *progctx);
 
WIMLIBAPI int
wimlib_load_text_file(const wimlib_tchar *path,
              wimlib_tchar **tstr_ret, size_t *tstr_nchars_ret);
 
WIMLIBAPI int
wimlib_mount_image(WIMStruct *wim,
           int image,
           const wimlib_tchar *dir,
           int mount_flags,
           const wimlib_tchar *staging_dir);
 
WIMLIBAPI int
wimlib_open_wim(const wimlib_tchar *wim_file,
        int open_flags,
        WIMStruct **wim_ret);
 
WIMLIBAPI int
wimlib_open_wim_with_progress(const wimlib_tchar *wim_file,
                  int open_flags,
                  WIMStruct **wim_ret,
                  wimlib_progress_func_t progfunc,
                  void *progctx);
 
WIMLIBAPI int
wimlib_overwrite(WIMStruct *wim, int write_flags, unsigned num_threads);
 
WIMLIBAPI void
wimlib_print_available_images(const WIMStruct *wim, int image);
 
WIMLIBAPI void
wimlib_print_header(const WIMStruct *wim);
 
WIMLIBAPI int
wimlib_reference_resource_files(WIMStruct *wim,
                const wimlib_tchar * const *resource_wimfiles_or_globs,
                unsigned count,
                int ref_flags,
                int open_flags);
 
WIMLIBAPI int
wimlib_reference_resources(WIMStruct *wim, WIMStruct **resource_wims,
               unsigned num_resource_wims, int ref_flags);
 
WIMLIBAPI int
wimlib_reference_template_image(WIMStruct *wim, int new_image,
                WIMStruct *template_wim, int template_image,
                int flags);
 
WIMLIBAPI void
wimlib_register_progress_function(WIMStruct *wim,
                  wimlib_progress_func_t progfunc,
                  void *progctx);
 
WIMLIBAPI int
wimlib_rename_path(WIMStruct *wim, int image,
           const wimlib_tchar *source_path, const wimlib_tchar *dest_path);
 
WIMLIBAPI int
wimlib_resolve_image(WIMStruct *wim,
             const wimlib_tchar *image_name_or_num);
 
WIMLIBAPI int
wimlib_set_error_file(FILE *fp);
 
WIMLIBAPI int
wimlib_set_error_file_by_name(const wimlib_tchar *path);
 
WIMLIBAPI int
wimlib_set_image_descripton(WIMStruct *wim, int image,
                const wimlib_tchar *description);
 
WIMLIBAPI int
wimlib_set_image_flags(WIMStruct *wim, int image, const wimlib_tchar *flags);
 
WIMLIBAPI int
wimlib_set_image_name(WIMStruct *wim, int image, const wimlib_tchar *name);
 
WIMLIBAPI int
wimlib_set_image_property(WIMStruct *wim, int image,
              const wimlib_tchar *property_name,
              const wimlib_tchar *property_value);
 
WIMLIBAPI int
wimlib_set_memory_allocator(void *(*malloc_func)(size_t),
                void (*free_func)(void *),
                void *(*realloc_func)(void *, size_t));
 
WIMLIBAPI int
wimlib_set_output_chunk_size(WIMStruct *wim, uint32_t chunk_size);
 
WIMLIBAPI int
wimlib_set_output_pack_chunk_size(WIMStruct *wim, uint32_t chunk_size);
 
WIMLIBAPI int
wimlib_set_output_compression_type(WIMStruct *wim,
                   enum wimlib_compression_type ctype);
 
WIMLIBAPI int
wimlib_set_output_pack_compression_type(WIMStruct *wim,
                    enum wimlib_compression_type ctype);
 
WIMLIBAPI int
wimlib_set_print_errors(bool show_messages);
 
WIMLIBAPI int
wimlib_set_wim_info(WIMStruct *wim, const struct wimlib_wim_info *info,
            int which);
 
WIMLIBAPI int
wimlib_split(WIMStruct *wim,
         const wimlib_tchar *swm_name,
         uint64_t part_size,
         int write_flags);
 
WIMLIBAPI int
wimlib_verify_wim(WIMStruct *wim, int verify_flags);
 
WIMLIBAPI int
wimlib_unmount_image(const wimlib_tchar *dir, int unmount_flags);
 
WIMLIBAPI int
wimlib_unmount_image_with_progress(const wimlib_tchar *dir,
                   int unmount_flags,
                   wimlib_progress_func_t progfunc,
                   void *progctx);
 
WIMLIBAPI int
wimlib_update_image(WIMStruct *wim,
            int image,
            const struct wimlib_update_command *cmds,
            size_t num_cmds,
            int update_flags);
 
WIMLIBAPI int
wimlib_write(WIMStruct *wim,
         const wimlib_tchar *path,
         int image,
         int write_flags,
         unsigned num_threads);
 
WIMLIBAPI int
wimlib_write_to_fd(WIMStruct *wim,
           int fd,
           int image,
           int write_flags,
           unsigned num_threads);
 
struct wimlib_compressor;
 
struct wimlib_decompressor;
 
WIMLIBAPI int
wimlib_set_default_compression_level(int ctype, unsigned int compression_level);
 
WIMLIBAPI uint64_t
wimlib_get_compressor_needed_memory(enum wimlib_compression_type ctype,
                    size_t max_block_size,
                    unsigned int compression_level);
 
#define WIMLIB_COMPRESSOR_FLAG_DESTRUCTIVE  0x80000000
 
WIMLIBAPI int
wimlib_create_compressor(enum wimlib_compression_type ctype,
             size_t max_block_size,
             unsigned int compression_level,
             struct wimlib_compressor **compressor_ret);
 
WIMLIBAPI size_t
wimlib_compress(const void *uncompressed_data, size_t uncompressed_size,
        void *compressed_data, size_t compressed_size_avail,
        struct wimlib_compressor *compressor);
 
WIMLIBAPI void
wimlib_free_compressor(struct wimlib_compressor *compressor);
 
WIMLIBAPI int
wimlib_create_decompressor(enum wimlib_compression_type ctype,
               size_t max_block_size,
               struct wimlib_decompressor **decompressor_ret);
 
WIMLIBAPI int
wimlib_decompress(const void *compressed_data, size_t compressed_size,
          void *uncompressed_data, size_t uncompressed_size,
          struct wimlib_decompressor *decompressor);
 
WIMLIBAPI void
wimlib_free_decompressor(struct wimlib_decompressor *decompressor);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* _WIMLIB_H */