lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
Open Source and information security mailing list archives
| ||
|
Message-ID: <20131204032121.GE9541@birch.djwong.org> Date: Tue, 3 Dec 2013 19:21:21 -0800 From: "Darrick J. Wong" <darrick.wong@...cle.com> To: linux-ext4@...r.kernel.org, "Theodore Ts'o" <tytso@....edu>, Zheng Liu <wenqing.lz@...bao.com> Subject: Re: [PATCH v2 01/28] libext2fs: support modifying arbitrary extended attributes On Wed, Dec 04, 2013 at 11:20:59AM +0800, Zheng Liu wrote: > On Tue, Dec 03, 2013 at 11:54:57AM -0800, Darrick J. Wong wrote: > > On Tue, Dec 03, 2013 at 08:11:28PM +0800, Zheng Liu wrote: > > > From: "Darrick J. Wong" <darrick.wong@...cle.com> > > > > > > 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. > > > > > > [Modified by Zheng] > > > Ext_attr feature check in ext2fs_xattrs_read/write() is removed because > > > inline_data feature can be enabled without ext_attr. > > > > Ok, so inline_data implies ext_attr. > > No. I try this command to create a ext4 filesystem with inline_data: > > % sudo mke2fs -t ext4 -O inline_data,^ext_attr ${DEV} > > Then I mount it and create/delete/modify some files. Everything is > fine. So that means that we can use inline_data even without ext_attr. > That is why I modify the sanity check in mke2fs and tune2fs. Now we > only check the inode size to ensure that we have enough space to store a > xattr entry in inode extended attribute space. I will explain why we > must ensure the inode has a 'system.data' xattr entry. <nod> My mistake. With inlinedata,^extattr we (userland) shouldn't be able to store attrs, even if inline_data is using those functions. > > > I think we should change the test to > > check for either feature flag, because with no test, we could accidentally > > read/write EAs on a FS with ^ext_attr,^inline_data. Or maybe provide a helper > > predicate to hide those details. > > Agree. I will add a sanity check for inline_data feature. Already did. I'll send it out in my ... growing nightmare of a patch stack. > > > > > Also, I'd ask you to send broken out changes to my patches... but I haven't > > posted my monster patchset recently. :) > > No problem. I will split this patch and send them out. Ok, I look forward to seeing that. --D > > Thanks, > - Zheng > > > > > (I think I might work up the courage to patchbomb the mailing list tonight.) > > > > --D > > > > > > Signed-off-by: Darrick J. Wong <darrick.wong@...cle.com> > > > Signed-off-by: Zheng Liu <wenqing.lz@...bao.com> > > > --- > > > lib/ext2fs/ext2_err.et.in | 18 ++ > > > lib/ext2fs/ext2fs.h | 28 ++ > > > lib/ext2fs/ext_attr.c | 754 +++++++++++++++++++++++++++++++++++++++++++++ > > > 3 files changed, 800 insertions(+) > > > > > > diff --git a/lib/ext2fs/ext2_err.et.in b/lib/ext2fs/ext2_err.et.in > > > index 9cc1bd1..b819a90 100644 > > > --- a/lib/ext2fs/ext2_err.et.in > > > +++ b/lib/ext2fs/ext2_err.et.in > > > @@ -482,4 +482,22 @@ ec EXT2_ET_BLOCK_BITMAP_CSUM_INVALID, > > > ec EXT2_ET_INLINE_DATA_CANT_ITERATE, > > > "Cannot block iterate on 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" > > > + > > > end > > > diff --git a/lib/ext2fs/ext2fs.h b/lib/ext2fs/ext2fs.h > > > index 67876ad..30bd4cf 100644 > > > --- a/lib/ext2fs/ext2fs.h > > > +++ b/lib/ext2fs/ext2fs.h > > > @@ -637,6 +637,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) > > > @@ -1142,6 +1149,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..4d40149 100644 > > > --- a/lib/ext2fs/ext_attr.c > > > +++ b/lib/ext2fs/ext_attr.c > > > @@ -186,3 +186,757 @@ 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; > > > +}; > > > + > > > +static struct ea_name_index ea_names[] = { > > > + {1, "user."}, > > > + {2, "system.posix_acl_access"}, > > > + {3, "system.posix_acl_default"}, > > > + {4, "trusted."}, > > > + {6, "security."}, > > > + {7, "system."}, > > > + {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); > > > + > > > + /* 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) > > > + return 0; > > > + > > > + /* 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) > > > + return err; > > > + ext2fs_file_acl_block_set(fs, (struct ext2_inode *)inode, blk); > > > +out2: > > > + 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, written; > > > + 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_mem(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; > > > + } > > > + > > > + if (block_buf) { > > > + /* 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 */ > > > + ext2fs_file_acl_block_set(handle->fs, > > > + (struct ext2_inode *)inode, 0); > > > + err = ext2fs_iblk_sub_blocks(handle->fs, > > > + (struct ext2_inode *)inode, 1); > > > + if (err) > > > + goto out; > > > + ext2fs_block_alloc_stats2(handle->fs, blk, -1); > > > + } > > > + > > > + /* 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; > > > + unsigned int attrs_len; > > > + 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; > > > +} > > > + > > > +#define XATTR_ABORT 1 > > > +#define XATTR_CHANGED 2 > > > +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; > > > + > > > + 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; > > > +} > > > -- > > > 1.7.9.7 > > > > > > -- > > > To unsubscribe from this list: send the line "unsubscribe linux-ext4" in > > > the body of a message to majordomo@...r.kernel.org > > > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to majordomo@...r.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Powered by blists - more mailing lists