#include <ext2fs/ext2_fs.h>

#include <ext2fs/ext2fs.h>

#include <stdlib.h>
#include <stdio.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int main(int argc, char **argv)
{

  if(argc != 2)
    {
      usage();
    }

  int fd = open(argv[1],O_RDONLY);

  if(fd == -1)
    {
      printf("Cannot open '%s'\n",argv[1]);
    }

  char buff[1024];
  struct ext2_super_block sb;
  int readcount = read(fd,&buff,1024);
  if(readcount != 1024)
    {
      printf("Really!? I didn't read 1024 bytes from the superblock!\n");
      printf("That's unusual, and I am stopping.\n");
      exit(2);
    }

  int i;
  for(i=0;i<1024;i++)
    {
      if(buff[i] != 0)
	{
	  printf("Hey, I found a non-null byte in the inital 1024 bytes at %d!\n",i);
	}
    }

  read(fd,&sb,1024);
  printf("Inodes count = %u\n",sb.s_inodes_count);
  printf("Blocks count = %u\n",sb.s_blocks_count);
  printf("Reserved blocks count = %u\n",sb.s_r_blocks_count);
  printf("Free blocks count = %u\n",sb.s_free_blocks_count);
  printf("Free inodes count = %u\n",sb.s_free_inodes_count);
  printf("First data block = %u\n",sb.s_first_data_block);
  printf("Block size = %u\n",sb.s_log_block_size);
  printf("Allocation cluster size = %u\n",sb.s_log_cluster_size);
  printf("Blocks per group = %u\n",sb.s_blocks_per_group);
  printf("# Fragments per group = %u\n",sb.s_clusters_per_group);
  printf("# Inodes per group = %u\n",sb.s_inodes_per_group);
  printf("Mount time = %u\n",sb.s_mtime);
  printf("Write time = %u\n",sb.s_wtime);
  printf("Mount count  = %u\n",sb.s_mnt_count);
  printf("Maximal mount count  = %u\n",sb.s_max_mnt_count);
  printf("Magic signature = %x\n",sb.s_magic);
  printf("File system state = %u\n",sb.s_state);
  printf("Behavior when detecting errors = %u\n",sb.s_errors);
  printf("Minor revision level = %u\n",sb.s_minor_rev_level);
  printf("Time of last check; = %u\n",sb.s_lastcheck);
  printf("Maximum time between checks  = %u\n",sb.s_checkinterval);
  printf("Creator OS = %u\n",sb.s_creator_os);
  printf("Revision level = %u\n",sb.s_rev_level);
  printf("Default uid for reserved blocks  = %u\n",sb.s_def_resuid);
  printf("Default gid for reserved blocks  = %u\n",sb.s_def_resgid);
  //  printf(" = %u\n",sb.);

  //	__u32	;	/* 
  //	__u32	;	/* 
  //	__u32	;		/*  */
  //	__u32	s_wtime;		/*  */
  //	__u16	;		/**/
  //	__s16		/**/
  //	__u16	;		/* Magic signature */
  //	__u16	;		/*  */
  //	__u16	;		/* Behaviour when detecting errors */
  //	__u16	;	/*  */
  //	__u32			/* time of last check */
  //	__u32	;	/**/
  //	__u32	;		/* OS */
  //	__u32	;		/*  */
  //	__u16	;		/* */
  //	__u16	;		/* Default gid for reserved blocks */
  //	/*
  //	 * These fields are for EXT2_DYNAMIC_REV superblocks only.
  //	 *
  //	 * Note: the difference between the compatible feature set and
  //	 * the incompatible feature set is that if there is a bit set
  //	 * in the incompatible feature set that the kernel doesn't
  //	 * know about, it should refuse to mount the filesystem.
  //	 *
  //	 * e2fsck's requirements are more strict; if it doesn't know
  //	 * about a feature in either the compatible or incompatible
  //	 * feature set, it must abort and not try to meddle with
  //	 * things it doesn't understand...
  //	 */
  //	__u32	s_first_ino;		/* First non-reserved inode */
  //	__u16   s_inode_size;		/* size of inode structure */
  //	__u16	s_block_group_nr;	/* block group # of this superblock */
  //	__u32	s_feature_compat;	/* compatible feature set */
  //	__u32	s_feature_incompat;	/* incompatible feature set */
  //	__u32	s_feature_ro_compat;	/* readonly-compatible feature set */
  //	__u8	s_uuid[16];		/* 128-bit uuid for volume */
  //	char	s_volume_name[16];	/* volume name */
  //	char	s_last_mounted[64];	/* directory where last mounted */
  //	__u32	s_algorithm_usage_bitmap; /* For compression */
  //	/*
  //	 * Performance hints.  Directory preallocation should only
  //	 * happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on.
  //	 */
  //	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
  //	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
  //	__u16	s_reserved_gdt_blocks;	/* Per group table for online growth */
  //	/*
  //	 * Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set.
  //	 */
  //	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
  //	__u32	s_journal_inum;		/* inode number of journal file */
  //	__u32	s_journal_dev;		/* device number of journal file */
  //	__u32	s_last_orphan;		/* start of list of inodes to delete */
  //	__u32	s_hash_seed[4];		/* HTREE hash seed */
  //	__u8	s_def_hash_version;	/* Default hash version to use */
  //	__u8	s_jnl_backup_type; 	/* Default type of journal backup */
  //	__u16	s_desc_size;		/* Group desc. size: INCOMPAT_64BIT */
  //	__u32	s_default_mount_opts;
  //	__u32	s_first_meta_bg;	/* First metablock group */
  //	__u32	s_mkfs_time;		/* When the filesystem was created */
  //	__u32	s_jnl_blocks[17]; 	/* Backup of the journal inode */
  //	__u32	s_blocks_count_hi;	/* Blocks count high 32bits */
  //	__u32	s_r_blocks_count_hi;	/* Reserved blocks count high 32 bits*/
  //	__u32	s_free_blocks_hi; 	/* Free blocks count */
  //	__u16	s_min_extra_isize;	/* All inodes have at least # bytes */
  //	__u16	s_want_extra_isize; 	/* New inodes should reserve # bytes */
  //	__u32	s_flags;		/* Miscellaneous flags */
  //	__u16   s_raid_stride;		/* RAID stride */
  //	__u16   s_mmp_update_interval;  /* # seconds to wait in MMP checking */
  //	__u64   s_mmp_block;            /* Block for multi-mount protection */
  //	__u32   s_raid_stripe_width;    /* blocks on all data disks (N*stride)*/
  //	__u8	s_log_groups_per_flex;	/* FLEX_BG group size */
  //	__u8    s_reserved_char_pad;
  //	__u16	s_reserved_pad;		/* Padding to next 32bits */
  //	__u64	s_kbytes_written;	/* nr of lifetime kilobytes written */
  //	__u32	s_snapshot_inum;	/* Inode number of active snapshot */
  //	__u32	s_snapshot_id;		/* sequential ID of active snapshot */
  //	__u64	s_snapshot_r_blocks_count; /* reserved blocks for active
  //					      snapshot's future use */
  //	__u32	s_snapshot_list;	/* inode number of the head of the on-disk sn////////////////////////////////////apshot list */
  //#define EXT4_S_ERR_START ext4_offsetof(struct ext2_super_block, s_error_count)
  //	__u32	s_error_count;		/* number of fs errors */
  //	__u32	s_first_error_time;	/* first time an error happened */
  //	__u32	s_first_error_ino;	/* inode involved in first error */
  //	__u64	s_first_error_block;	/* block involved of first error */
  //	__u8	s_first_error_func[32];	/* function where the error happened */
  //	__u32	s_first_error_line;	/* line number where error happened */
  //	__u32	s_last_error_time;	/* most recent time of an error */
  //	__u32	s_last_error_ino;	/* inode involved in last error */
  //	__u32	s_last_error_line;	/* line number where error happened */
  //	__u64	s_last_error_block;	/* block involved of last error */
  //	__u8	s_last_error_func[32];	/* function where the error happened */
  //#define EXT4_S_ERR_END ext4_offsetof(struct ext2_super_block, s_mount_opts)
  //	__u8	s_mount_opts[64];
  //	__u32	s_usr_quota_inum;	/* inode number of user quota file */
  //	__u32	s_grp_quota_inum;	/* inode number of group quota file */
  //	__u32	s_overhead_blocks;	/* overhead blocks/clusters in fs */
  //	__u32   s_reserved[108];        /* Padding to the end of the block */
  //	__u32	s_checksum;		/* crc32c(superblock) */
  //
  //

  ext2_filsys efs;
  ext2fs_open(argv[1],/*flags */ 0, /* superblock */0, /*blocksize*/0, /* io_manager manager */ unix_io_manager, /* ext2_filsys *ret_fs*/ &efs );

}
int usage()
{
      printf("Usage: parse-ext IMAGEFILE\n");
      exit(1);
}