diff options
Diffstat (limited to '')
| -rw-r--r-- | ext2ed/dir_com.c | 678 |
1 files changed, 678 insertions, 0 deletions
diff --git a/ext2ed/dir_com.c b/ext2ed/dir_com.c new file mode 100644 index 0000000..67bb4b5 --- /dev/null +++ b/ext2ed/dir_com.c @@ -0,0 +1,678 @@ +/* + +/usr/src/ext2ed/dir_com.c + +A part of the extended file system 2 disk editor. + +-------------------- +Handles directories. +-------------------- + +This file contains the codes which allows the user to handle directories. + +Most of the functions use the global variable file_info (along with the special directory fields there) to save +information and pass it between them. + +Since a directory is just a big file which is composed of directory entries, you will find that +the functions here are a superset of those in the file_com.c source. + +We assume that the user reached here using the dir command of the inode type and not by using settype dir, so +that init_dir_info is indeed called to gather the required information. + +type_data is not changed! It still contains the inode of the file - We handle the directory in our own +variables, so that settype ext2_inode will "go back" to the inode of this directory. + +First written on: April 28 1995 + +Copyright (C) 1995 Gadi Oxman + +*/ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "ext2ed.h" + +char name_search [80]; +long entry_num_search; + +int init_dir_info (struct struct_file_info *info_ptr) + +/* + +This function is called by the inode of the directory when the user issues the dir command from the inode. +It is used to gather information about the inode and to reset some variables which we need in order to handle +directories. + +*/ + +{ + struct ext2_inode *ptr; + + ptr=&type_data.u.t_ext2_inode; /* type_data contains the inode */ + + info_ptr->inode_ptr=ptr; + info_ptr->inode_offset=device_offset; /* device offset contains the inode's offset */ + + /* Reset the current position to the start */ + + info_ptr->global_block_num=ptr->i_block [0]; + info_ptr->global_block_offset=ptr->i_block [0]*file_system_info.block_size; + info_ptr->block_num=0; + info_ptr->file_offset=0; + /* Set the size of the directory */ + + info_ptr->blocks_count=(ptr->i_size+file_system_info.block_size-1)/file_system_info.block_size; + info_ptr->file_length=ptr->i_size; + + info_ptr->level=0; /* We start using direct blocks */ + info_ptr->display=HEX; /* This is not actually used */ + + info_ptr->dir_entry_num=0;info_ptr->dir_entries_count=0; /* We'll start at the first directory entry */ + info_ptr->dir_entry_offset=0; + + /* Find dir_entries_count */ + + info_ptr->dir_entries_count=count_dir_entries (); /* Set the total number of entries */ + + return (1); +} + +struct struct_file_info search_dir_entries (int (*action) (struct struct_file_info *info),int *status) + +/* + This is the main function in this source file. Various actions are implemented using this basic function. + + This routine runs on all directory entries in the current directory. + For each entry, action is called. We'll act according to the return code of action: + + ABORT - Current dir entry is returned. + CONTINUE - Continue searching. + FOUND - Current dir entry is returned. + + If the last entry is reached, it is returned, along with an ABORT status. + + status is updated to the returned code of action. +*/ + +{ + struct struct_file_info info; /* Temporary variables used to */ + struct ext2_dir_entry_2 *dir_entry_ptr; /* contain the current search entries */ + int return_code, next; + + info=first_file_info; /* Start from the first entry - Read it */ + low_read (info.buffer,file_system_info.block_size,info.global_block_offset); + dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); + + while (info.file_offset < info.file_length) { /* While we haven't reached the end */ + + *status=return_code=action (&info); /* Call the client function to test */ + /* the current entry */ + if (return_code==ABORT || return_code==FOUND) + return (info); /* Stop, if so asked */ + + /* Pass to the next entry */ + + dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); + + info.dir_entry_num++; + next = dir_entry_ptr->rec_len; + if (!next) + next = file_system_info.block_size - info.dir_entry_offset; + info.dir_entry_offset += next; + info.file_offset += next; + + if (info.file_offset >= info.file_length) break; + + if (info.dir_entry_offset >= file_system_info.block_size) { /* We crossed a block boundary */ + /* Find the next block, */ + info.block_num++; + info.global_block_num=file_block_to_global_block (info.block_num,&info); + info.global_block_offset=info.global_block_num*file_system_info.block_size; + info.file_offset=info.block_num*file_system_info.block_size; + info.dir_entry_offset=0; + /* read it and update the pointer */ + + low_read (info.buffer,file_system_info.block_size,info.global_block_offset); + dir_entry_ptr=(struct ext2_dir_entry_2 *) (info.buffer+info.dir_entry_offset); + + } + + } + + *status=ABORT;return (info); /* There was no match */ +} + +long count_dir_entries (void) + +/* + +This function counts the number of entries in the directory. We just call search_dir_entries till the end. +The client function is action_count, which just tell search_dir_entries to continue. + +*/ + +{ + int status; + + return (search_dir_entries (&action_count,&status).dir_entry_num); +} + +int action_count (struct struct_file_info *info) + +/* + +Used by count_dir_entries above - This function is called by search_dir_entries, and it tells it to continue +searching, until we get to the last entry. + +*/ + +{ + return (CONTINUE); /* Just continue searching */ +} + +void type_dir___cd (char *command_line) + +/* + Changes to a directory, relative to the current directory. + + This is a complicated operation, so I would repeat here the explanation from the design and + implementation document. + +1. The path is checked that it is not an absolute path (from /). If it is, we let the general cd to do the job by + calling directly type_ext2___cd. + +2. The path is divided into the nearest path and the rest of the path. For example, cd 1/2/3/4 is divided into + 1 and into 2/3/4. + +3. It is the first part of the path that we need to search for in the current directory. We search for it using + search_dir_entries, which accepts the action_name function as the client function. + +4. search_dir_entries will scan the entire entries and will call our action_name function for each entry. + In action_name, the required name will be checked against the name of the current entry, and FOUND will be + returned when a match occurs. + +5. If the required entry is found, we dispatch a remember command to insert the current inode (remember that + type_data is still intact and contains the inode of the current directory) into the object memory. + This is required to easily support symbolic links - If we find later that the inode pointed by the entry is + actually a symbolic link, we'll need to return to this point, and the above inode doesn't have (and can't have, + because of hard links) the information necessary to "move back". + +6. We then dispatch a followinode command to reach the inode pointed by the required entry. This command will + automatically change the type to ext2_inode - We are now at an inode, and all the inode commands are available. + +7. We check the inode's type to see if it is a directory. If it is, we dispatch a dir command to "enter the directory", + and recursively call ourself (The type is dir again) by dispatching a cd command, with the rest of the path + as an argument. + +8. If the inode's type is a symbolic link (only fast symbolic link were meanwhile implemented. I guess this is + typically the case.), we note the path it is pointing at, the saved inode is recalled, we dispatch dir to + get back to the original directory, and we call ourself again with the link path/rest of the path argument. + +9. In any other case, we just stop at the resulting inode. + +*/ + +{ + int status; + char *ptr,full_dir_name [500],dir_name [500],temp [500],temp2 [500]; + struct struct_file_info info; + struct ext2_dir_entry_2 *dir_entry_ptr; + + dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); + + ptr=parse_word (command_line,dir_name); + + if (*ptr==0) { /* cd alone will enter the highlighted directory */ + strncpy (full_dir_name,dir_entry_ptr->name,dir_entry_ptr->name_len); + full_dir_name [dir_entry_ptr->name_len]=0; + } + else + ptr=parse_word (ptr,full_dir_name); + + ptr=strchr (full_dir_name,'/'); + + if (ptr==full_dir_name) { /* Pathname is from root - Let the general cd do the job */ + sprintf (temp,"cd %s",full_dir_name);type_ext2___cd (temp);return; + } + + if (ptr==NULL) { + strcpy (dir_name,full_dir_name); + full_dir_name [0]=0; + } + + else { + strncpy (dir_name,full_dir_name,ptr-full_dir_name); + dir_name [ptr-full_dir_name]=0; + strcpy (full_dir_name,++ptr); + } + /* dir_name contains the current entry, while */ + /* full_dir_name contains the rest */ + + strcpy (name_search,dir_name); /* name_search is used to hold the required entry name */ + + if (dir_entry_ptr->name_len != strlen (dir_name) || + strncmp (dir_name,dir_entry_ptr->name,dir_entry_ptr->name_len)!=0) + info=search_dir_entries (&action_name,&status); /* Search for the entry. Answer in info. */ + else { + status=FOUND;info=file_info; + } + + if (status==FOUND) { /* If found */ + file_info=info; /* Switch to it, by setting the global file_info */ + dispatch ("remember internal_variable"); /* Move the inode into the objects memory */ + + dispatch ("followinode"); /* Go to the inode pointed by this directory entry */ + + if (S_ISLNK (type_data.u.t_ext2_inode.i_mode)) {/* Symbolic link ? */ + + if (type_data.u.t_ext2_inode.i_size > 60) { /* I'm lazy, I guess :-) */ + wprintw (command_win,"Error - Sorry, Only fast symbolic link following is currently supported\n"); + refresh_command_win (); + return; + } + /* Get the pointed name and append the previous path */ + + strcpy (temp2,(unsigned char *) &type_data.u.t_ext2_inode.i_block); + strcat (temp2,"/"); + strcat (temp2,full_dir_name); + + dispatch ("recall internal_variable"); /* Return to the original inode */ + dispatch ("dir"); /* and to the directory */ + + sprintf (temp,"cd %s",temp2); /* And continue from there by dispatching a cd command */ + dispatch (temp); /* (which can call ourself or the general cd) */ + + return; + } + + if (S_ISDIR (type_data.u.t_ext2_inode.i_mode)) { /* Is it an inode of a directory ? */ + + dispatch ("dir"); /* Yes - Pass to the pointed directory */ + + if (full_dir_name [0] != 0) { /* And call ourself with the rest of the pathname */ + sprintf (temp,"cd %s",full_dir_name); + dispatch (temp); + } + + return; + } + + else { /* If we can't continue from here, we'll just stop */ + wprintw (command_win,"Can\'t continue - Stopping at last inode\n");refresh_command_win (); + return; + } + } + + wprintw (command_win,"Error - Directory entry %s not found.\n",dir_name); /* Hmm, an invalid path somewhere */ + refresh_command_win (); +} + +int action_name (struct struct_file_info *info) + +/* + +Compares the current search entry name (somewhere inside info) with the required name (in name_search). +Returns FOUND if found, or CONTINUE if not found. + +*/ + +{ + struct ext2_dir_entry_2 *dir_entry_ptr; + + dir_entry_ptr=(struct ext2_dir_entry_2 *) (info->buffer+info->dir_entry_offset); + + if (dir_entry_ptr->name_len != strlen (name_search)) + return (CONTINUE); + + if (strncmp (dir_entry_ptr->name,name_search,dir_entry_ptr->name_len)==0) + return (FOUND); + + return (CONTINUE); +} + +void type_dir___entry (char *command_line) + +/* + +Selects a directory entry according to its number. +search_dir_entries is used along with action_entry_num, in the same fashion as the previous usage of search_dir_entries. + +*/ + +{ + int status; + struct struct_file_info info; + char *ptr,buffer [80]; + + ptr=parse_word (command_line,buffer); + if (*ptr==0) { + wprintw (command_win,"Error - Argument_not_specified\n");wrefresh (command_win); + return; + } + ptr=parse_word (ptr,buffer); + entry_num_search=atol (buffer); + + if (entry_num_search < 0 || entry_num_search >= file_info.dir_entries_count) { + wprintw (command_win,"Error - Entry number out of range\n");wrefresh (command_win); + return; + } + + info=search_dir_entries (&action_entry_num,&status); + if (status==FOUND) { + file_info=info; + dispatch ("show"); + return; + } +#ifdef DEBUG + internal_error ("dir_com","type_dir___entry","According to our gathered data, we should have found this entry"); +#endif +} + +int action_entry_num (struct struct_file_info *info) + +/* + +Used by the above function. Just compares the current number (in info) with the required one. + +*/ + +{ + if (info->dir_entry_num == entry_num_search) + return (FOUND); + + return (CONTINUE); +} + +void type_dir___followinode (char *command_line) + +/* + +Here we pass to the inode pointed by the current entry. +It involves computing the device offset of the inode and using directly the setoffset and settype commands. + +*/ +{ + long inode_offset; + char buffer [80]; + + struct ext2_dir_entry_2 *dir_entry_ptr; + + low_read (file_info.buffer,file_system_info.block_size,file_info.global_block_offset); + dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); + + inode_offset=inode_num_to_inode_offset (dir_entry_ptr->inode); /* Compute the inode's offset */ + sprintf (buffer,"setoffset %ld",inode_offset);dispatch (buffer); /* Move to it */ + sprintf (buffer,"settype ext2_inode");dispatch (buffer); /* and set the type to an inode */ +} + +void type_dir___inode (char *command_line) + +/* + +Returns to the parent inode of the current directory. +This is trivial, as we type_data is still intact and contains the parent inode ! + +*/ + +{ + dispatch ("settype ext2_inode"); +} + + +void type_dir___show (char *command_line) + +/* + +We use search_dir_entries to run on all the entries. Each time, action_show will be called to show one entry. + +*/ + +{ + int status; + + wmove (show_pad,0,0); + show_pad_info.max_line=-1; + + search_dir_entries (&action_show,&status); + show_pad_info.line=file_info.dir_entry_num-show_pad_info.display_lines/2; + refresh_show_pad (); + show_dir_status (); +} + +int action_show (struct struct_file_info *info) + +/* + +Show the current search entry (info) in one line. If the entry happens to be the current edited entry, it is highlighted. + +*/ + +{ + unsigned char temp [80]; + struct ext2_dir_entry_2 *dir_entry_ptr; + + dir_entry_ptr=(struct ext2_dir_entry_2 *) (info->buffer+info->dir_entry_offset); + + if (info->dir_entry_num == file_info.dir_entry_num) /* Highlight the current entry */ + wattrset (show_pad,A_REVERSE); + + strncpy (temp,dir_entry_ptr->name,dir_entry_ptr->name_len); /* The name is not terminated */ + temp [dir_entry_ptr->name_len]=0; + if (dir_entry_ptr->name_len > (COLS - 55) && COLS > 55) + temp [COLS-55]=0; + wprintw (show_pad,"inode = %-8lu rec_len = %-4lu name_len = %-3lu name = %s\n", /* Display the various fields */ + dir_entry_ptr->inode,dir_entry_ptr->rec_len,dir_entry_ptr->name_len,temp); + + show_pad_info.max_line++; + + if (info->dir_entry_num == file_info.dir_entry_num) + wattrset (show_pad,A_NORMAL); + + return (CONTINUE); /* And pass to the next */ +} + +void type_dir___next (char *command_line) + +/* + +This function moves to the next directory entry. It just uses the current information and the entry command. + +*/ + +{ + int offset=1; + char *ptr,buffer [80]; + + ptr=parse_word (command_line,buffer); + + if (*ptr!=0) { + ptr=parse_word (ptr,buffer); + offset*=atol (buffer); + } + + sprintf (buffer,"entry %ld",file_info.dir_entry_num+offset);dispatch (buffer); + +} + +void type_dir___prev (char *command_line) + +{ + int offset=1; + char *ptr,buffer [80]; + + ptr=parse_word (command_line,buffer); + + if (*ptr!=0) { + ptr=parse_word (ptr,buffer); + offset*=atol (buffer); + } + + sprintf (buffer,"entry %ld",file_info.dir_entry_num-offset);dispatch (buffer); +} + +void show_dir_status (void) + +/* + +Various statistics about the directory. + +*/ + +{ + long inode_num; + + wmove (show_win,0,0); + wprintw (show_win,"Directory listing. Block %ld. ",file_info.global_block_num); + wprintw (show_win,"Directory entry %ld of %ld.\n",file_info.dir_entry_num,file_info.dir_entries_count-1); + wprintw (show_win,"Directory Offset %ld of %ld. ",file_info.file_offset,file_info.file_length-1); + + inode_num=inode_offset_to_inode_num (file_info.inode_offset); + wprintw (show_win,"File inode %ld. Indirection level %ld.\n",inode_num,file_info.level); + + refresh_show_win (); +} + +void type_dir___remember (char *command_line) + +/* + +This is overridden here because we don't remember a directory - It is too complicated. Instead, we remember the +inode of the current directory. + +*/ + +{ + int found=0; + long entry_num; + char *ptr,buffer [80]; + struct struct_descriptor *descriptor_ptr; + + ptr=parse_word (command_line,buffer); + + if (*ptr==0) { + wprintw (command_win,"Error - Argument not specified\n");wrefresh (command_win); + return; + } + + ptr=parse_word (ptr,buffer); + + entry_num=remember_lifo.entries_count++; + if (entry_num>REMEMBER_COUNT-1) { + entry_num=0; + remember_lifo.entries_count--; + } + + descriptor_ptr=first_type; + while (descriptor_ptr!=NULL && !found) { + if (strcmp (descriptor_ptr->name,"ext2_inode")==0) + found=1; + else + descriptor_ptr=descriptor_ptr->next; + } + + + remember_lifo.offset [entry_num]=device_offset; + remember_lifo.type [entry_num]=descriptor_ptr; + strcpy (remember_lifo.name [entry_num],buffer); + + wprintw (command_win,"Object %s in Offset %ld remembered as %s\n",descriptor_ptr->name,device_offset,buffer); + wrefresh (command_win); +} + +void type_dir___set (char *command_line) + +/* + +Since the dir object doesn't have variables, we provide the impression that it has here. ext2_dir_entry was not used +because it is of variable length. + +*/ + +{ + int found=0; + unsigned char *ptr,buffer [80],variable [80],value [80],temp [80]; + struct ext2_dir_entry_2 *dir_entry_ptr; + + dir_entry_ptr=(struct ext2_dir_entry_2 *) (file_info.buffer+file_info.dir_entry_offset); + + ptr=parse_word (command_line,buffer); + if (*ptr==0) { + wprintw (command_win,"Error - Missing arguments\n");refresh_command_win (); + return; + } + parse_word (ptr,buffer); + ptr=strchr (buffer,'='); + if (ptr==NULL) { + wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return; + } + strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0; + strcpy (value,++ptr); + + if (strcasecmp ("inode",variable)==0) { + found=1; + dir_entry_ptr->inode=atol (value); + wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->inode);refresh_command_win (); + + } + + if (strcasecmp ("rec_len",variable)==0) { + found=1; + dir_entry_ptr->rec_len=(unsigned int) atol (value); + wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->rec_len);refresh_command_win (); + + } + + if (strcasecmp ("name_len",variable)==0) { + found=1; + dir_entry_ptr->name_len=(unsigned int) atol (value); + wprintw (command_win,"Variable %s set to %lu\n",variable,dir_entry_ptr->name_len);refresh_command_win (); + + } + + if (strcasecmp ("name",variable)==0) { + found=1; + if (strlen (value) > dir_entry_ptr->name_len) { + wprintw (command_win,"Error - Length of name greater then name_len\n"); + refresh_command_win ();return; + } + strncpy (dir_entry_ptr->name,value,strlen (value)); + wprintw (command_win,"Variable %s set to %s\n",variable,value);refresh_command_win (); + + } + + if (found) { + wattrset (show_pad,A_REVERSE); + strncpy (temp,dir_entry_ptr->name,dir_entry_ptr->name_len); + temp [dir_entry_ptr->name_len]=0; + wmove (show_pad,file_info.dir_entry_num,0); + wprintw (show_pad,"inode = %-8lu rec_len = %-4lu name_len = %-3lu name = %s\n", + dir_entry_ptr->inode,dir_entry_ptr->rec_len,dir_entry_ptr->name_len,temp); + wattrset (show_pad,A_NORMAL); + show_pad_info.line=file_info.dir_entry_num-show_pad_info.display_lines/2; + refresh_show_pad (); + show_dir_status (); + } + + else { + wprintw (command_win,"Error - Variable %s not found\n",variable); + refresh_command_win (); + } + +} + +void type_dir___writedata (char *command_line) + +/* + +We need to override this since the data is not in type_data. Instead, we have to write the buffer which corresponds +to the current block. + +*/ + +{ + low_write (file_info.buffer,file_system_info.block_size,file_info.global_block_offset); + return; +} |