diff options
Diffstat (limited to 'src/lookup_local.c')
| -rw-r--r-- | src/lookup_local.c | 732 |
1 files changed, 732 insertions, 0 deletions
diff --git a/src/lookup_local.c b/src/lookup_local.c new file mode 100644 index 0000000..f77f00d --- /dev/null +++ b/src/lookup_local.c @@ -0,0 +1,732 @@ +/*************************************************************************** + * Copyright (C) 2010 by Roberto Maar * + * robi@users.berlios.de * + * * + * 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. * + ***************************************************************************/ +//header util.h + +#include <stdio.h> +#include <string.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif + +#include <ext2fs/ext2fs.h> +#include <ext2fs/ext2_io.h> +#include "ext2fsP.h" +#include <ctype.h> +#include <time.h> +#include "dir_list.h" +#include "util.h" +#include "inode.h" + +extern ext2_filsys current_fs ; + +static const char *monstr[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + + + +// local sub function for printing the dir entry +static int list_dir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + int entry, + struct ext2_dir_entry *dirent, + int offset EXT2FS_ATTR((unused)), + int blocksize EXT2FS_ATTR((unused)), + char *buf EXT2FS_ATTR((unused)), + void *private) +{ + struct ext2_inode inode; + ext2_ino_t ino; + struct tm *tm_p; + time_t modtime; + char name[EXT2_NAME_LEN + 1]; + char tmp[EXT2_NAME_LEN + 16]; + char datestr[80]; + char lbr, rbr; + int thislen,retval = 0; + int col = 0; + struct priv_dir_iterate_struct *ls = (struct priv_dir_iterate_struct *) private; + + thislen = ((dirent->name_len & 0xFF) < EXT2_NAME_LEN) ? + (dirent->name_len & 0xFF) : EXT2_NAME_LEN; + strncpy(name, dirent->name, thislen); + name[thislen] = '\0'; + ino = dirent->inode; + +//FIXME: + // if ((entry == DIRENT_DELETED_FILE) || (ls->options & DELETED_DIR)) { + if (entry == DIRENT_DELETED_FILE) { + lbr = '<'; + rbr = '>'; + } else { + lbr = rbr = ' '; + } + if (ls->options & PARSE_OPT) { + if (ino && intern_read_inode(ino, &inode)) return 0; + fprintf(stdout,"/%u/%06o/%d/%d/%s/",ino,inode.i_mode,inode.i_uid, inode.i_gid,name); + if (LINUX_S_ISDIR(inode.i_mode)) + fprintf(stdout, "/"); + else + fprintf(stdout, "%lld/", inode.i_size | ((__u64)inode.i_size_high << 32)); + fprintf(stdout, "\n"); + } + else if (ls->options & LONG_OPT) { + if ((ino && (ino <= current_fs->super->s_inodes_count))) { + if (ls->options & ONLY_JOURNAL) + retval = read_journal_inode( ino,&inode, ls->transaction->start); + if (retval || !(ls->options & ONLY_JOURNAL)) + if (intern_read_inode(ino, &inode)) + return 0; + modtime = inode.i_mtime; + tm_p = localtime(&modtime); + sprintf(datestr, "%2d-%s-%4d %02d:%02d", + tm_p->tm_mday, monstr[tm_p->tm_mon], + 1900 + tm_p->tm_year, tm_p->tm_hour, + tm_p->tm_min); + } else { + strcpy(datestr, " "); + memset(&inode, 0, sizeof(struct ext2_inode)); + } + fprintf(stdout, "%c%8u%c %c %4o (%d) %5d %5d ", lbr, ino, rbr, get_inode_mode_type(inode.i_mode),inode.i_mode & 07777 , dirent->name_len >> 8, inode_uid(inode), inode_gid(inode)); + if (LINUX_S_ISDIR(inode.i_mode)) + fprintf(stdout, "%5d", inode.i_size); + else + fprintf(stdout, "%5llu", inode.i_size | + ((unsigned long long) inode.i_size_high << 32)); + fprintf (stdout, " %s %s\n", datestr, name); + } else { + sprintf(tmp, "%c%u%c (%d) %s ", lbr, dirent->inode, rbr, + dirent->rec_len, name); + thislen = strlen(tmp); + + if (col + thislen > 80) { + fprintf(stdout, "\n"); + col = 0; + } + fprintf(stdout, "%s", tmp); + col += thislen; + } + return 0; +} + + +// list dir by using real fs inode and real fs dir blocks an real dir-entry-inodes +void list_dir(ext2_ino_t inode) +{ + int retval; + int flags; + struct priv_dir_iterate_struct ls; + + ls.options = 0; + if (!inode) return; + + ls.options |= LONG_OPT; + ls.options |= DELETED_OPT; + + flags = DIRENT_FLAG_INCLUDE_EMPTY; + if (ls.options & DELETED_OPT) flags |= DIRENT_FLAG_INCLUDE_REMOVED; + + retval = ext2fs_dir_iterate2(current_fs, inode, flags,0, list_dir_proc, &ls); + fprintf(stdout, "\n"); + if (retval) + fprintf(stderr,"Error %d \n", retval); + + return; +} + + + + + +//--------------------------------------------------------------- +/* + * This function checks to see whether or not a potential deleted + * directory entry looks valid. What we do is check the deleted entry + * and each successive entry to make sure that they all look valid and + * that the last deleted entry ends at the beginning of the next + * undeleted entry. Returns 1 if the deleted entry looks valid, zero + * if not valid. + * + * copy of a not public function from e2fsprogs ext2fs_validate_entry() + * use only from local_process_dir_block() + */ +static int local_validate_entry(ext2_filsys fs, char *buf, + unsigned int offset, + unsigned int final_offset) +{ + struct ext2_dir_entry *dirent; + unsigned int rec_len = 0; + +#define DIRENT_MIN_LENGTH 12 + + while ((offset < final_offset) && + (offset <= fs->blocksize - DIRENT_MIN_LENGTH)) { + dirent = (struct ext2_dir_entry *)(buf + offset); + if (ext2fs_get_rec_len(fs, dirent, &rec_len)) + return 0; + + offset += rec_len; + if ((rec_len < 8) || + ((rec_len % 4) != 0) || + ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) + return 0; + } + + return (offset == final_offset); +} + + + +// convert dir_block for bigendian inclusive deleted entry +static int convert_dir_block(char *buf, int flags){ + errcode_t retval; + char *p, *end; + struct ext2_dir_entry *dirent; + unsigned int name_len, rec_len; + + p = (char *) buf; + end = (char *) buf + current_fs->blocksize; + while (p < end-8) { + dirent = (struct ext2_dir_entry *) p; +#ifdef WORDS_BIGENDIAN + dirent->inode = ext2fs_swab32(dirent->inode); + dirent->rec_len = ext2fs_swab16(dirent->rec_len); + dirent->name_len = ext2fs_swab16(dirent->name_len); +#endif + name_len = dirent->name_len; +#ifdef WORDS_BIGENDIAN + if (flags & EXT2_DIRBLOCK_V2_STRUCT) + dirent->name_len = ext2fs_swab16(dirent->name_len); +#endif + if ((retval = ext2fs_get_rec_len(current_fs, dirent, &rec_len)) != 0) + return retval; + if ((rec_len < 8) || (rec_len % 4)) { + rec_len = 8; + retval = EXT2_ET_DIR_CORRUPTED; + } else if (((name_len & 0xFF) + 8) > rec_len) + retval = EXT2_ET_DIR_CORRUPTED; + // p += rec_len; + p += ((name_len & 0xFF) + 11) & ~3; + } + return retval; +} + + +/* + * Helper function which is private to this module. Used by + * local_dir_iterate3() (modi of ext2fs_process_dir_block + */ + static int local_process_dir_block(ext2_filsys fs, + blk_t *blocknr, + e2_blkcnt_t blockcnt, + blk_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct dir_context *ctx = (struct dir_context *) priv_data; + unsigned int offset = 0; + unsigned int next_real_entry = 0; + int ret = 0; + int changed = 0; + int do_abort = 0; + unsigned int rec_len, size; + int entry; + struct ext2_dir_entry *dirent; + trans_range_t *transaction = NULL; + + if (blockcnt < 0) + return 0; + entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE; + + transaction = (trans_range_t*) ((struct priv_dir_iterate_struct*)ctx->priv_data)->transaction; + if (get_last_block(ctx->buf, blocknr, transaction->start, transaction->end)){ + if (ctx->flags & ONLY_JOURNAL ) return BLOCK_ABORT; +//FIXME: if not found dir-block in journal, read from real filesystem and hope is ok ?????? + ctx->errcode = io_channel_read_blk(fs->io, *blocknr, 1, ctx->buf); + } +#ifdef WORDS_BIGENDIAN + if(!ctx->errcode) + ctx->errcode = convert_dir_block(ctx->buf,0); +#endif + if (ctx->errcode) + return BLOCK_ABORT; + + while (offset < fs->blocksize) { + dirent = (struct ext2_dir_entry *) (ctx->buf + offset); + if (ext2fs_get_rec_len(fs, dirent, &rec_len)) + return BLOCK_ABORT; + if (((offset + rec_len) > fs->blocksize) || + (rec_len < 8) || + ((rec_len % 4) != 0) || + ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) { + + ctx->errcode = EXT2_ET_DIR_CORRUPTED; + return BLOCK_ABORT; + } + if (!dirent->inode && + !(ctx->flags & DIRENT_FLAG_INCLUDE_EMPTY)) + goto next; + + ret = (ctx->func)(ctx->dir, + (next_real_entry > offset) ? + DIRENT_DELETED_FILE : entry, + dirent, offset, + fs->blocksize, ctx->buf, + ctx->priv_data); + if (entry < DIRENT_OTHER_FILE) + entry++; + + if (ret & DIRENT_CHANGED) { + if (ext2fs_get_rec_len(fs, dirent, &rec_len)) + return BLOCK_ABORT; + changed++; + } + if (ret & DIRENT_ABORT) { + do_abort++; + break; + } +next: + if (next_real_entry == offset) + next_real_entry += rec_len; + + if (ctx->flags & DIRENT_FLAG_INCLUDE_REMOVED) { + size = ((dirent->name_len & 0xFF) + 11) & ~3; + + if (rec_len != size) { + unsigned int final_offset = 0; + + final_offset = offset + rec_len; + offset += size; + while (offset < final_offset && + !local_validate_entry(fs, ctx->buf, + offset, + final_offset)) + offset += 4; + continue; + } + } + offset += rec_len; + } + + if (changed) { + ctx->errcode = ext2fs_write_dir_block(fs, *blocknr, ctx->buf); + if (ctx->errcode) + return BLOCK_ABORT; + } + if (do_abort) + return BLOCK_ABORT; + return 0; +} + + + + +//------------------------------------------------------ +// Sub function for search the path, use from get_dir3() +static int find_dir_proc(ext2_ino_t dir EXT2FS_ATTR((unused)), + int entry, + struct ext2_dir_entry *dirent, + int offset EXT2FS_ATTR((unused)), + int blocksize EXT2FS_ATTR((unused)), + char *buf EXT2FS_ATTR((unused)), + void *private) +{ + ext2_ino_t ino; + char name[EXT2_NAME_LEN + 1]; + int thislen; + struct priv_dir_iterate_struct *fl = (struct priv_dir_iterate_struct *) private; + + thislen = ((dirent->name_len & 0xFF) < EXT2_NAME_LEN) ? + (dirent->name_len & 0xFF) : EXT2_NAME_LEN; + if (thislen){ + strncpy(name, dirent->name, thislen); + name[thislen] = '\0'; + ino = dirent->inode; + + if ((ino) && (ino <= current_fs->super->s_inodes_count)) + add_list_item(fl->dir_list,ino,name,(char) entry); + } + return 0; +} + + + + +//------------------------------------------------------- +// local directory iterate for use inode +static errcode_t local_dir_iterate3(ext2_filsys fs, + ext2_ino_t dir, + struct ext2_inode *inode, + int flags, + char *block_buf, + int (*func)(ext2_ino_t dir, + int entry, + struct ext2_dir_entry *dirent, + int offset, + int blocksize, + char *buf, + void *priv_data), + void *priv_data) +{ + struct dir_context ctx; + errcode_t retval; + + EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); + + ctx.dir = dir; + ctx.flags = flags; + if (block_buf) + ctx.buf = block_buf; + else { + retval = ext2fs_get_mem(fs->blocksize, &ctx.buf); + if (retval) + return retval; + } + ctx.func = func; + ctx.priv_data = priv_data; + ctx.errcode = 0; + retval = local_block_iterate3(fs, *inode, BLOCK_FLAG_READ_ONLY, 0, + local_process_dir_block, &ctx); + if (!block_buf) + ext2fs_free_mem(&ctx.buf); + if (retval) + return retval; + return ctx.errcode; +} + + + + + +// list dir over journal inode use real fs dir blocks an real dir-entry-inodes +void list_dir2(ext2_ino_t ino, struct ext2_inode *inode) +{ + int retval; + int flags; + struct priv_dir_iterate_struct ls; + + ls.options = 0; + if (!ino || (! LINUX_S_ISDIR(inode->i_mode))) return; + + ls.options |= LONG_OPT; + ls.options |= DELETED_OPT; + if (! ext2fs_test_inode_bitmap ( current_fs->inode_map, ino )) ls.options |= DELETED_DIR ; + + flags = DIRENT_FLAG_INCLUDE_EMPTY; + if (ls.options & DELETED_OPT) flags |= DIRENT_FLAG_INCLUDE_REMOVED; + + retval = local_dir_iterate3(current_fs,ino, inode, flags,0, list_dir_proc, &ls); + fprintf(stdout, "\n"); + if (retval) + fprintf(stderr,"Error %d \n", retval); + + return; +} + + + + +//-------------------------------------------------- +// +// local sub function +// load dir-index in a dir_list + struct dir_list_head_t* get_dir3(struct ext2_inode* d_inode,ext2_ino_t path_ino, ext2_ino_t ino, + char* path, char* name, + __u32 t_after , __u32 t_before, + int options ) +{ + int retval; + int flags; + struct ext2_inode* inode; + struct ring_buf *i_list = NULL; + r_item *item = NULL; + struct priv_dir_iterate_struct fl; + struct dir_list_head_t * l_dir = NULL; + + if(d_inode) d_inode->i_links_count = 0; //set flag for test + i_list = (struct ring_buf*) get_j_inode_list(current_fs->super, ino); + if (! i_list) return NULL; + + item = get_undel_inode(i_list , t_after , t_before); + if ( item && item->inode ) { + inode = (struct ext2_inode*)item->inode; + if(d_inode) + memcpy(d_inode,inode,current_fs->super->s_inode_size); + if (!ino || (! LINUX_S_ISDIR(inode->i_mode))) + goto errout; + +//get dir + l_dir = new_dir_list ( path_ino,ino, path, name); + if (l_dir) + { + fl.options = options; + fl.dir_list = l_dir; + fl.transaction = &item->transaction; + +// flags = DIRENT_FLAG_INCLUDE_EMPTY; + flags = 0; + if (options & DELETED_OPT ) flags |= DIRENT_FLAG_INCLUDE_REMOVED; + retval = local_dir_iterate3(current_fs,ino, inode, flags,0, find_dir_proc, &fl); + if (retval ) + fprintf(stderr,"Warning: ERROR %d can not found the file: %s\n", retval, path); + } + } + +errout: + if (i_list) + ring_del(i_list); + return (l_dir) ? clean_up_dir_list(l_dir) : NULL ; +} + + + +// main worker function for recover and list +// lookup_local() : search recursiv through the filesystem +// use inode and dirblocks from journal +// flag = 0 only undelete, flag = 2 process all +void lookup_local(char* des_dir, struct dir_list_head_t * dir, __u32 t_after , __u32 t_before, int flag){ + struct dir_list_head_t *d_list = NULL; + struct dir_list_t *lp; + struct ext2_inode* inode = NULL; + struct ring_buf *i_list = NULL; + r_item *item = NULL; + char c = ' '; + int allocated; + + if (! dir) { + d_list = get_dir3(NULL, EXT2_ROOT_INO , EXT2_ROOT_INO , "","", t_after,t_before, flag); + if (!d_list) return; +//recursion + lookup_local(des_dir,d_list, t_after, t_before, flag); + } + else { + if (flag & DOUPLE_QUOTES_LIST) + c = '"'; + lp = GET_FIRST(dir); + inode = malloc(current_fs->super->s_inode_size); + while (lp){ + if (! strcmp(lp->filename,"..")) { + if ((dir->path_inode != lp->inode_nr) && (dir->path_inode != 0)) break; + lp = GET_NEXT(dir,lp); + continue; + } + if (! strcmp(lp->filename,".")) + { +// prefunction for directory + switch (flag & REC_FILTER){ + case LIST_ALL : + if (dir->dir_inode != lp->inode_nr) break; + printf("DIR %lu %c%s%c\n",lp->inode_nr,c,dir->pathname,c); + break; + case LIST_STATUS : + break; + case RECOV_DEL : + break; + case RECOV_ALL : + //create_all_dir(des_dir,dir->pathname, lp->inode_nr); + break; + case HIST_DIR : + add_coll_list(lp->inode_nr); + break; + } + + } + else{ + d_list = get_dir3(inode, dir->dir_inode,lp->inode_nr, + dir->pathname,lp->filename,t_after,t_before, flag); + + if (d_list){ +//recursion for directory + lookup_local(des_dir, d_list, t_after, t_before, flag); + } + else{ +//function for all files apart from dir + switch (flag & REC_FILTER){ + case LIST_ALL : + printf("--- %lu %c%s%s%s%c\n",lp->inode_nr,c,dir->pathname, + ((strlen(dir->pathname) > 0) && strcmp(dir->pathname,"/")) ? "/" : "", + lp->filename,c); + break; + case LIST_STATUS : + allocated = check_file_recover(inode); + if (allocated) + printf("%5u%% %c%s%s%s%c\n",allocated,c,dir->pathname, + ((strlen(dir->pathname) > 0) && strcmp(dir->pathname,"/")) ? "/" : "", + lp->filename,c); + break; + case RECOV_DEL : + if (inode->i_links_count) + recover_file(des_dir,dir->pathname, lp->filename, inode, lp->inode_nr,1); + break; + case RECOV_ALL : + if (inode->i_links_count) + recover_file(des_dir,dir->pathname, lp->filename, inode, lp->inode_nr,0); + break; + case HIST_DIR : + add_coll_list(lp->inode_nr); + break; + } + + } + if (d_list) clear_dir_list(d_list); + d_list = NULL; + } + lp = GET_NEXT(dir,lp); + } + + //if (inode) + free(inode); + + +// postfunction for directory + switch (flag & REC_FILTER){ + case LIST_ALL : + break; + case LIST_STATUS : + break; + case RECOV_DEL : + break; + case RECOV_ALL : + i_list = get_j_inode_list(current_fs->super, dir->dir_inode); + if (! i_list) break; + item = get_undel_inode(i_list , t_after , t_before); + if (item) + set_dir_attributes(des_dir, dir->pathname,(struct ext2_inode*)item->inode); + if (i_list) ring_del(i_list); + break; + case HIST_DIR : + break; + } + + } +if(d_list) + clear_dir_list(d_list); +} + + + +// list dir over journal inode and journal dir blocks an journal dir-entry-inodes +void list_dir3(ext2_ino_t ino, struct ext2_inode *inode, trans_range_t* transaction) +{ + int retval; + int flags; + struct priv_dir_iterate_struct ls; + + ls.options = 0; + if (!ino || (! LINUX_S_ISDIR(inode->i_mode))) return; + + ls.options |= LONG_OPT; + ls.options |= DELETED_OPT; + ls.options |= ONLY_JOURNAL; + + if (! ext2fs_test_inode_bitmap ( current_fs->inode_map, ino )) ls.options |= DELETED_DIR ; + + ls.transaction = transaction; + + flags = DIRENT_FLAG_INCLUDE_EMPTY + ONLY_JOURNAL; + + if (ls.options & DELETED_OPT) flags |= DIRENT_FLAG_INCLUDE_REMOVED; + + retval = local_dir_iterate3(current_fs,ino, inode, flags,0, list_dir_proc, &ls); + fprintf(stdout, "\n"); + if (retval) + fprintf(stderr,"Error %d \n", retval); + + return; +} + + + +// search the Inode for an pathname (recursiv function) +ext2_ino_t local_namei(struct dir_list_head_t * dir, char *path, __u32 t_after , __u32 t_before, int flag){ + struct dir_list_head_t *d_list = NULL; + struct dir_list_t *lp; + ext2_ino_t ret_inode = 0; + char *p_path = NULL; + char *p1; + char c; + char *p2; + + if (! dir) { + d_list = get_dir3(NULL,EXT2_ROOT_INO , EXT2_ROOT_INO , "","", t_after,t_before, flag); + if (!d_list) { + fprintf(stderr,"no rootdir at filesystem found\n"); + return 0; + } + ret_inode = local_namei(d_list, path, t_after, t_before, flag); + } + else { +// Check end recursion + if (!(strlen(path))) { + ret_inode = dir->dir_inode; + goto out; + } + + p_path = (char*) malloc(strlen(path)+1); + p2 = p_path; + p1 = path + strspn(path,"/"); + c = *p1; + while ( c != '/' ){ + *p2++ = c; + if (c == 0) break; + p1++; + c = *p1; + } + if ( c ) *p2 = 0; + + lp = GET_FIRST(dir); + while (lp){ + if (! strcmp(lp->filename,"..")) { + if (dir->path_inode != lp->inode_nr) { + break; + } + } + if (! strcmp(lp->filename,".")) + { + if (dir->dir_inode != lp->inode_nr) { + break; + } + } + else{ + if (strcmp( p_path , lp->filename)) { + lp = GET_NEXT(dir,lp); + continue; + } + d_list = get_dir3(NULL,dir->dir_inode,lp->inode_nr,dir->pathname,lp->filename,t_after,t_before, flag); + if (d_list){ + ret_inode = local_namei(d_list, p1, t_after, t_before, flag); +// break if found + if (ret_inode) goto out; + } + else{ +// recursions end (file find) + ret_inode = lp->inode_nr; + goto out; + } + } + lp = GET_NEXT(dir,lp); + } + } +out: +if(p_path) + free(p_path); +if(d_list) + clear_dir_list(d_list); + +return ret_inode; +} |