/*
* Reads the security data from the metadata resource of a WIM image.
*
- * @metadata_resource: An array that contains the uncompressed metadata
- * resource for the WIM image.
- * @metadata_resource_len: The length of @metadata_resource.
- * @sd_ret: A pointer to a pointer to a wim_security_data structure that
- * will be filled in with a pointer to a new wim_security_data
- * structure containing the security data on success.
+ * @buf
+ * Buffer containing an uncompressed WIM metadata resource.
+ * @buf_len
+ * Length of the uncompressed metadata resource, in bytes.
+ * @sd_ret
+ * On success, a pointer to the resulting security data structure will be
+ * returned here.
*
* Note: There is no `offset' argument because the security data is located at
* the beginning of the metadata resource.
* WIMLIB_ERR_NOMEM
*/
int
-read_wim_security_data(const u8 metadata_resource[], size_t metadata_resource_len,
+read_wim_security_data(const u8 *buf, size_t buf_len,
struct wim_security_data **sd_ret)
{
struct wim_security_data *sd;
const struct wim_security_data_disk *sd_disk;
const u8 *p;
- if (metadata_resource_len < 8)
+ if (buf_len < 8)
return WIMLIB_ERR_INVALID_METADATA_RESOURCE;
sd = new_wim_security_data();
if (!sd)
goto out_of_memory;
- sd_disk = (const struct wim_security_data_disk*)metadata_resource;
+ sd_disk = (const struct wim_security_data_disk *)buf;
sd->total_length = le32_to_cpu(sd_disk->total_length);
sd->num_entries = le32_to_cpu(sd_disk->num_entries);
* integer, even though each security descriptor size is a 64-bit
* integer. This is stupid, and we need to be careful not to actually
* let the security descriptor sizes be over 0xffffffff. */
- if (sd->total_length > metadata_resource_len)
+ if (sd->total_length > buf_len)
goto out_invalid_sd;
sizes_size = (u64)sd->num_entries * sizeof(u64);
}
struct sd_node {
- int security_id;
+ int32_t security_id;
u8 hash[SHA1_HASH_SIZE];
struct avl_tree_node index_node;
};
}
}
+void
+rollback_new_security_descriptors(struct wim_sd_set *sd_set)
+{
+ struct wim_security_data *sd = sd_set->sd;
+ u8 **descriptors = sd->descriptors + sd_set->orig_num_entries;
+ u32 num_entries = sd->num_entries - sd_set->orig_num_entries;
+ while (num_entries--)
+ FREE(*descriptors++);
+ sd->num_entries = sd_set->orig_num_entries;
+}
+
/* Frees a security descriptor index set. */
void
-destroy_sd_set(struct wim_sd_set *sd_set, bool rollback)
+destroy_sd_set(struct wim_sd_set *sd_set)
{
- if (rollback) {
- struct wim_security_data *sd = sd_set->sd;
- u8 **descriptors = sd->descriptors + sd_set->orig_num_entries;
- u32 num_entries = sd->num_entries - sd_set->orig_num_entries;
- while (num_entries--)
- FREE(*descriptors++);
- sd->num_entries = sd_set->orig_num_entries;
- }
free_sd_tree(sd_set->root);
}
return hashes_cmp(SD_NODE(n1)->hash, SD_NODE(n2)->hash);
}
-/* Inserts a a new node into the security descriptor index tree. Returns true
+/* Inserts a new node into the security descriptor index tree. Returns true
* if successful (not a duplicate). */
static bool
insert_sd_node(struct wim_sd_set *set, struct sd_node *new)
/* Returns the index of the security descriptor having a SHA1 message digest of
* @hash. If not found, return -1. */
-static int
+static int32_t
lookup_sd(struct wim_sd_set *set, const u8 hash[SHA1_HASH_SIZE])
{
struct avl_tree_node *res;
* the security ID for it. If a new security descriptor cannot be allocated,
* return -1.
*/
-int
+int32_t
sd_set_add_sd(struct wim_sd_set *sd_set, const char *descriptor, size_t size)
{
u8 hash[SHA1_HASH_SIZE];
- int security_id;
+ int32_t security_id;
struct sd_node *new;
u8 **descriptors;
u64 *sizes;
ret = 0;
goto out;
out_destroy_sd_set:
- destroy_sd_set(sd_set, false);
+ destroy_sd_set(sd_set);
out:
return ret;
}