ext2fs: Take cares of indiannes

In ext2 data are stored in little endian to ensure portability. So
enforce little endian when manipulating these bytes.
Message-Id: <20220123041715.19402-8-etienne.brateau@gmail.com>

1 files changed, 21 insertions, 21 deletions

diff --git a/ext2fs/hyper.c b/ext2fs/hyper.c
index 0bcf0c72..04da86a7 100644
--- a/ext2fs/hyper.c
+++ b/ext2fs/hyper.c
@@ -42,7 +42,7 @@ allocate_mod_map (void)
        global blocks are actually modified so the pager can write only them. */
     {
       /* One bit per filesystem block.  */
-      mod_map_size = sblock->s_blocks_count >> 3;
+      mod_map_size = le32toh (sblock->s_blocks_count) >> 3;
       modified_global_blocks = mmap (0, mod_map_size, PROT_READ|PROT_WRITE,
 				     MAP_ANON, 0, 0);
       assert_backtrace (modified_global_blocks != (void *) -1);
@@ -70,15 +70,15 @@ get_hypermetadata (void)
   if (err || read != SBLOCK_SIZE)
     ext2_panic ("Cannot read hypermetadata");
 
-  if (sblock->s_magic != EXT2_SUPER_MAGIC
+  if (sblock->s_magic != htole16 (EXT2_SUPER_MAGIC)
 #ifdef EXT2FS_PRE_02B_COMPAT
-      && sblock->s_magic != EXT2_PRE_02B_MAGIC
+      && sblock->s_magic != htole16 (EXT2_PRE_02B_MAGIC)
 #endif
       )
     ext2_panic ("bad magic number %#x (should be %#x)",
-		sblock->s_magic, EXT2_SUPER_MAGIC);
+		le16toh (sblock->s_magic), EXT2_SUPER_MAGIC);
 
-  log2_block_size = EXT2_MIN_BLOCK_LOG_SIZE + sblock->s_log_block_size;
+  log2_block_size = EXT2_MIN_BLOCK_LOG_SIZE + le32toh(sblock->s_log_block_size);
   block_size = 1 << log2_block_size;
 
   if (block_size > EXT2_MAX_BLOCK_SIZE)
@@ -98,10 +98,10 @@ get_hypermetadata (void)
     ext2_panic ("block size %d isn't a power-of-two multiple of 512!",
 		block_size);
 
-  if ((store->size >> log2_block_size) < sblock->s_blocks_count)
+  if ((store->size >> log2_block_size) < le32toh (sblock->s_blocks_count))
     ext2_panic ("disk size (%qd bytes) too small; superblock says we need %qd",
 		(long long int) store->size,
-		(long long int) sblock->s_blocks_count << log2_block_size);
+	       (long long int) le32toh (sblock->s_blocks_count) << log2_block_size);
   if (log2_dev_blocks_per_fs_block != 0
       && (store->size & ((1 << log2_dev_blocks_per_fs_block) - 1)) != 0)
     ext2_warning ("%Ld (%zd byte) device blocks "
@@ -112,12 +112,12 @@ get_hypermetadata (void)
   /* Set these handy variables.  */
   inodes_per_block = block_size / EXT2_INODE_SIZE (sblock);
 
-  frag_size = EXT2_MIN_FRAG_SIZE << sblock->s_log_frag_size;
+  frag_size = EXT2_MIN_FRAG_SIZE << le32toh (sblock->s_log_frag_size);
   if (frag_size == 0)
     ext2_panic ("frag size is zero!");
   frags_per_block = block_size / frag_size;
 
-  if (sblock->s_rev_level > EXT2_GOOD_OLD_REV)
+  if (le32toh (sblock->s_rev_level) > EXT2_GOOD_OLD_REV)
     {
       features = EXT2_HAS_INCOMPAT_FEATURE(sblock, EXT2_FEATURE_INCOMPAT_UNSUPPORTED);
       if (features)
@@ -132,21 +132,21 @@ get_hypermetadata (void)
 			features);
 	  diskfs_readonly = 1;
 	}
-      if (sblock->s_inode_size != EXT2_GOOD_OLD_INODE_SIZE)
-	ext2_panic ("inode size %d isn't supported", sblock->s_inode_size);
+      if (le16toh (sblock->s_inode_size) != EXT2_GOOD_OLD_INODE_SIZE)
+	ext2_panic ("inode size %d isn't supported", le16toh (sblock->s_inode_size));
     }
 
   groups_count =
-    ((sblock->s_blocks_count - sblock->s_first_data_block +
-      sblock->s_blocks_per_group - 1)
-     / sblock->s_blocks_per_group);
+    ((le32toh (sblock->s_blocks_count) - le32toh (sblock->s_first_data_block) +
+      le32toh (sblock->s_blocks_per_group) - 1)
+     / le32toh (sblock->s_blocks_per_group));
 
-  itb_per_group = sblock->s_inodes_per_group / inodes_per_block;
+  itb_per_group = le32toh (sblock->s_inodes_per_group) / inodes_per_block;
   desc_per_block = block_size / sizeof (struct ext2_group_desc);
   addr_per_block = block_size / sizeof (block_t);
   db_per_group = (groups_count + desc_per_block - 1) / desc_per_block;
 
-  ext2fs_clean = sblock->s_state & EXT2_VALID_FS;
+  ext2fs_clean = sblock->s_state & htole16 (EXT2_VALID_FS);
   if (! ext2fs_clean)
     {
       ext2_warning ("FILESYSTEM NOT UNMOUNTED CLEANLY; PLEASE fsck");
@@ -183,16 +183,16 @@ map_hypermetadata (void)
 error_t
 diskfs_set_hypermetadata (int wait, int clean)
 {
-  if (clean && ext2fs_clean && !(sblock->s_state & EXT2_VALID_FS))
+  if (clean && ext2fs_clean && !(sblock->s_state & htole16 (EXT2_VALID_FS)))
     /* The filesystem is clean, so we need to set the clean flag.  */
     {
-      sblock->s_state |= EXT2_VALID_FS;
+      sblock->s_state |= htole16 (EXT2_VALID_FS);
       sblock_dirty = 1;
     }
-  else if (!clean && (sblock->s_state & EXT2_VALID_FS))
+  else if (!clean && (sblock->s_state & htole16 (EXT2_VALID_FS)))
     /* The filesystem just became dirty, so clear the clean flag.  */
     {
-      sblock->s_state &= ~EXT2_VALID_FS;
+      sblock->s_state &= htole16 (~EXT2_VALID_FS);
       sblock_dirty = 1;
       wait = 1;
     }
@@ -221,6 +221,6 @@ diskfs_readonly_changed (int readonly)
   mprotect (disk_cache, disk_cache_size,
 	    PROT_READ | (readonly ? 0 : PROT_WRITE));
 
-  if (!readonly && !(sblock->s_state & EXT2_VALID_FS))
+  if (!readonly && !(sblock->s_state & htole16 (EXT2_VALID_FS)))
     ext2_warning ("UNCLEANED FILESYSTEM NOW WRITABLE");
 }