offset += rec_len;
if ((rec_len < 8) ||
((rec_len % 4) != 0) ||
- ((ext2fs_dirent_name_len(dirent)+8) > rec_len))
+ ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len))
return 0;
}
return (offset == final_offset);
if (((offset + rec_len) > buflen) ||
(rec_len < 8) ||
((rec_len % 4) != 0) ||
- ((ext2fs_dirent_name_len(dirent)+8) > rec_len)) {
+ ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len)) {
ctx->errcode = EXT2_ET_DIR_CORRUPTED;
return BLOCK_ABORT;
}
return NULL;
}
-static int find_ea_index(const char *fullname, char **name, int *index)
+static int find_ea_index(char *fullname, char **name, int *index)
{
struct ea_name_index *e;
{
struct ext2_xattr *x = *pos;
struct ext2_ext_attr_entry *e = entries_start;
- void *end = entries_start + storage_size;
+ char *end = (char *) entries_start + storage_size;
char *shortname;
unsigned int entry_size, value_size;
int idx, ret;
* 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)
+ if ((char *)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 +
+ e->e_value_offs = end - value_size - (char *)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((char *)e + sizeof(*e), shortname, e->e_name_len);
memcpy(end, x->value, e->e_value_size);
if (write_hash)
{
struct ext2_xattr *x;
struct ext2_inode_large *inode;
- void *start, *block_buf = NULL;
+ char *start, *block_buf = NULL;
struct ext2_ext_attr_header *header;
__u32 ea_inode_magic;
blk64_t blk;
start = block_buf + sizeof(struct ext2_ext_attr_header);
err = write_xattrs_to_buffer(handle, &x, start, storage_size,
- (void *)start - block_buf, 1);
+ start - block_buf, 1);
if (err)
goto out2;
}
/* Write a header on the EA block */
- header = block_buf;
+ header = (struct ext2_ext_attr_header *) block_buf;
header->h_magic = EXT2_EXT_ATTR_MAGIC;
header->h_refcount = 1;
header->h_blocks = 1;
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,
+ char *value_start,
size_t *nr_read)
{
struct ext2_xattr *x;
unsigned int remain, prefix_len;
errcode_t err;
unsigned int values_size = storage_size +
- ((char *)entries - (char *)value_start);
+ ((char *)entries - value_start);
x = handle->attrs;
while (x->name)
if (entry->e_value_size > 0 &&
value_start + entry->e_value_offs <
- (void *)end + sizeof(__u32))
+ (char *)end + sizeof(__u32))
return EXT2_ET_EA_BAD_VALUE_OFFSET;
/* e_value_block must be 0 in inode's ea */
memcpy(x->name, prefix, prefix_len);
if (entry->e_name_len)
memcpy(x->name + prefix_len,
- (void *)entry + sizeof(*entry),
+ (char *)entry + sizeof(*entry),
entry->e_name_len);
err = ext2fs_get_mem(entry->e_value_size, &x->value);
struct ext2_ext_attr_header *header;
__u32 ea_inode_magic;
unsigned int storage_size;
- void *start, *block_buf = NULL;
+ char *start, *block_buf = NULL;
blk64_t blk;
- int i;
+ size_t i;
errcode_t err;
EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EA_HANDLE);
start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
inode->i_extra_isize + sizeof(__u32);
- err = read_xattrs_from_buffer(handle, start, storage_size,
+ err = read_xattrs_from_buffer(handle,
+ (struct ext2_ext_attr_entry *) start, storage_size,
start, &handle->count);
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 = read_xattrs_from_buffer(handle, start, storage_size,
+ err = read_xattrs_from_buffer(handle,
+ (struct ext2_ext_attr_entry *) start, storage_size,
block_buf, &handle->count);
if (err)
goto out3;
void **value, size_t *value_len)
{
struct ext2_xattr *x;
- void *val;
+ char *val;
errcode_t err;
EXT2_CHECK_MAGIC(h, EXT2_ET_MAGIC_EA_HANDLE);
struct ext2_inode_large *inode;
__u32 ea_inode_magic;
unsigned int minoff;
- void *start;
- int i;
+ char *start;
+ size_t i;
errcode_t err;
i = EXT2_INODE_SIZE(fs->super);
/* has xattrs. calculate the size */
start= ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE +
inode->i_extra_isize + sizeof(__u32);
- entry = start;
+ entry = (struct ext2_ext_attr_entry *) start;
while (!EXT2_EXT_IS_LAST_ENTRY(entry)) {
if (!entry->e_value_block && entry->e_value_size) {
unsigned int offs = entry->e_value_offs;
if (retval)
goto done;
} else {
- __u32 orig_length;
- blk64_t orig_lblk;
- struct ext2fs_extent orig_extent;
+ __u32 save_length;
+ blk64_t save_lblk;
+ struct ext2fs_extent save_extent;
errcode_t r2;
#ifdef DEBUG
printf("(re/un)mapping in middle of extent\n");
#endif
/* need to split this extent; later */
- orig_lblk = extent.e_lblk;
- orig_length = extent.e_len;
- orig_extent = extent;
+ save_lblk = extent.e_lblk;
+ save_length = extent.e_len;
+ save_extent = extent;
/* shorten pre-split extent */
extent.e_len = (logical - extent.e_lblk);
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &newextent);
if (retval) {
- r2 = ext2fs_extent_goto(handle, orig_lblk);
+ r2 = ext2fs_extent_goto(handle, save_lblk);
if (r2 == 0)
(void)ext2fs_extent_replace(handle, 0,
- &orig_extent);
+ &save_extent);
goto done;
}
}
/* add post-split extent */
extent.e_pblk += extent.e_len + 1;
extent.e_lblk += extent.e_len + 1;
- extent.e_len = orig_length - extent.e_len - 1;
+ extent.e_len = save_length - extent.e_len - 1;
retval = ext2fs_extent_insert(handle,
EXT2_EXTENT_INSERT_AFTER, &extent);
if (retval) {
if (r2 == 0)
(void)ext2fs_extent_delete(handle, 0);
}
- r2 = ext2fs_extent_goto(handle, orig_lblk);
+ r2 = ext2fs_extent_goto(handle, save_lblk);
if (r2 == 0)
(void)ext2fs_extent_replace(handle, 0,
- &orig_extent);
+ &save_extent);
goto done;
}
}
* At the end, update i_blocks and i_size appropriately.
*/
-static void dbg_print_extent(char *desc, struct ext2fs_extent *extent)
+static void dbg_print_extent(const char *desc EXT2FS_ATTR((unused)),
+ const struct ext2fs_extent *extent EXT2FS_ATTR((unused)))
{
#ifdef DEBUG
if (desc)
count = wanted;
memcpy(buf, file->buf + file->pos, count);
file->pos += count;
- buf += count;
+ buf = (char *) buf + count;
out:
if (got)
errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
int whence, ext2_off_t *ret_pos)
{
- __u64 loffset, ret_loffset;
+ __u64 loffset, ret_loffset = 0;
errcode_t retval;
loffset = offset;
errcode_t ext2fs_inline_data_init(ext2_filsys fs, ext2_ino_t ino)
{
struct ext2_inline_data data;
+ char empty[1] = { '\0' };
data.fs = fs;
data.ino = ino;
data.ea_size = 0;
- data.ea_data = "";
+ data.ea_data = empty;
return ext2fs_inline_data_ea_set(&data);
}
struct ext2_dir_entry *dir, *dir2;
struct ext2_dir_entry_tail *t;
errcode_t retval;
- unsigned int offset, rec_len;
+ int offset;
+ unsigned int rec_len;
int csum_size = 0;
int filetype = 0;
memcpy(buf, (void *)inode->i_block, EXT4_MIN_INLINE_DATA_SIZE);
if (data.ea_size > 0)
- memcpy(buf + EXT4_MIN_INLINE_DATA_SIZE,
+ memcpy((char *) buf + EXT4_MIN_INLINE_DATA_SIZE,
data.ea_data, data.ea_size);
if (size)
data.fs = fs;
data.ino = ino;
data.ea_size = size - EXT4_MIN_INLINE_DATA_SIZE;
- data.ea_data = buf + EXT4_MIN_INLINE_DATA_SIZE;
+ data.ea_data = (char *) buf + EXT4_MIN_INLINE_DATA_SIZE;
return ext2fs_inline_data_ea_set(&data);
}
*/
errcode_t ext2fs_flush_icache(ext2_filsys fs)
{
- int i;
+ unsigned i;
if (!fs->icache)
return 0;
*/
void ext2fs_free_inode_cache(struct ext2_inode_cache *icache)
{
- int i;
+ unsigned i;
if (--icache->refcount)
return;
errcode_t ext2fs_create_inode_cache(ext2_filsys fs, unsigned int cache_size)
{
- int i;
+ unsigned i;
errcode_t retval;
if (fs->icache)
ext2_ino_t ino, inodes_to_scan;
unsigned int badness, checksum_failures;
unsigned int inodes_in_buf, inodes_per_block;
- void *p;
+ char *p;
struct ext2_inode_large *inode;
char *block_status;
unsigned int blk, bad_csum;
if (inodes_to_scan > inodes_in_buf)
inodes_to_scan = inodes_in_buf;
- p = scan->inode_buffer;
+ p = (char *) scan->inode_buffer;
ino = scan->current_inode + 1;
checksum_failures = badness = 0;
block_status = SCAN_BLOCK_STATUS(scan);
#endif
while (inodes_to_scan > 0) {
- blk = (p - (void *)scan->inode_buffer) / scan->fs->blocksize;
- bad_csum = ext2fs_inode_csum_verify(scan->fs, ino, p) == 0;
+ blk = (p - (char *)scan->inode_buffer) / scan->fs->blocksize;
+ bad_csum = ext2fs_inode_csum_verify(scan->fs, ino,
+ (struct ext2_inode_large *) p) == 0;
#ifdef WORDS_BIGENDIAN
ext2fs_swap_inode_full(scan->fs,
(struct ext2_inode_large *) p,
0, EXT2_INODE_SIZE(scan->fs->super));
#else
- inode = p;
+ inode = (struct ext2_inode_large *) p;
#endif
/* Is this inode insane? */
unsigned long group, block, offset;
char *ptr;
errcode_t retval;
- int clen, i, inodes_per_block;
+ unsigned i;
+ int clen, inodes_per_block;
io_channel io;
int length = EXT2_INODE_SIZE(fs->super);
struct ext2_inode_large *iptr;
errcode_t retval = 0;
struct ext2_inode_large *w_inode;
char *ptr;
- int clen, i;
+ unsigned i;
+ int clen;
int length = EXT2_INODE_SIZE(fs->super);
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
/*
* Create new directory on inline data
*/
-errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs, ext2_ino_t dir_ino,
+errcode_t ext2fs_new_dir_inline_data(ext2_filsys fs,
+ ext2_ino_t dir_ino EXT2FS_ATTR((unused)),
ext2_ino_t parent_ino, __u32 *iblock)
{
struct ext2_dir_entry *dir = NULL;
projects / thirdparty / e2fsprogs.git / commitdiff
