include/wimlib/error.h \
include/wimlib/file_io.h \
include/wimlib/glob.h \
+ include/wimlib/guid.h \
include/wimlib/hc_matchfinder.h \
include/wimlib/header.h \
include/wimlib/inode.h \
--- /dev/null
+/*
+ * guid.h
+ *
+ * Utility functions for handling 16-byte globally unique identifiers (GUIDs).
+ */
+
+#ifndef _WIMLIB_GUID_H
+#define _WIMLIB_GUID_H
+
+#include <string.h>
+
+#include "wimlib/util.h"
+
+#define GUID_SIZE 16
+
+static inline void
+copy_guid(u8 dest[GUID_SIZE], const u8 src[GUID_SIZE])
+{
+ memcpy(dest, src, GUID_SIZE);
+}
+
+static inline int
+cmp_guids(const u8 guid1[GUID_SIZE], const u8 guid2[GUID_SIZE])
+{
+ return memcmp(guid1, guid2, GUID_SIZE);
+}
+
+static inline bool
+guids_equal(const u8 guid1[GUID_SIZE], const u8 guid2[GUID_SIZE])
+{
+ return !cmp_guids(guid1, guid2);
+}
+
+static inline void
+generate_guid(u8 guid[GUID_SIZE])
+{
+ return randomize_byte_array(guid, GUID_SIZE);
+}
+
+#endif /* _WIMLIB_GUID_H */
#include <limits.h>
+#include "wimlib/guid.h"
#include "wimlib/resource.h"
#include "wimlib/types.h"
-/* Length of "Globally Unique ID" field in WIM header. */
-#define WIM_GUID_LEN 16
-
/* Length of the WIM header on disk. wimlib currently requires that the header
* be exactly this size. */
#define WIM_HEADER_DISK_SIZE 208
/* +0x18: Globally unique identifier for the WIM file. Basically a
* bunch of random bytes. */
- u8 guid[WIM_GUID_LEN];
+ u8 guid[GUID_SIZE];
/* +0x28: Number of this WIM part in the split WIM file, indexed from 1,
* or 1 if the WIM is not split. */
u32 wim_version;
u32 flags;
u32 chunk_size;
- u8 guid[WIM_GUID_LEN];
+ u8 guid[GUID_SIZE];
u16 part_number;
u16 total_parts;
u32 image_count;
extern int
wimboot_alloc_data_source_id(const wchar_t *wim_path,
- const u8 guid[WIM_GUID_LEN], int image,
+ const u8 guid[GUID_SIZE], int image,
const wchar_t *target, u64 *data_source_id_ret,
bool *wof_running_ret);
/* Different (possibly split) WIMs? */
if (wim1 != wim2) {
- v = memcmp(wim1->hdr.guid, wim2->hdr.guid, WIM_GUID_LEN);
+ v = cmp_guids(wim1->hdr.guid, wim2->hdr.guid);
if (v)
return v;
}
struct wim_resource_descriptor rdesc;
struct blob_descriptor *blob;
- memcpy(ctx->progress.extract.guid, ctx->wim->hdr.guid, WIM_GUID_LEN);
+ copy_guid(ctx->progress.extract.guid, ctx->wim->hdr.guid);
ctx->progress.extract.part_number = ctx->wim->hdr.part_number;
ctx->progress.extract.total_parts = ctx->wim->hdr.total_parts;
ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
if (part_number == ctx->progress.extract.part_number &&
total_parts == ctx->progress.extract.total_parts &&
- !memcmp(pwm_hdr.guid, ctx->progress.extract.guid, WIM_GUID_LEN))
+ guids_equal(pwm_hdr.guid, ctx->progress.extract.guid))
continue;
- memcpy(ctx->progress.extract.guid, pwm_hdr.guid, WIM_GUID_LEN);
+ copy_guid(ctx->progress.extract.guid, pwm_hdr.guid);
ctx->progress.extract.part_number = part_number;
ctx->progress.extract.total_parts = total_parts;
ret = extract_progress(ctx, WIMLIB_PROGRESS_MSG_EXTRACT_SPWM_PART_BEGIN);
hdr->flags = le32_to_cpu(disk_hdr.wim_flags);
hdr->chunk_size = le32_to_cpu(disk_hdr.chunk_size);
- memcpy(hdr->guid, disk_hdr.guid, WIM_GUID_LEN);
+ copy_guid(hdr->guid, disk_hdr.guid);
hdr->part_number = le16_to_cpu(disk_hdr.part_number);
hdr->total_parts = le16_to_cpu(disk_hdr.total_parts);
disk_hdr.wim_version = cpu_to_le32(hdr->wim_version);
disk_hdr.wim_flags = cpu_to_le32(hdr->flags);
disk_hdr.chunk_size = cpu_to_le32(hdr->chunk_size);
- memcpy(disk_hdr.guid, hdr->guid, WIM_GUID_LEN);
+ copy_guid(disk_hdr.guid, hdr->guid);
disk_hdr.part_number = cpu_to_le16(hdr->part_number);
disk_hdr.total_parts = cpu_to_le16(hdr->total_parts);
disk_hdr.image_count = cpu_to_le32(hdr->image_count);
tprintf(T("Chunk Size = %u\n"), hdr->chunk_size);
tfputs (T("GUID = "), stdout);
- print_byte_field(hdr->guid, WIM_GUID_LEN, stdout);
+ print_byte_field(hdr->guid, GUID_SIZE, stdout);
tputchar(T('\n'));
tprintf(T("Part Number = %hu\n"), hdr->part_number);
tprintf(T("Total Parts = %hu\n"), hdr->total_parts);
"chunk size");
return WIMLIB_ERR_SPLIT_INVALID;
}
- if (memcmp(guid, swm->hdr.guid, WIM_GUID_LEN) != 0) {
+ if (!guids_equal(guid, swm->hdr.guid)) {
ERROR("The split WIMs do not all have the same "
"GUID");
return WIMLIB_ERR_SPLIT_INVALID;
union wimlib_progress_info progress;
unsigned part_number;
int ret;
- u8 guid[WIMLIB_GUID_LEN];
+ u8 guid[GUID_SIZE];
swm_name_len = tstrlen(swm_name);
swm_name_buf = alloca((swm_name_len + 20) * sizeof(tchar));
progress.split.total_bytes += swm_info->parts[part_number - 1].size;
progress.split.total_parts = swm_info->num_parts;
- randomize_byte_array(guid, WIMLIB_GUID_LEN);
+ generate_guid(guid);
for (part_number = 1; part_number <= swm_info->num_parts; part_number++) {
int part_write_flags;
wim->hdr.wim_version = WIM_VERSION_DEFAULT;
wim->hdr.flags = 0;
wim->hdr.chunk_size = 0;
- randomize_byte_array(wim->hdr.guid, WIMLIB_GUID_LEN);
+ generate_guid(wim->hdr.guid);
wim->hdr.part_number = 1;
wim->hdr.total_parts = 1;
wim->hdr.image_count = 0;
wimlib_get_wim_info(WIMStruct *wim, struct wimlib_wim_info *info)
{
memset(info, 0, sizeof(struct wimlib_wim_info));
- memcpy(info->guid, wim->hdr.guid, WIMLIB_GUID_LEN);
+ copy_guid(info->guid, wim->hdr.guid);
info->image_count = wim->hdr.image_count;
info->boot_index = wim->hdr.boot_idx;
info->wim_version = wim->hdr.wim_version;
}
if (which & WIMLIB_CHANGE_GUID)
- memcpy(wim->hdr.guid, info->guid, WIM_GUID_LEN);
+ copy_guid(wim->hdr.guid, info->guid);
if (which & WIMLIB_CHANGE_BOOT_INDEX)
wim->hdr.boot_idx = info->boot_index;
fill_in_wimoverlay_dat(u8 *buf,
const struct WimOverlay_dat_header *old_hdr,
const wchar_t *wim_path,
- const u8 wim_guid[WIM_GUID_LEN],
+ const u8 wim_guid[GUID_SIZE],
int image,
u64 new_data_source_id,
const PARTITION_INFORMATION_EX *part_info,
new_entry_1->entry_2_length = new_entry_2_size;
new_entry_1->wim_type = WIM_BOOT_NOT_OS_WIM;
new_entry_1->wim_index = image;
- BUILD_BUG_ON(sizeof(new_entry_1->guid) != WIM_GUID_LEN);
- memcpy(new_entry_1->guid, wim_guid, WIM_GUID_LEN);
+ BUILD_BUG_ON(sizeof(new_entry_1->guid) != GUID_SIZE);
+ copy_guid(new_entry_1->guid, wim_guid);
p += sizeof(struct WimOverlay_dat_entry_1);
static int
prepare_wimoverlay_dat(const struct WimOverlay_dat_header *old_hdr,
const wchar_t *wim_path,
- const u8 wim_guid[WIM_GUID_LEN],
+ const u8 wim_guid[GUID_SIZE],
int image,
void **new_contents_ret,
u32 *new_contents_size_ret,
*/
static int
update_wimoverlay_manually(const wchar_t *drive, const wchar_t *wim_path,
- const u8 wim_guid[WIM_GUID_LEN],
+ const u8 wim_guid[GUID_SIZE],
int image, u64 *data_source_id_ret)
{
wchar_t path_main[] = L"A:\\System Volume Information\\WimOverlay.dat";
*/
int
wimboot_alloc_data_source_id(const wchar_t *wim_path,
- const u8 wim_guid[WIM_GUID_LEN],
+ const u8 wim_guid[GUID_SIZE],
int image, const wchar_t *target,
u64 *data_source_id_ret, bool *wof_running_ret)
{
if (write_flags & WIMLIB_WRITE_FLAG_RETAIN_GUID)
guid = wim->hdr.guid;
if (guid)
- memcpy(wim->out_hdr.guid, guid, WIMLIB_GUID_LEN);
+ copy_guid(wim->out_hdr.guid, guid);
else
- randomize_byte_array(wim->out_hdr.guid, WIMLIB_GUID_LEN);
+ generate_guid(wim->out_hdr.guid);
/* Set the part number and total parts. */
wim->out_hdr.part_number = part_number;