/**

* Ext2read

* File: ext2fs.cpp

**/

/**

* Copyright (C) 2005 2010 by Manish Regmi (regmi dot manish at gmail.com)

*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the

* Free Software Foundation, Inc.,

* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

**/

#include "ext2read.h"

#include "lvm.h"

Ext2Partition::Ext2Partition(lloff_t size, lloff_t offset, int ssize, FileHandle phandle, LogicalVolume *vol)

}

Ext2Partition::~Ext2Partition()

{

free (desc);

}

void Ext2Partition::set_linux_name(const char *name, int disk, int partition)

}

string &Ext2Partition::get_linux_name()

{

return linux_name;

}

int Ext2Partition::ext2_readblock(lloff_t blocknum, void *buffer)

}

int Ext2Partition::mount()

}

EXT2DIRENT *Ext2Partition::open_dir(Ext2File *parent)

{

EXT2DIRENT *dirent;

if(!parent)

return NULL;

dirent = new EXT2DIRENT;

dirent->parent = parent;

dirent->next = NULL;

dirent->dirbuf = NULL;

dirent->read_bytes = 0;

dirent->next_block = 0;

return dirent;

}

Ext2File *Ext2Partition::read_dir(EXT2DIRENT *dirent)

{

string filename;

Ext2File *newEntry;

char *pos;

int ret;

if(!dirent)

return NULL;

if(!dirent->dirbuf)

{

dirent->dirbuf = (EXT2_DIR_ENTRY *) new char[blocksize];

if(!dirent->dirbuf)

return NULL;

ret = read_data_block(&dirent->parent->inode, dirent->next_block, dirent->dirbuf);

if(ret < 0)

return NULL;

dirent->next_block++;

}

again:

if(!dirent->next)

dirent->next = dirent->dirbuf;

else

{

pos = (char *) dirent->next;

dirent->next = (EXT2_DIR_ENTRY *)(pos + dirent->next->rec_len);

if(IS_BUFFER_END(dirent->next, dirent->dirbuf, blocksize))

{

dirent->next = NULL;

if(dirent->read_bytes < dirent->parent->file_size)

{

//LOG("DIR: Reading next block %d parent %s\n", dirent->next_block, dirent->parent->file_name.c_str());

ret = read_data_block(&dirent->parent->inode, dirent->next_block, dirent->dirbuf);

if(ret < 0)

return NULL;

dirent->next_block++;

goto again;

}

return NULL;

}

}

dirent->read_bytes += dirent->next->rec_len;

filename.assign(dirent->next->name, dirent->next->name_len);

if((filename.compare(".") == 0) ||

(filename.compare("..") == 0))

goto again;

newEntry = read_inode(dirent->next->inode);

if(!newEntry)

{

LOG("Error reading Inode %d parent inode %d.\n", dirent->next->inode, dirent->parent->inode_num);

return NULL;

}

newEntry->file_type = dirent->next->filetype;

newEntry->file_name = filename;

return newEntry;

}

void Ext2Partition::close_dir(EXT2DIRENT *dirent)

}

Ext2File *Ext2Partition::read_inode(uint32_t inum)

{

uint32_t group, index, blknum;

int inode_index, ret = 0;

Ext2File *file = NULL;

EXT2_INODE *src;

if(inum == 0)

return NULL;

if(!inode_buffer)

{

inode_buffer = (char *)malloc(blocksize);

if(!inode_buffer)

return NULL;

}

group = (inum - 1) / inodes_per_group;

if(group > totalGroups)

{

LOG("Error Reading Inode %X. Invalid Inode Number\n", inum);

return NULL;

}

index = ((inum - 1) % inodes_per_group) * inode_size;

inode_index = (index % blocksize);

blknum = desc[group].bg_inode_table + (index / blocksize);

if(blknum != last_block)

ret = ext2_readblock(blknum, inode_buffer);

file = new Ext2File;

if(!file)

{

LOG("Allocation of File Failed. \n");

return NULL;

}

src = (EXT2_INODE *)(inode_buffer + inode_index);

file->inode = *src;

//LOG("BLKNUM is %d, inode_index %d\n", file->inode.i_size, inode_index);

file->inode_num = inum;

file->file_size = (lloff_t) src->i_size | ((lloff_t) src->i_size_high << 32);

if(file->file_size == 0)

{

LOG("Inode %d with file size 0\n", inum);

}

file->partition = (Ext2Partition *)this;

file->onview = false;

last_block = blknum;

return file;

}

int Ext2Partition::read_data_block(EXT2_INODE *ino, lloff_t lbn, void *buf)

}

lloff_t Ext2Partition::extent_binarysearch(EXT4_EXTENT_HEADER *header, lloff_t lbn, bool isallocated)

}

lloff_t Ext2Partition::extent_to_logical(EXT2_INODE *ino, lloff_t lbn)

}

uint32_t Ext2Partition::fileblock_to_logical(EXT2_INODE *ino, uint32_t lbn)

}