From: "Darrick J. Wong" Subject: [PATCH 55/74] libext2fs: support modifying arbitrary extended attributes Date: Tue, 10 Dec 2013 17:24:26 -0800 Message-ID: <20131211012426.30655.26259.stgit@birch.djwong.org> References: <20131211011813.30655.39624.stgit@birch.djwong.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Cc: linux-ext4@vger.kernel.org To: tytso@mit.edu, darrick.wong@oracle.com Return-path: Received: from userp1040.oracle.com ([156.151.31.81]:43647 "EHLO userp1040.oracle.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751243Ab3LKBYc (ORCPT ); Tue, 10 Dec 2013 20:24:32 -0500 In-Reply-To: <20131211011813.30655.39624.stgit@birch.djwong.org> Sender: linux-ext4-owner@vger.kernel.org List-ID: Add functions to allow clients to get, set, and remove extended attributes from any file. It also supports modifying EAs living in i_file_acl. v2: Put the header declarations in the correct part of ext2fs.h, provide a function to release an EA block from an inode, and check i_extra_isize to make sure we actually have space for in-inode EAs. v3: Add system.richacl prefix support, and only allow the new ext2fs_xattr_* functions to run if we have either ext_attr or inline_data set. Fix some memory leaks and stack disclosure problems, and an accounting problem when freeing an EA block. Signed-off-by: Darrick J. Wong --- lib/ext2fs/ext2_err.et.in | 21 + lib/ext2fs/ext2fs.h | 28 ++ lib/ext2fs/ext_attr.c | 757 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 806 insertions(+) diff --git a/lib/ext2fs/ext2_err.et.in b/lib/ext2fs/ext2_err.et.in index 93a1106..0a69aa3 100644 --- a/lib/ext2fs/ext2_err.et.in +++ b/lib/ext2fs/ext2_err.et.in @@ -482,4 +482,25 @@ ec EXT2_ET_BLOCK_BITMAP_CSUM_INVALID, ec EXT2_ET_INLINE_DATA_CANT_ITERATE, "Cannot iterate data blocks of an inode containing inline data" +ec EXT2_ET_EA_BAD_NAME_LEN, + "Extended attribute has an invalid name length" + +ec EXT2_ET_EA_BAD_VALUE_SIZE, + "Extended attribute has an invalid value length" + +ec EXT2_ET_BAD_EA_HASH, + "Extended attribute has an incorrect hash" + +ec EXT2_ET_BAD_EA_HEADER, + "Extended attribute block has a bad header" + +ec EXT2_ET_EA_KEY_NOT_FOUND, + "Extended attribute key not found" + +ec EXT2_ET_EA_NO_SPACE, + "Insufficient space to store extended attribute data" + +ec EXT2_ET_MISSING_EA_FEATURE, + "Filesystem is missing ext_attr or inline_data feature" + end diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h index 316e6f5..f3cb3a0 100644 --- a/lib/ext2fs/ext2fs.h +++ b/lib/ext2fs/ext2fs.h @@ -638,6 +638,13 @@ typedef struct stat ext2fs_struct_stat; #define EXT2_FLAG_FLUSH_NO_SYNC 1 /* + * Modify and iterate extended attributes + */ +struct ext2_xattr_handle; +#define XATTR_ABORT 1 +#define XATTR_CHANGED 2 + +/* * function prototypes */ static inline int ext2fs_has_group_desc_csum(ext2_filsys fs) @@ -1152,6 +1159,27 @@ extern errcode_t ext2fs_adjust_ea_refcount3(ext2_filsys fs, blk64_t blk, char *block_buf, int adjust, __u32 *newcount, ext2_ino_t inum); +errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h, + unsigned int expandby); +errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle); +errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle); +errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, + int (*func)(char *name, char *value, + void *data), + void *data); +errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key, + void **value, unsigned int *value_len); +errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle, + const char *key, + const void *value, + unsigned int value_len); +errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle, + const char *key); +errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino, + struct ext2_xattr_handle **handle); +errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle); +errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode_large *inode); /* extent.c */ extern errcode_t ext2fs_extent_header_verify(void *ptr, int size); diff --git a/lib/ext2fs/ext_attr.c b/lib/ext2fs/ext_attr.c index 9649a14..6eadca2 100644 --- a/lib/ext2fs/ext_attr.c +++ b/lib/ext2fs/ext_attr.c @@ -186,3 +186,760 @@ errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk, return ext2fs_adjust_ea_refcount2(fs, blk, block_buf, adjust, newcount); } + +/* Manipulate the contents of extended attribute regions */ +struct ext2_xattr { + char *name; + void *value; + unsigned int value_len; +}; + +struct ext2_xattr_handle { + ext2_filsys fs; + struct ext2_xattr *attrs; + unsigned int length; + ext2_ino_t ino; + int dirty; +}; + +errcode_t ext2fs_xattrs_expand(struct ext2_xattr_handle *h, + unsigned int expandby) +{ + struct ext2_xattr *new_attrs; + errcode_t err; + + err = ext2fs_get_arrayzero(h->length + expandby, + sizeof(struct ext2_xattr), &new_attrs); + if (err) + return err; + + memcpy(new_attrs, h->attrs, h->length * sizeof(struct ext2_xattr)); + ext2fs_free_mem(&h->attrs); + h->length += expandby; + h->attrs = new_attrs; + + return 0; +} + +struct ea_name_index { + int index; + const char *name; +}; + +/* Keep these names sorted in order of decreasing specificity. */ +static struct ea_name_index ea_names[] = { + {3, "system.posix_acl_default"}, + {2, "system.posix_acl_access"}, + {8, "system.richacl"}, + {6, "security."}, + {4, "trusted."}, + {7, "system."}, + {1, "user."}, + {0, NULL}, +}; + +static const char *find_ea_prefix(int index) +{ + struct ea_name_index *e; + + for (e = ea_names; e->name; e++) + if (e->index == index) + return e->name; + + return NULL; +} + +static int find_ea_index(const char *fullname, char **name, int *index) +{ + struct ea_name_index *e; + + for (e = ea_names; e->name; e++) { + if (memcmp(fullname, e->name, strlen(e->name)) == 0) { + *name = (char *)fullname + strlen(e->name); + *index = e->index; + return 1; + } + } + return 0; +} + +errcode_t ext2fs_free_ext_attr(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode_large *inode) +{ + struct ext2_ext_attr_header *header; + void *block_buf = NULL; + dgrp_t grp; + blk64_t blk, goal; + errcode_t err; + struct ext2_inode_large i; + + /* Read inode? */ + if (inode == NULL) { + err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&i, + sizeof(struct ext2_inode_large)); + if (err) + return err; + inode = &i; + } + + /* Do we already have an EA block? */ + blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode); + if (blk == 0) + return 0; + + /* Find block, zero it, write back */ + if ((blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { + err = EXT2_ET_BAD_EA_BLOCK_NUM; + goto out; + } + + err = ext2fs_get_mem(fs->blocksize, &block_buf); + if (err) + goto out; + + err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino); + if (err) + goto out2; + + header = (struct ext2_ext_attr_header *) block_buf; + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { + err = EXT2_ET_BAD_EA_HEADER; + goto out2; + } + + header->h_refcount--; + err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino); + if (err) + goto out2; + + /* Erase link to block */ + ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, 0); + if (header->h_refcount == 0) + ext2fs_block_alloc_stats2(fs, blk, -1); + err = ext2fs_iblk_sub_blocks(fs, (struct ext2_inode *)inode, 1); + if (err) + goto out2; + + /* Write inode? */ + if (inode == &i) { + err = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&i, + sizeof(struct ext2_inode_large)); + if (err) + goto out2; + } + +out2: + ext2fs_free_mem(&block_buf); +out: + return err; +} + +static errcode_t prep_ea_block_for_write(ext2_filsys fs, ext2_ino_t ino, + struct ext2_inode_large *inode) +{ + struct ext2_ext_attr_header *header; + void *block_buf = NULL; + dgrp_t grp; + blk64_t blk, goal; + errcode_t err; + + /* Do we already have an EA block? */ + blk = ext2fs_file_acl_block(fs, (struct ext2_inode *)inode); + if (blk != 0) { + if ((blk < fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(fs->super))) { + err = EXT2_ET_BAD_EA_BLOCK_NUM; + goto out; + } + + err = ext2fs_get_mem(fs->blocksize, &block_buf); + if (err) + goto out; + + err = ext2fs_read_ext_attr3(fs, blk, block_buf, ino); + if (err) + goto out2; + + header = (struct ext2_ext_attr_header *) block_buf; + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { + err = EXT2_ET_BAD_EA_HEADER; + goto out2; + } + + /* Single-user block. We're done here. */ + if (header->h_refcount == 1) + goto out2; + + /* We need to CoW the block. */ + header->h_refcount--; + err = ext2fs_write_ext_attr3(fs, blk, block_buf, ino); + if (err) + goto out2; + } else { + /* No block, we must increment i_blocks */ + err = ext2fs_iblk_add_blocks(fs, (struct ext2_inode *)inode, + 1); + if (err) + goto out; + } + + /* Allocate a block */ + grp = ext2fs_group_of_ino(fs, ino); + goal = ext2fs_inode_table_loc(fs, grp); + err = ext2fs_alloc_block2(fs, goal, NULL, &blk); + if (err) + goto out2; + ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk); +out2: + if (block_buf) + ext2fs_free_mem(&block_buf); +out: + return err; +} + + +static errcode_t write_xattrs_to_buffer(struct ext2_xattr_handle *handle, + struct ext2_xattr **pos, + void *entries_start, + unsigned int storage_size, + unsigned int value_offset_correction) +{ + struct ext2_xattr *x = *pos; + struct ext2_ext_attr_entry *e = entries_start; + void *end = entries_start + storage_size; + char *shortname; + unsigned int entry_size, value_size; + int idx, ret; + + /* For all remaining x... */ + for (; x < handle->attrs + handle->length; x++) { + if (!x->name) + continue; + + /* Calculate index and shortname position */ + shortname = x->name; + ret = find_ea_index(x->name, &shortname, &idx); + + /* Calculate entry and value size */ + entry_size = (sizeof(*e) + strlen(shortname) + + EXT2_EXT_ATTR_PAD - 1) & + ~(EXT2_EXT_ATTR_PAD - 1); + value_size = ((x->value_len + EXT2_EXT_ATTR_PAD - 1) / + EXT2_EXT_ATTR_PAD) * EXT2_EXT_ATTR_PAD; + + /* + * Would entry collide with value? + * Note that we must leave sufficient room for a (u32)0 to + * mark the end of the entries. + */ + if ((void *)e + entry_size + sizeof(__u32) > end - value_size) + break; + + /* Fill out e appropriately */ + e->e_name_len = strlen(shortname); + e->e_name_index = (ret ? idx : 0); + e->e_value_offs = end - value_size - (void *)entries_start + + value_offset_correction; + e->e_value_block = 0; + e->e_value_size = x->value_len; + + /* Store name and value */ + end -= value_size; + memcpy((void *)e + sizeof(*e), shortname, e->e_name_len); + memcpy(end, x->value, e->e_value_size); + + e->e_hash = ext2fs_ext_attr_hash_entry(e, end); + + e = EXT2_EXT_ATTR_NEXT(e); + *(__u32 *)e = 0; + } + *pos = x; + + return 0; +} + +errcode_t ext2fs_xattrs_write(struct ext2_xattr_handle *handle) +{ + struct ext2_xattr *x; + struct ext2_inode_large *inode; + void *start, *block_buf = NULL; + struct ext2_ext_attr_header *header; + __u32 ea_inode_magic; + blk64_t blk; + unsigned int storage_size; + unsigned int i; + errcode_t err; + + i = EXT2_INODE_SIZE(handle->fs->super); + if (i < sizeof(*inode)) + i = sizeof(*inode); + err = ext2fs_get_memzero(i, &inode); + if (err) + return err; + + err = ext2fs_read_inode_full(handle->fs, handle->ino, + (struct ext2_inode *)inode, + EXT2_INODE_SIZE(handle->fs->super)); + if (err) + goto out; + + x = handle->attrs; + /* Does the inode have size for EA? */ + if (EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize + + sizeof(__u32)) + goto write_ea_block; + + /* Write the inode EA */ + ea_inode_magic = EXT2_EXT_ATTR_MAGIC; + memcpy(((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize, &ea_inode_magic, sizeof(__u32)); + storage_size = EXT2_INODE_SIZE(handle->fs->super) - + EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize - + sizeof(__u32); + start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize + sizeof(__u32); + + err = write_xattrs_to_buffer(handle, &x, start, storage_size, 0); + if (err) + goto out; + + /* Are we done? */ + if (x == handle->attrs + handle->length) + goto skip_ea_block; + +write_ea_block: + /* Write the EA block */ + err = ext2fs_get_memzero(handle->fs->blocksize, &block_buf); + if (err) + goto out; + + storage_size = handle->fs->blocksize - + sizeof(struct ext2_ext_attr_header); + start = block_buf + sizeof(struct ext2_ext_attr_header); + + err = write_xattrs_to_buffer(handle, &x, start, storage_size, + (void *)start - block_buf); + if (err) + goto out2; + + if (x < handle->attrs + handle->length) { + err = EXT2_ET_EA_NO_SPACE; + goto out2; + } + + /* Write a header on the EA block */ + header = block_buf; + header->h_magic = EXT2_EXT_ATTR_MAGIC; + header->h_refcount = 1; + header->h_blocks = 1; + + /* Get a new block for writing */ + err = prep_ea_block_for_write(handle->fs, handle->ino, inode); + if (err) + goto out2; + + /* Finally, write the new EA block */ + blk = ext2fs_file_acl_block(handle->fs, + (struct ext2_inode *)inode); + err = ext2fs_write_ext_attr3(handle->fs, blk, block_buf, + handle->ino); + if (err) + goto out2; + +skip_ea_block: + blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode); + if (!block_buf && blk) { + /* xattrs shrunk, free the block */ + err = ext2fs_free_ext_attr(handle->fs, handle->ino, inode); + if (err) + goto out; + } + + /* Write the inode */ + err = ext2fs_write_inode_full(handle->fs, handle->ino, + (struct ext2_inode *)inode, + EXT2_INODE_SIZE(handle->fs->super)); + if (err) + goto out2; + +out2: + ext2fs_free_mem(&block_buf); +out: + ext2fs_free_mem(&inode); + handle->dirty = 0; + return err; +} + +static errcode_t read_xattrs_from_buffer(struct ext2_xattr_handle *handle, + struct ext2_ext_attr_entry *entries, + unsigned int storage_size, + void *value_start) +{ + struct ext2_xattr *x; + struct ext2_ext_attr_entry *entry; + const char *prefix; + void *ptr; + unsigned int remain, prefix_len; + errcode_t err; + + x = handle->attrs; + while (x->name) + x++; + + entry = entries; + while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { + __u32 hash; + + /* header eats this space */ + remain -= sizeof(struct ext2_ext_attr_entry); + + /* is attribute name valid? */ + if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) + return EXT2_ET_EA_BAD_NAME_LEN; + + /* attribute len eats this space */ + remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); + + /* check value size */ + if (entry->e_value_size > remain) + return EXT2_ET_EA_BAD_VALUE_SIZE; + + /* e_value_block must be 0 in inode's ea */ + if (entry->e_value_block != 0) + return EXT2_ET_BAD_EA_BLOCK_NUM; + + hash = ext2fs_ext_attr_hash_entry(entry, value_start + + entry->e_value_offs); + + /* e_hash may be 0 in older inode's ea */ + if (entry->e_hash != 0 && entry->e_hash != hash) + return EXT2_ET_BAD_EA_HASH; + + remain -= entry->e_value_size; + + /* Allocate space for more attrs? */ + if (x == handle->attrs + handle->length) { + err = ext2fs_xattrs_expand(handle, 4); + if (err) + return err; + x = handle->attrs + handle->length - 4; + } + + /* Extract name/value */ + prefix = find_ea_prefix(entry->e_name_index); + prefix_len = (prefix ? strlen(prefix) : 0); + err = ext2fs_get_memzero(entry->e_name_len + prefix_len + 1, + &x->name); + if (err) + return err; + if (prefix) + memcpy(x->name, prefix, prefix_len); + if (entry->e_name_len) + memcpy(x->name + prefix_len, + (void *)entry + sizeof(*entry), + entry->e_name_len); + + err = ext2fs_get_mem(entry->e_value_size, &x->value); + if (err) + return err; + x->value_len = entry->e_value_size; + memcpy(x->value, value_start + entry->e_value_offs, + entry->e_value_size); + x++; + entry = EXT2_EXT_ATTR_NEXT(entry); + } + + return 0; +} + +errcode_t ext2fs_xattrs_read(struct ext2_xattr_handle *handle) +{ + struct ext2_xattr *attrs = NULL, *x; + struct ext2_inode_large *inode; + struct ext2_ext_attr_header *header; + __u32 ea_inode_magic; + unsigned int storage_size; + void *start, *block_buf = NULL; + blk64_t blk; + int i; + errcode_t err; + + i = EXT2_INODE_SIZE(handle->fs->super); + if (i < sizeof(*inode)) + i = sizeof(*inode); + err = ext2fs_get_memzero(i, &inode); + if (err) + return err; + + err = ext2fs_read_inode_full(handle->fs, handle->ino, + (struct ext2_inode *)inode, + EXT2_INODE_SIZE(handle->fs->super)); + if (err) + goto out; + + /* Does the inode have size for EA? */ + if (EXT2_INODE_SIZE(handle->fs->super) <= EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize + + sizeof(__u32)) + goto read_ea_block; + + /* Look for EA in the inode */ + memcpy(&ea_inode_magic, ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize, sizeof(__u32)); + if (ea_inode_magic == EXT2_EXT_ATTR_MAGIC) { + storage_size = EXT2_INODE_SIZE(handle->fs->super) - + EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize - + sizeof(__u32); + start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize + sizeof(__u32); + + err = read_xattrs_from_buffer(handle, start, storage_size, + start); + if (err) + goto out; + } + +read_ea_block: + /* Look for EA in a separate EA block */ + blk = ext2fs_file_acl_block(handle->fs, (struct ext2_inode *)inode); + if (blk != 0) { + if ((blk < handle->fs->super->s_first_data_block) || + (blk >= ext2fs_blocks_count(handle->fs->super))) { + err = EXT2_ET_BAD_EA_BLOCK_NUM; + goto out; + } + + err = ext2fs_get_mem(handle->fs->blocksize, &block_buf); + if (err) + goto out; + + err = ext2fs_read_ext_attr3(handle->fs, blk, block_buf, + handle->ino); + if (err) + goto out3; + + header = (struct ext2_ext_attr_header *) block_buf; + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { + err = EXT2_ET_BAD_EA_HEADER; + goto out3; + } + + if (header->h_blocks != 1) { + err = EXT2_ET_BAD_EA_HEADER; + goto out3; + } + + /* Read EAs */ + storage_size = handle->fs->blocksize - + sizeof(struct ext2_ext_attr_header); + start = block_buf + sizeof(struct ext2_ext_attr_header); + err = read_xattrs_from_buffer(handle, start, storage_size, + block_buf); + if (err) + goto out3; + + ext2fs_free_mem(&block_buf); + } + + ext2fs_free_mem(&block_buf); + ext2fs_free_mem(&inode); + return 0; + +out3: + ext2fs_free_mem(&block_buf); +out: + ext2fs_free_mem(&inode); + return err; +} + +errcode_t ext2fs_xattrs_iterate(struct ext2_xattr_handle *h, + int (*func)(char *name, char *value, + void *data), + void *data) +{ + struct ext2_xattr *x; + errcode_t err; + int ret; + + for (x = h->attrs; x < h->attrs + h->length; x++) { + if (!x->name) + continue; + + ret = func(x->name, x->value, data); + if (ret & XATTR_CHANGED) + h->dirty = 1; + if (ret & XATTR_ABORT) + return 0; + } + + return 0; +} + +errcode_t ext2fs_xattr_get(struct ext2_xattr_handle *h, const char *key, + void **value, unsigned int *value_len) +{ + struct ext2_xattr *x; + void *val; + errcode_t err; + + for (x = h->attrs; x < h->attrs + h->length; x++) { + if (!x->name) + continue; + + if (strcmp(x->name, key) == 0) { + err = ext2fs_get_mem(x->value_len, &val); + if (err) + return err; + memcpy(val, x->value, x->value_len); + *value = val; + *value_len = x->value_len; + return 0; + } + } + + return EXT2_ET_EA_KEY_NOT_FOUND; +} + +errcode_t ext2fs_xattr_set(struct ext2_xattr_handle *handle, + const char *key, + const void *value, + unsigned int value_len) +{ + struct ext2_xattr *x, *last_empty; + char *new_value; + errcode_t err; + + last_empty = NULL; + for (x = handle->attrs; x < handle->attrs + handle->length; x++) { + if (!x->name) { + last_empty = x; + continue; + } + + /* Replace xattr */ + if (strcmp(x->name, key) == 0) { + err = ext2fs_get_mem(value_len, &new_value); + if (err) + return err; + memcpy(new_value, value, value_len); + ext2fs_free_mem(&x->value); + x->value = new_value; + x->value_len = value_len; + handle->dirty = 1; + return 0; + } + } + + /* Add attr to empty slot */ + if (last_empty) { + err = ext2fs_get_mem(strlen(key) + 1, &last_empty->name); + if (err) + return err; + strcpy(last_empty->name, key); + + err = ext2fs_get_mem(value_len, &last_empty->value); + if (err) + return err; + memcpy(last_empty->value, value, value_len); + last_empty->value_len = value_len; + handle->dirty = 1; + return 0; + } + + /* Expand array, append slot */ + err = ext2fs_xattrs_expand(handle, 4); + if (err) + return err; + + x = handle->attrs + handle->length - 4; + err = ext2fs_get_mem(strlen(key) + 1, &x->name); + if (err) + return err; + strcpy(x->name, key); + + err = ext2fs_get_mem(value_len, &x->value); + if (err) + return err; + memcpy(x->value, value, value_len); + x->value_len = value_len; + handle->dirty = 1; + return 0; +} + +errcode_t ext2fs_xattr_remove(struct ext2_xattr_handle *handle, + const char *key) +{ + struct ext2_xattr *x; + errcode_t err; + + for (x = handle->attrs; x < handle->attrs + handle->length; x++) { + if (!x->name) + continue; + + if (strcmp(x->name, key) == 0) { + ext2fs_free_mem(&x->name); + ext2fs_free_mem(&x->value); + x->value_len = 0; + handle->dirty = 1; + return 0; + } + } + + return EXT2_ET_EA_KEY_NOT_FOUND; +} + +errcode_t ext2fs_xattrs_open(ext2_filsys fs, ext2_ino_t ino, + struct ext2_xattr_handle **handle) +{ + struct ext2_xattr_handle *h; + errcode_t err; + + if (!EXT2_HAS_COMPAT_FEATURE(fs->super, + EXT2_FEATURE_COMPAT_EXT_ATTR) && + !EXT2_HAS_INCOMPAT_FEATURE(fs->super, + EXT4_FEATURE_INCOMPAT_INLINE_DATA)) + return EXT2_ET_MISSING_EA_FEATURE; + + err = ext2fs_get_memzero(sizeof(*h), &h); + if (err) + return err; + + h->length = 4; + err = ext2fs_get_arrayzero(h->length, sizeof(struct ext2_xattr), + &h->attrs); + if (err) { + ext2fs_free_mem(&h); + return err; + } + h->ino = ino; + h->fs = fs; + *handle = h; + return 0; +} + +errcode_t ext2fs_xattrs_close(struct ext2_xattr_handle **handle) +{ + unsigned int i; + struct ext2_xattr_handle *h = *handle; + struct ext2_xattr *a = h->attrs; + errcode_t err; + + if (h->dirty) { + err = ext2fs_xattrs_write(h); + if (err) + return err; + } + + for (i = 0; i < h->length; i++) { + if (a[i].name) + ext2fs_free_mem(&a[i].name); + if (a[i].value) + ext2fs_free_mem(&a[i].value); + } + + ext2fs_free_mem(&h->attrs); + ext2fs_free_mem(handle); + return 0; +}