--- /dev/null
+/*
+ * tagged_items.c
+ *
+ * Support for tagged metadata items that can be appended to WIM directory
+ * entries.
+ */
+
+/*
+ * Copyright (C) 2014 Eric Biggers
+ *
+ * This file is part of wimlib, a library for working with WIM files.
+ *
+ * wimlib is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wimlib; if not, see http://www.gnu.org/licenses/.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "wimlib/endianness.h"
+#include "wimlib/inode.h"
+#include "wimlib/types.h"
+#include "wimlib/unix_data.h"
+
+/* Used by the Microsoft implementation. */
+#define TAG_OBJECT_ID 0x00000001
+
+/* Random number that we'll use for tagging our UNIX data items. */
+#define TAG_WIMLIB_UNIX_DATA 0x337DD873
+
+/* Header that begins each tagged metadata item in the metadata resource */
+struct tagged_item_header {
+
+ /* Unique identifier for this item. */
+ le32 tag;
+
+ /* Size of the data of this tagged item, in bytes. This includes this
+ * header and should be a multiple of 8.
+ *
+ * (Actually, the MS implementation seems to round this up to an 8 byte
+ * boundary when calculating the offset to the next tagged item, but
+ * uses this length unmodified when validating the item. We might as
+ * well do the same.) */
+ le32 length;
+
+ /* Variable length data */
+ u8 data[];
+};
+
+struct object_id_disk {
+ u8 object_id[16];
+ u8 birth_volume_id[16];
+ u8 birth_object_id[16];
+ u8 domain_id[16];
+};
+
+struct wimlib_unix_data_disk {
+ le32 uid;
+ le32 gid;
+ le32 mode;
+ le32 reserved;
+};
+
+/* Retrieves the first tagged item with the specified tag and minimum length
+ * from the WIM inode. Returns a pointer to the tagged data, which can be read
+ * and/or modified in place. Or, if no matching tagged item is found, returns
+ * NULL. */
+static void *
+inode_get_tagged_item(const struct wim_inode *inode,
+ u32 desired_tag, u32 min_data_len)
+{
+ size_t minlen_with_hdr = sizeof(struct tagged_item_header) + min_data_len;
+ size_t len_remaining = inode->i_extra_size;
+ u8 *p = inode->i_extra;
+
+ /* Iterate through the tagged items. */
+ while (len_remaining >= minlen_with_hdr) {
+ struct tagged_item_header *hdr;
+ u32 tag;
+ u32 len;
+
+ hdr = (struct tagged_item_header *)p;
+ tag = le32_to_cpu(hdr->tag);
+ len = le32_to_cpu(hdr->length);
+
+ if (tag == desired_tag && len >= min_data_len)
+ return hdr->data;
+
+ len = (len + 7) & ~7;
+ if (len >= len_remaining)
+ return NULL;
+ len_remaining -= len;
+ p = hdr->data + len;
+ }
+ return NULL;
+}
+
+/* Adds a tagged item to a WIM inode and returns a pointer to its uninitialized
+ * data, which must be initialized in-place by the caller. */
+static void *
+inode_add_tagged_item(struct wim_inode *inode, u32 tag, u32 len)
+{
+ size_t itemsize;
+ size_t newsize;
+ u8 *buf;
+ struct tagged_item_header *hdr;
+
+ /* We prepend the item instead of appending it because it's easier. */
+
+ itemsize = sizeof(struct tagged_item_header) + len;
+ newsize = itemsize + inode->i_extra_size;
+
+ buf = MALLOC(newsize);
+ if (!buf)
+ return NULL;
+
+ if (inode->i_extra_size) {
+ memcpy(buf + itemsize, inode->i_extra, inode->i_extra_size);
+ FREE(inode->i_extra);
+ }
+ inode->i_extra = buf;
+ inode->i_extra_size = newsize;
+
+ hdr = (struct tagged_item_header *)buf;
+ hdr->tag = cpu_to_le32(tag);
+ hdr->length = cpu_to_le32(len);
+ return hdr->data;
+}
+
+static inline struct wimlib_unix_data_disk *
+inode_get_unix_data_disk(const struct wim_inode *inode)
+{
+ return inode_get_tagged_item(inode, TAG_WIMLIB_UNIX_DATA,
+ sizeof(struct wimlib_unix_data_disk));
+}
+
+static inline struct wimlib_unix_data_disk *
+inode_add_unix_data_disk(struct wim_inode *inode)
+{
+ return inode_add_tagged_item(inode, TAG_WIMLIB_UNIX_DATA,
+ sizeof(struct wimlib_unix_data_disk));
+}
+
+/* Returns %true if the specified WIM inode has UNIX data; otherwise %false.
+ * This is a wimlib extension. */
+bool
+inode_has_unix_data(const struct wim_inode *inode)
+{
+ return inode_get_unix_data_disk(inode) != NULL;
+}
+
+/* Retrieves UNIX data from the specified WIM inode.
+ * This is a wimlib extension.
+ *
+ * Returns %true and fills @unix_data if the inode has UNIX data.
+ * Otherwise returns %false. */
+bool
+inode_get_unix_data(const struct wim_inode *inode,
+ struct wimlib_unix_data *unix_data)
+{
+ const struct wimlib_unix_data_disk *p;
+
+ p = inode_get_unix_data_disk(inode);
+ if (!p)
+ return false;
+
+ unix_data->uid = le32_to_cpu(p->uid);
+ unix_data->gid = le32_to_cpu(p->gid);
+ unix_data->mode = le32_to_cpu(p->mode);
+ return true;
+}
+
+/* Sets UNIX data on the specified WIM inode.
+ * This is a wimlib extension.
+ *
+ * Callers must specify all of @uid, @gid, and @mode. If the inode does not yet
+ * have UNIX data, it is given these values. Otherwise, only the values that
+ * also have the corresponding flags in @which set are changed.
+ *
+ * Returns %true if successful, %false if failed (out of memory). */
+bool
+inode_set_unix_data(struct wim_inode *inode, u32 uid, u32 gid, u32 mode,
+ int which)
+{
+ struct wimlib_unix_data_disk *p;
+
+ p = inode_get_unix_data_disk(inode);
+ if (!p) {
+ p = inode_add_unix_data_disk(inode);
+ if (!p)
+ return false;
+ p->reserved = cpu_to_le32(0);
+ which = UNIX_DATA_UID | UNIX_DATA_GID | UNIX_DATA_MODE;
+ }
+ if (which & UNIX_DATA_UID)
+ p->uid = cpu_to_le32(uid);
+ if (which & UNIX_DATA_GID)
+ p->gid = cpu_to_le32(gid);
+ if (which & UNIX_DATA_MODE)
+ p->mode = cpu_to_le32(mode);
+ return true;
+}
git://wimlib.net / wimlib / blobdiff