#include "ext2_fs.h"
#include "ext2fs.h"
+#include "ext2fsP.h"
#include <ext2fs/ext2_ext_attr.h>
-#ifdef WORDS_BIGENDIAN
void ext2fs_swap_super(struct ext2_super_block * sb)
{
- int i;
+ int i;
+
sb->s_inodes_count = ext2fs_swab32(sb->s_inodes_count);
sb->s_blocks_count = ext2fs_swab32(sb->s_blocks_count);
sb->s_r_blocks_count = ext2fs_swab32(sb->s_r_blocks_count);
sb->s_feature_compat = ext2fs_swab32(sb->s_feature_compat);
sb->s_feature_incompat = ext2fs_swab32(sb->s_feature_incompat);
sb->s_feature_ro_compat = ext2fs_swab32(sb->s_feature_ro_compat);
+ /* sb->s_uuid is __u8 and does not need swabbing */
+ /* sb->s_volume_name is char and does not need swabbing */
+ /* sb->s_last_mounted is char and does not need swabbing */
sb->s_algorithm_usage_bitmap = ext2fs_swab32(sb->s_algorithm_usage_bitmap);
+ /* sb->s_prealloc_blocks is __u8 and does not need swabbing */
+ /* sb->s_prealloc_dir_blocks is __u8 and does not need swabbing */
sb->s_reserved_gdt_blocks = ext2fs_swab16(sb->s_reserved_gdt_blocks);
+ /* sb->s_journal_uuid is __u8 and does not need swabbing */
sb->s_journal_inum = ext2fs_swab32(sb->s_journal_inum);
sb->s_journal_dev = ext2fs_swab32(sb->s_journal_dev);
sb->s_last_orphan = ext2fs_swab32(sb->s_last_orphan);
+ for (i = 0; i < 4; i++)
+ sb->s_hash_seed[i] = ext2fs_swab32(sb->s_hash_seed[i]);
+ /* sb->s_def_hash_version is __u8 and does not need swabbing */
+ /* sb->s_jnl_backup_type is __u8 and does not need swabbing */
sb->s_desc_size = ext2fs_swab16(sb->s_desc_size);
sb->s_default_mount_opts = ext2fs_swab32(sb->s_default_mount_opts);
sb->s_first_meta_bg = ext2fs_swab32(sb->s_first_meta_bg);
sb->s_mkfs_time = ext2fs_swab32(sb->s_mkfs_time);
+ /* if journal backup is for a valid extent-based journal... */
+ if (ext2fs_extent_header_verify(sb->s_jnl_blocks,
+ sizeof(sb->s_jnl_blocks)) == 0) {
+ /* ... swap only the journal i_size and i_size_high,
+ * and the extent data is not swapped on read */
+ i = 15;
+ } else {
+ /* direct/indirect journal: swap it all */
+ i = 0;
+ }
+ for (; i < 17; i++)
+ sb->s_jnl_blocks[i] = ext2fs_swab32(sb->s_jnl_blocks[i]);
sb->s_blocks_count_hi = ext2fs_swab32(sb->s_blocks_count_hi);
sb->s_r_blocks_count_hi = ext2fs_swab32(sb->s_r_blocks_count_hi);
sb->s_free_blocks_hi = ext2fs_swab32(sb->s_free_blocks_hi);
sb->s_min_extra_isize = ext2fs_swab16(sb->s_min_extra_isize);
sb->s_want_extra_isize = ext2fs_swab16(sb->s_want_extra_isize);
sb->s_flags = ext2fs_swab32(sb->s_flags);
+ sb->s_raid_stride = ext2fs_swab16(sb->s_raid_stride);
sb->s_mmp_update_interval = ext2fs_swab16(sb->s_mmp_update_interval);
sb->s_mmp_block = ext2fs_swab64(sb->s_mmp_block);
+ sb->s_raid_stripe_width = ext2fs_swab32(sb->s_raid_stripe_width);
+ /* sb->s_log_groups_per_flex is __u8 and does not need swabbing */
+ /* sb->s_checksum_type is __u8 and does not need swabbing */
+ /* sb->s_encryption_level is __u8 and does not need swabbing */
+ /* sb->s_reserved_pad is __u8 and does not need swabbing */
sb->s_kbytes_written = ext2fs_swab64(sb->s_kbytes_written);
sb->s_snapshot_inum = ext2fs_swab32(sb->s_snapshot_inum);
sb->s_snapshot_id = ext2fs_swab32(sb->s_snapshot_id);
sb->s_snapshot_r_blocks_count =
ext2fs_swab64(sb->s_snapshot_r_blocks_count);
sb->s_snapshot_list = ext2fs_swab32(sb->s_snapshot_list);
+ sb->s_error_count = ext2fs_swab32(sb->s_error_count);
+ sb->s_first_error_time = ext2fs_swab32(sb->s_first_error_time);
+ sb->s_first_error_ino = ext2fs_swab32(sb->s_first_error_ino);
+ sb->s_first_error_block = ext2fs_swab64(sb->s_first_error_block);
+ /* sb->s_first_error_func is __u8 and does not need swabbing */
+ sb->s_last_error_time = ext2fs_swab32(sb->s_last_error_time);
+ sb->s_last_error_ino = ext2fs_swab32(sb->s_last_error_ino);
+ sb->s_last_error_block = ext2fs_swab64(sb->s_last_error_block);
+ /* sb->s_last_error_func is __u8 and does not need swabbing */
+ /* sb->s_mount_opts is __u8 and does not need swabbing */
sb->s_usr_quota_inum = ext2fs_swab32(sb->s_usr_quota_inum);
sb->s_grp_quota_inum = ext2fs_swab32(sb->s_grp_quota_inum);
sb->s_overhead_blocks = ext2fs_swab32(sb->s_overhead_blocks);
+ sb->s_backup_bgs[0] = ext2fs_swab32(sb->s_backup_bgs[0]);
+ sb->s_backup_bgs[1] = ext2fs_swab32(sb->s_backup_bgs[1]);
+ /* sb->s_encrypt_algos is __u8 and does not need swabbing */
+ /* sb->s_encrypt_pw_salt is __u8 and does not need swabbing */
+ sb->s_lpf_ino = ext2fs_swab32(sb->s_lpf_ino);
+ sb->s_prj_quota_inum = ext2fs_swab32(sb->s_prj_quota_inum);
+ sb->s_checksum_seed = ext2fs_swab32(sb->s_checksum_seed);
+ /* s_*_time_hi are __u8 and does not need swabbing */
+ sb->s_encoding = ext2fs_swab16(sb->s_encoding);
+ sb->s_encoding_flags = ext2fs_swab16(sb->s_encoding_flags);
+ /* catch when new fields are used from s_reserved */
+ EXT2FS_BUILD_BUG_ON(sizeof(sb->s_reserved) != 95 * sizeof(__le32));
sb->s_checksum = ext2fs_swab32(sb->s_checksum);
-
- for (i=0; i < 4; i++)
- sb->s_hash_seed[i] = ext2fs_swab32(sb->s_hash_seed[i]);
-
- /* if journal backup is for a valid extent-based journal... */
- if (ext2fs_extent_header_verify(sb->s_jnl_blocks,
- sizeof(sb->s_jnl_blocks)) == 0) {
- /* ... swap only the journal i_size and i_size_high,
- * and the extent data is not swapped on read */
- i = 15;
- } else {
- /* direct/indirect journal: swap it all */
- i = 0;
- }
- for (; i < 17; i++)
- sb->s_jnl_blocks[i] = ext2fs_swab32(sb->s_jnl_blocks[i]);
}
void ext2fs_swap_group_desc2(ext2_filsys fs, struct ext2_group_desc *gdp)
{
+ struct ext4_group_desc *gdp4 = (struct ext4_group_desc *)gdp;
+
/* Do the 32-bit parts first */
gdp->bg_block_bitmap = ext2fs_swab32(gdp->bg_block_bitmap);
gdp->bg_inode_bitmap = ext2fs_swab32(gdp->bg_inode_bitmap);
gdp->bg_itable_unused = ext2fs_swab16(gdp->bg_itable_unused);
gdp->bg_checksum = ext2fs_swab16(gdp->bg_checksum);
/* If we're 32-bit, we're done */
- if (fs && (!fs->super->s_desc_size ||
- (fs->super->s_desc_size < EXT2_MIN_DESC_SIZE_64BIT)))
+ if (fs == NULL || EXT2_DESC_SIZE(fs->super) < EXT2_MIN_DESC_SIZE_64BIT)
return;
/* Swap the 64-bit parts */
- struct ext4_group_desc *gdp4 = (struct ext4_group_desc *) gdp;
gdp4->bg_block_bitmap_hi = ext2fs_swab32(gdp4->bg_block_bitmap_hi);
gdp4->bg_inode_bitmap_hi = ext2fs_swab32(gdp4->bg_inode_bitmap_hi);
gdp4->bg_inode_table_hi = ext2fs_swab32(gdp4->bg_inode_table_hi);
ext2fs_swab16(gdp4->bg_block_bitmap_csum_hi);
gdp4->bg_inode_bitmap_csum_hi =
ext2fs_swab16(gdp4->bg_inode_bitmap_csum_hi);
+ EXT2FS_BUILD_BUG_ON(sizeof(gdp4->bg_reserved) != sizeof(__u32));
}
void ext2fs_swap_group_desc(struct ext2_group_desc *gdp)
struct ext2_ext_attr_entry *from_entry)
{
to_entry->e_value_offs = ext2fs_swab16(from_entry->e_value_offs);
- to_entry->e_value_block = ext2fs_swab32(from_entry->e_value_block);
+ to_entry->e_value_inum = ext2fs_swab32(from_entry->e_value_inum);
to_entry->e_value_size = ext2fs_swab32(from_entry->e_value_size);
to_entry->e_hash = ext2fs_swab32(from_entry->e_hash);
}
to_entry = (struct ext2_ext_attr_entry *)to_header;
}
- while ((char *)from_entry < from_end && *(__u32 *)from_entry) {
+ while ((char *)from_entry < from_end &&
+ (char *)EXT2_EXT_ATTR_NEXT(from_entry) <= from_end &&
+ *(__u32 *)from_entry) {
ext2fs_swap_ext_attr_entry(to_entry, from_entry);
from_entry = EXT2_EXT_ATTR_NEXT(from_entry);
to_entry = EXT2_EXT_ATTR_NEXT(to_entry);
struct ext2_inode_large *f, int hostorder,
int bufsize)
{
- unsigned i, has_data_blocks, extra_isize, attr_magic;
- int has_extents = 0;
- int islnk = 0;
+ unsigned i, extra_isize, attr_magic;
+ int has_extents, has_inline_data, islnk, fast_symlink;
+ int inode_size;
__u32 *eaf, *eat;
- if (hostorder && LINUX_S_ISLNK(f->i_mode))
- islnk = 1;
+ /*
+ * Note that t and f may point to the same address. That's why
+ * if (hostorder) condition is executed before swab calls and
+ * if (!hostorder) afterwards.
+ */
+ if (hostorder) {
+ islnk = LINUX_S_ISLNK(f->i_mode);
+ fast_symlink = ext2fs_is_fast_symlink(EXT2_INODE(f));
+ has_extents = (f->i_flags & EXT4_EXTENTS_FL) != 0;
+ has_inline_data = (f->i_flags & EXT4_INLINE_DATA_FL) != 0;
+ }
+
t->i_mode = ext2fs_swab16(f->i_mode);
- if (!hostorder && LINUX_S_ISLNK(t->i_mode))
- islnk = 1;
t->i_uid = ext2fs_swab16(f->i_uid);
t->i_size = ext2fs_swab32(f->i_size);
t->i_atime = ext2fs_swab32(f->i_atime);
t->i_gid = ext2fs_swab16(f->i_gid);
t->i_links_count = ext2fs_swab16(f->i_links_count);
t->i_file_acl = ext2fs_swab32(f->i_file_acl);
- if (hostorder)
- has_data_blocks = ext2fs_inode_data_blocks(fs,
- (struct ext2_inode *) f);
t->i_blocks = ext2fs_swab32(f->i_blocks);
- if (!hostorder)
- has_data_blocks = ext2fs_inode_data_blocks(fs,
- (struct ext2_inode *) t);
- if (hostorder && (f->i_flags & EXT4_EXTENTS_FL))
- has_extents = 1;
t->i_flags = ext2fs_swab32(f->i_flags);
- if (!hostorder && (t->i_flags & EXT4_EXTENTS_FL))
- has_extents = 1;
- t->i_dir_acl = ext2fs_swab32(f->i_dir_acl);
- /* extent data are swapped on access, not here */
- if (!has_extents && (!islnk || has_data_blocks)) {
+ t->i_size_high = ext2fs_swab32(f->i_size_high);
+
+ if (!hostorder) {
+ islnk = LINUX_S_ISLNK(t->i_mode);
+ fast_symlink = ext2fs_is_fast_symlink(EXT2_INODE(t));
+ has_extents = (t->i_flags & EXT4_EXTENTS_FL) != 0;
+ has_inline_data = (t->i_flags & EXT4_INLINE_DATA_FL) != 0;
+ }
+
+ /*
+ * Extent data and inline data are swapped on access, not here
+ */
+ if (!has_extents && !has_inline_data && (!islnk || !fast_symlink)) {
for (i = 0; i < EXT2_N_BLOCKS; i++)
t->i_block[i] = ext2fs_swab32(f->i_block[i]);
} else if (t != f) {
/* this is error case: i_extra_size is too large */
return;
}
+ if (extra_isize & 3)
+ return; /* Illegal inode extra_isize */
- if (extra_isize >= 4)
+ inode_size = EXT2_GOOD_OLD_INODE_SIZE + extra_isize;
+ if (inode_includes(inode_size, i_checksum_hi))
t->i_checksum_hi = ext2fs_swab16(f->i_checksum_hi);
- if (extra_isize >= 8)
+ if (inode_includes(inode_size, i_ctime_extra))
t->i_ctime_extra = ext2fs_swab32(f->i_ctime_extra);
- if (extra_isize >= 12)
+ if (inode_includes(inode_size, i_mtime_extra))
t->i_mtime_extra = ext2fs_swab32(f->i_mtime_extra);
- if (extra_isize >= 16)
+ if (inode_includes(inode_size, i_atime_extra))
t->i_atime_extra = ext2fs_swab32(f->i_atime_extra);
- if (extra_isize >= 20)
+ if (inode_includes(inode_size, i_crtime))
t->i_crtime = ext2fs_swab32(f->i_crtime);
- if (extra_isize >= 24)
+ if (inode_includes(inode_size, i_crtime_extra))
t->i_crtime_extra = ext2fs_swab32(f->i_crtime_extra);
- if (extra_isize >= 28)
+ if (inode_includes(inode_size, i_version_hi))
t->i_version_hi = ext2fs_swab32(f->i_version_hi);
+ if (inode_includes(inode_size, i_projid))
+ t->i_projid = ext2fs_swab32(f->i_projid);
+ /* catch new static fields added after i_projid */
+ EXT2FS_BUILD_BUG_ON(sizeof(struct ext2_inode_large) != 160);
i = sizeof(struct ext2_inode) + extra_isize + sizeof(__u32);
if (bufsize < (int) i)
errcode_t ext2fs_dirent_swab_in(ext2_filsys fs, char *buf, int flags)
{
+ return ext2fs_dirent_swab_in2(fs, buf, fs->blocksize, flags);
+}
+
+errcode_t ext2fs_dirent_swab_in2(ext2_filsys fs, char *buf,
+ size_t size, int flags)
+{
errcode_t retval;
char *p, *end;
struct ext2_dir_entry *dirent;
- unsigned int name_len, rec_len;
+ unsigned int name_len, rec_len, left;
p = (char *) buf;
- end = (char *) buf + fs->blocksize;
+ end = (char *) buf + size;
+ left = size;
while (p < end-8) {
dirent = (struct ext2_dir_entry *) p;
dirent->inode = ext2fs_swab32(dirent->inode);
retval = EXT2_ET_DIR_CORRUPTED;
} else if (((name_len & 0xFF) + 8) > rec_len)
retval = EXT2_ET_DIR_CORRUPTED;
+ if (rec_len > left)
+ return EXT2_ET_DIR_CORRUPTED;
+ left -= rec_len;
p += rec_len;
}
errcode_t ext2fs_dirent_swab_out(ext2_filsys fs, char *buf, int flags)
{
+ return ext2fs_dirent_swab_out2(fs, buf, fs->blocksize, flags);
+}
+
+errcode_t ext2fs_dirent_swab_out2(ext2_filsys fs, char *buf,
+ size_t size, int flags)
+{
errcode_t retval;
char *p, *end;
- unsigned int rec_len;
+ unsigned int rec_len, left;
struct ext2_dir_entry *dirent;
p = buf;
- end = buf + fs->blocksize;
+ end = buf + size;
+ left = size;
while (p < end) {
dirent = (struct ext2_dir_entry *) p;
retval = ext2fs_get_rec_len(fs, dirent, &rec_len);
dirent->inode = ext2fs_swab32(dirent->inode);
dirent->rec_len = ext2fs_swab16(dirent->rec_len);
dirent->name_len = ext2fs_swab16(dirent->name_len);
+ if (rec_len > size)
+ return EXT2_ET_DIR_CORRUPTED;
+ size -= rec_len;
if (flags & EXT2_DIRBLOCK_V2_STRUCT)
dirent->name_len = ext2fs_swab16(dirent->name_len);
return 0;
}
-
-#endif
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff