#include <stdio.h>
#include <linux/ext2_fs.h>
#include <sys/stat.h>
#include <unistd.h>

FILE *f;
struct ext2_super_block esb;
struct ext2_inode eino;
struct ext2_group_desc egroup;
long groups;
__u32 blocksize;


void Halt(char *message)
 {
  printf(message);
  exit(1);
 }

void seekToBlock(__u32 blocknr)
 {
  fseek(f,blocknr*blocksize,SEEK_SET);
 }

void readSuperBlock(__u32 base)
 {
  fseek(f,base+0x400,SEEK_SET);
  if (fread(&esb,1,sizeof esb,f)<sizeof esb) Halt("Superblock read failed!\n");
  if (esb.s_magic!=EXT2_SUPER_MAGIC) Halt("Doesn't look like ext2!\n");

  blocksize=EXT2_MIN_BLOCK_SIZE<<esb.s_log_block_size;
  groups=(esb.s_blocks_count+esb.s_blocks_per_group-1)/esb.s_blocks_per_group;

  printf("Inode groups: %d/%d\n",esb.s_inodes_count,esb.s_inodes_per_group);
  printf("Block groups: %d/%d -> %d groups\n",esb.s_blocks_count,esb.s_blocks_per_group,groups);
  printf("1 block = %d bytes\n",blocksize);
 }

void readGroup(__u32 base,__u32 grnum)
 {
  fseek(f,base+(1+esb.s_first_data_block)*blocksize+grnum*sizeof(egroup),SEEK_SET);
  if (fread(&egroup,1,sizeof egroup,f)<sizeof egroup) Halt("Group read failed!\n");
 }


FILE *fo;

void dumpBlock(__u32 blocknr, __u32 *len)
 {
  char buffer[blocksize];
  __u32 toread;
  
  toread=*len>blocksize?blocksize:*len;
  
  seekToBlock(blocknr);
  if (fread(&buffer,1,toread,f)<toread)
   {
    printf("Problem reading block !\n");
    return;
   }
  fwrite(&buffer,1,toread,fo);
  *len-=toread;
 }

void dumpBlocks(__u32 idxblock,__u32 *sizetodump, int depth)
 {
  __u32 blocklist[blocksize/sizeof(__u32)];
  int i;
  
  if (*sizetodump<=0) return;
  
  if (depth==0) { dumpBlock(idxblock,sizetodump); return; }
  
  seekToBlock(idxblock);
  if (fread(&blocklist,1,blocksize,f)<blocksize)
   {
    printf("Problem reading block !\n");
    return;
   }
  for (i=0;*sizetodump>0,i<blocksize/sizeof(__u32);i++) dumpBlocks(blocklist[i],sizetodump,depth-1);
 }


void dumpIt(char *where)
 {
  __u32 i,isize;
  __u32 opos=ftell(f);
  char buffer[blocksize];
  
  if (!(fo=fopen(where,"wb")))
   { 
    printf("Error opening %d for dump\n",where);
    return;
   }
  
  if (!(isize=eino.i_size)) isize=blocksize*eino.i_blocks;
  
  for (i=0;isize>0,i<EXT2_IND_BLOCK;i++) dumpBlocks(eino.i_block[i],&isize,0);
  dumpBlocks(eino.i_block[EXT2_IND_BLOCK],&isize,1);
  dumpBlocks(eino.i_block[EXT2_DIND_BLOCK],&isize,2);
  
  fclose(fo);
  fseek(f,opos,SEEK_SET);
 }

void parseInodes(__u32 base, __u32 grnum)
 {
  __u32 i;
  char tmp[1000];
  
  fseek(f,base+egroup.bg_inode_table*blocksize,SEEK_SET);
  for (i=0;i<esb.s_inodes_per_group;i++)
   {
    if (fread(&eino,1,sizeof eino,f)<sizeof eino) Halt("Inode table read failed!\n");
    
//    if (!eino.i_dtime) continue;
    if (!eino.i_mode) continue;
    
    if (S_ISDIR(eino.i_mode))
     {
      sprintf(tmp,"dirs/%.5x.dir",grnum*esb.s_inodes_per_group+i+1);
      dumpIt(tmp);
     }
/*    else if (S_ISREG(eino.i_mode))
     {
      sprintf(tmp,"files/%.5x.file",grnum*esb.s_inodes_per_group+i+1);
      dumpIt(tmp);
     }*/
    printf("Inode %.5x   ",grnum*esb.s_inodes_per_group+i+1);
    printf("Type: %8o  UID: %5d  GID: %5d  Size: %8d   ",eino.i_mode,eino.i_uid,eino.i_gid,eino.i_size);
    strcpy(tmp,"  A: "); if (!eino.i_atime) strcat(tmp,"0"); else { strcat(tmp,ctime(&eino.i_atime)); tmp[strlen(tmp)-1]='\0'; }
    strcat(tmp,"  C: "); if (!eino.i_ctime) strcat(tmp,"0"); else { strcat(tmp,ctime(&eino.i_ctime)); tmp[strlen(tmp)-1]='\0'; }
    strcat(tmp,"  M: "); if (!eino.i_mtime) strcat(tmp,"0"); else { strcat(tmp,ctime(&eino.i_mtime)); tmp[strlen(tmp)-1]='\0'; }
    strcat(tmp,"  D: "); if (!eino.i_dtime) strcat(tmp,"0"); else { strcat(tmp,ctime(&eino.i_dtime)); tmp[strlen(tmp)-1]='\0'; }
    printf("  %s\n",tmp);
   }
 }

void parseBlocks()
 {
  __u32 i,j,tl;
  char tmp[100];
  char block[blocksize];
  char mask[0x18]={0xff, 0xff, 0xff, 0xff,0,0,0,0,0,0xff,0xff,0xff,
                   0xff, 0xff, 0xff, 0xff,0xff,0xff,0,0,0,0,0xff,0xff};
  char pattern[0x18]={0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x01, 0x02, 0x2e, 0xff, 0xff, 0xff,
                      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x02, 0x02, 0x2e, 0x2e, 0xff, 0xff};
  
  rewind(f);
  for (i=0;i<esb.s_blocks_count;i++)
   {
    if (fread(&block,1,blocksize,f)<blocksize)
     {
      printf("Error reading block\n");
      continue;
     }
    if (i%1024==0) printf("%d\n",i/1024);
    for (j=0;j<sizeof(mask);j++) if ((block[j]|mask[j])!=pattern[j]) break;
    if (j<sizeof(mask)) continue;
    printf("Block %.5x looks like a directory\n",i);
    sprintf(tmp,"dumps/%.5x.dump",i);
    fo=fopen(tmp,"wb");
    tl=blocksize;
    dumpBlock(i,&tl);
    fclose(fo);
   }
 }

void goo()
 {
  __u32 xxx=13*1048576;
  fo=fopen("gogo","wb");
  dumpBlocks(0x16237,&xxx,2);
  fclose(fo);
 }

void main(int argc, char *argv[])
 {
  int i;
  if (argc<2) return;
  if (!(f=fopen(argv[1],"rb"))) return;
  
  readSuperBlock(0);
  
//  goo();
  printf("\nPHASE 1\n\n");
  for (i=0;i<groups;i++)
   {
    printf("Analysing group %d\n",i);
    readGroup(0,i);
    parseInodes(0,i);
   }

  printf("\nPHASE 2\n\n");
  parseBlocks();
 }