diff options
Diffstat (limited to 'ext2ed/init.c')
| -rw-r--r-- | ext2ed/init.c | 633 |
1 files changed, 633 insertions, 0 deletions
diff --git a/ext2ed/init.c b/ext2ed/init.c new file mode 100644 index 0000000..4e58431 --- /dev/null +++ b/ext2ed/init.c @@ -0,0 +1,633 @@ +/* + +/usr/src/ext2ed/init.c + +A part of the extended file system 2 disk editor. + +-------------------------------- +Various initialization routines. +-------------------------------- + +First written on: April 9 1995 + +Copyright (C) 1995 Gadi Oxman + +*/ + +#include "config.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#ifdef HAVE_READLINE +#include <readline.h> +#endif +#include <signal.h> +#include <unistd.h> + +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> + +#include "ext2ed.h" + +char lines_s [80],cols_s [80]; + +void signal_handler (void); + +void prepare_to_close (void) + +{ + close_windows (); + if (device_handle!=NULL) + fclose (device_handle); + free_user_commands (&general_commands); + free_user_commands (&ext2_commands); + free_struct_descriptors (); +} + +int init (void) + +{ + printf ("Initializing ...\n"); + + if (!process_configuration_file ()) { + fprintf (stderr,"Error - Unable to complete configuration. Quitting.\n"); + return (0); + }; + + general_commands.last_command=-1; /* No commands whatsoever meanwhile */ + ext2_commands.last_command=-1; + add_general_commands (); /* Add the general commands, available always */ + device_handle=NULL; /* Notice that our device is still not set up */ + device_offset=-1; + current_type=NULL; /* No filesystem specific types yet */ + + remember_lifo.entries_count=0; /* Object memory is empty */ + + init_windows (); /* Initialize the NCURSES interface */ + init_readline (); /* Initialize the READLINE interface */ + init_signals (); /* Initialize the signal handlers */ + write_access=0; /* Write access disabled */ + + strcpy (last_command_line,"help"); /* Show the help screen to the user */ + dispatch ("help"); + return (1); /* Success */ +} + +void add_general_commands (void) + +{ + add_user_command (&general_commands,"help","EXT2ED help system",help); + add_user_command (&general_commands,"set","Changes a variable in the current object",set); + add_user_command (&general_commands,"setdevice","Selects the filesystem block device (e.g. /dev/hda1)",set_device); + add_user_command (&general_commands,"setoffset","Moves asynchronously in the filesystem",set_offset); + add_user_command (&general_commands,"settype","Tells EXT2ED how to interpret the current object",set_type); + add_user_command (&general_commands,"show","Displays the current object",show); + add_user_command (&general_commands,"pgup","Scrolls data one page up",pgup); + add_user_command (&general_commands,"pgdn","Scrolls data one page down",pgdn); + add_user_command (&general_commands,"redraw","Redisplay the screen",redraw); + add_user_command (&general_commands,"remember","Saves the current position and data information",remember); + add_user_command (&general_commands,"recall","Gets back to the saved object position",recall); + add_user_command (&general_commands,"enablewrite","Enters Read/Write mode - Allows changing the filesystem",enable_write); + add_user_command (&general_commands,"disablewrite","Enters read only mode",disable_write); + add_user_command (&general_commands,"writedata","Write data back to disk",write_data); + add_user_command (&general_commands,"next","Moves to the next byte in hex mode",next); + add_user_command (&general_commands,"prev","Moves to the previous byte in hex mode",prev); +} + +void add_ext2_general_commands (void) + +{ + add_user_command (&ext2_commands,"super","Moves to the superblock of the filesystem",type_ext2___super); + add_user_command (&ext2_commands,"group","Moves to the first group descriptor",type_ext2___group); + add_user_command (&ext2_commands,"cd","Moves to the directory specified",type_ext2___cd); +} + +int set_struct_descriptors (char *file_name) + +{ + FILE *fp; + char current_line [500],current_word [50],*ch; + char variable_name [50],variable_type [20]; + struct struct_descriptor *current_descriptor; + + if ( (fp=fopen (file_name,"rt"))==NULL) { + wprintw (command_win,"Error - Failed to open descriptors file %s\n",file_name); + refresh_command_win (); return (0); + }; + + while (!feof (fp)) { + fgets (current_line,500,fp); + if (feof (fp)) break; + ch=parse_word (current_line,current_word); + if (strcmp (current_word,"struct")==0) { + ch=parse_word (ch,current_word); + current_descriptor=add_new_descriptor (current_word); + + while (strchr (current_line,'{')==NULL) { + fgets (current_line,500,fp); + if (feof (fp)) break; + }; + if (feof (fp)) break; + + fgets (current_line,500,fp); + + while (strchr (current_line,'}')==NULL) { + while (strchr (current_line,';')==NULL) { + fgets (current_line,500,fp); + if (strchr (current_line,'}')!=NULL) break; + }; + if (strchr (current_line,'}') !=NULL) break; + ch=parse_word (current_line,variable_type); + ch=parse_word (ch,variable_name); + while (variable_name [strlen (variable_name)-1]!=';') { + strcpy (variable_type,variable_name); + ch=parse_word (ch,variable_name); + }; + variable_name [strlen (variable_name)-1]=0; + add_new_variable (current_descriptor,variable_type,variable_name); + fgets (current_line,500,fp); + }; + }; + }; + + fclose (fp); + return (1); +} + +void free_struct_descriptors (void) + +{ + struct struct_descriptor *ptr,*next; + + ptr=first_type; + while (ptr!=NULL) { + next=ptr->next; + free_user_commands (&ptr->type_commands); + free (ptr); + ptr=next; + } + first_type=last_type=current_type=NULL; +} + +void free_user_commands (struct struct_commands *ptr) + +{ + int i; + + for (i=0;i<=ptr->last_command;i++) { + free (ptr->names [i]); + free (ptr->descriptions [i]); + } + + ptr->last_command=-1; +} + +struct struct_descriptor *add_new_descriptor (char *name) + +{ + struct struct_descriptor *ptr; + + ptr = malloc (sizeof (struct struct_descriptor)); + if (ptr == NULL) { + printf ("Error - Can not allocate memory - Quitting\n"); + exit (1); + } + memset(ptr, 0, sizeof(struct struct_descriptor)); + ptr->prev = ptr->next = NULL; + strcpy (ptr->name,name); + ptr->length=0; + ptr->fields_num=0; + if (first_type==NULL) { + first_type = last_type = ptr; + } else { + ptr->prev = last_type; last_type->next = ptr; last_type=ptr; + } + ptr->type_commands.last_command=-1; + fill_type_commands (ptr); + return (ptr); +} + +struct type_table { + char *name; + int field_type; + int len; +}; + +struct type_table type_table[] = { + { "long", FIELD_TYPE_INT, 4 }, + { "short", FIELD_TYPE_INT, 2 }, + { "char", FIELD_TYPE_CHAR, 1 }, + { "__u32", FIELD_TYPE_UINT, 4 }, + { "__s32", FIELD_TYPE_INT, 4 }, + { "__u16", FIELD_TYPE_UINT, 2 }, + { "__s16", FIELD_TYPE_INT, 2 }, + { "__u8", FIELD_TYPE_UINT, 1 }, + { "__s8", FIELD_TYPE_INT, 1 }, + { 0, 0, 0 } +}; + +void add_new_variable (struct struct_descriptor *ptr,char *v_type,char *v_name) + +{ + short len=1; + char field_type=FIELD_TYPE_INT; + struct type_table *p; + + strcpy (ptr->field_names [ptr->fields_num],v_name); + ptr->field_positions [ptr->fields_num]=ptr->length; + + for (p = type_table; p->name; p++) { + if (strcmp(v_type, p->name) == 0) { + len = p->len; + field_type = p->field_type; + break; + } + } + if (p->name == 0) { + if (strncmp(v_type, "char[", 5) == 0) { + len = atoi(v_type+5); + field_type = FIELD_TYPE_CHAR; + } else { + printf("Unknown type %s for field %s\n", v_type, v_name); + exit(1); + } + } + + ptr->field_lengths [ptr->fields_num] = len; + ptr->field_types [ptr->fields_num] = field_type; + + ptr->length+=len; + ptr->fields_num++; +} + +void fill_type_commands (struct struct_descriptor *ptr) + +/* + +Set specific type user commands. + +*/ + +{ + + if (strcmp ((ptr->name),"file")==0) { + add_user_command (&ptr->type_commands,"show","Shows file data",type_file___show); + add_user_command (&ptr->type_commands,"inode","Returns to the inode of the current file",type_file___inode); + add_user_command (&ptr->type_commands,"display","Specifies data format - text or hex",type_file___display); + add_user_command (&ptr->type_commands,"next","Pass to next byte",type_file___next); + add_user_command (&ptr->type_commands,"prev","Pass to the previous byte",type_file___prev); + add_user_command (&ptr->type_commands,"offset","Pass to a specified byte in the current block",type_file___offset); + add_user_command (&ptr->type_commands,"nextblock","Pass to next file block",type_file___nextblock); + add_user_command (&ptr->type_commands,"prevblock","Pass to the previous file block",type_file___prevblock); + add_user_command (&ptr->type_commands,"block","Specify which file block to edit",type_file___block); + add_user_command (&ptr->type_commands,"remember","Saves the file\'s inode position for later reference",type_file___remember); + add_user_command (&ptr->type_commands,"set","Sets the current byte",type_file___set); + add_user_command (&ptr->type_commands,"writedata","Writes the current block to the disk",type_file___writedata); + } + + if (strcmp ((ptr->name),"ext2_inode")==0) { + add_user_command (&ptr->type_commands,"show","Shows inode data",type_ext2_inode___show); + add_user_command (&ptr->type_commands,"next","Move to next inode in current block group",type_ext2_inode___next); + add_user_command (&ptr->type_commands,"prev","Move to next inode in current block group",type_ext2_inode___prev); + add_user_command (&ptr->type_commands,"group","Move to the group descriptors of the current inode table",type_ext2_inode___group); + add_user_command (&ptr->type_commands,"entry","Move to a specified entry in the current inode table",type_ext2_inode___entry); + add_user_command (&ptr->type_commands,"file","Display file data of the current inode",type_ext2_inode___file); + add_user_command (&ptr->type_commands,"dir","Display directory data of the current inode",type_ext2_inode___dir); + } + + if (strcmp ((ptr->name),"dir")==0) { + add_user_command (&ptr->type_commands,"show","Shows current directory data",type_dir___show); + add_user_command (&ptr->type_commands,"inode","Returns to the inode of the current directory",type_dir___inode); + add_user_command (&ptr->type_commands,"next","Pass to the next directory entry",type_dir___next); + add_user_command (&ptr->type_commands,"prev","Pass to the previous directory entry",type_dir___prev); + add_user_command (&ptr->type_commands,"followinode","Follows the inode specified in this directory entry",type_dir___followinode); + add_user_command (&ptr->type_commands,"remember","Remember the inode of the current directory entry",type_dir___remember); + add_user_command (&ptr->type_commands,"cd","Changes directory relative to the current directory",type_dir___cd); + add_user_command (&ptr->type_commands,"entry","Moves to a specified entry in the current directory",type_dir___entry); + add_user_command (&ptr->type_commands,"writedata","Writes the current entry to the disk",type_dir___writedata); + add_user_command (&ptr->type_commands,"set","Changes a variable in the current directory entry",type_dir___set); + } + + if (strcmp ((ptr->name),"ext2_super_block")==0) { + add_user_command (&ptr->type_commands,"show","Displays the super block data",type_ext2_super_block___show); + add_user_command (&ptr->type_commands,"gocopy","Move to another backup copy of the superblock",type_ext2_super_block___gocopy); + add_user_command (&ptr->type_commands,"setactivecopy","Copies the current superblock to the main superblock",type_ext2_super_block___setactivecopy); + } + + if (strcmp ((ptr->name),"ext2_group_desc")==0) { + add_user_command (&ptr->type_commands,"next","Pass to the next block group descriptor",type_ext2_group_desc___next); + add_user_command (&ptr->type_commands,"prev","Pass to the previous group descriptor",type_ext2_group_desc___prev); + add_user_command (&ptr->type_commands,"entry","Pass to a specific group descriptor",type_ext2_group_desc___entry); + add_user_command (&ptr->type_commands,"show","Shows the current group descriptor",type_ext2_group_desc___show); + add_user_command (&ptr->type_commands,"inode","Pass to the inode table of the current group block",type_ext2_group_desc___inode); + add_user_command (&ptr->type_commands,"gocopy","Move to another backup copy of the group descriptor",type_ext2_group_desc___gocopy); + add_user_command (&ptr->type_commands,"blockbitmap","Show the block allocation bitmap of the current group block",type_ext2_group_desc___blockbitmap); + add_user_command (&ptr->type_commands,"inodebitmap","Show the inode allocation bitmap of the current group block",type_ext2_group_desc___inodebitmap); + add_user_command (&ptr->type_commands,"setactivecopy","Copies the current group descriptor to the main table",type_ext2_super_block___setactivecopy); + } + + if (strcmp ((ptr->name),"block_bitmap")==0) { + add_user_command (&ptr->type_commands,"show","Displays the block allocation bitmap",type_ext2_block_bitmap___show); + add_user_command (&ptr->type_commands,"entry","Moves to a specific bit",type_ext2_block_bitmap___entry); + add_user_command (&ptr->type_commands,"next","Moves to the next bit",type_ext2_block_bitmap___next); + add_user_command (&ptr->type_commands,"prev","Moves to the previous bit",type_ext2_block_bitmap___prev); + add_user_command (&ptr->type_commands,"allocate","Allocates the current block",type_ext2_block_bitmap___allocate); + add_user_command (&ptr->type_commands,"deallocate","Deallocates the current block",type_ext2_block_bitmap___deallocate); + } + + if (strcmp ((ptr->name),"inode_bitmap")==0) { + add_user_command (&ptr->type_commands,"show","Displays the inode allocation bitmap",type_ext2_inode_bitmap___show); + add_user_command (&ptr->type_commands,"entry","Moves to a specific bit",type_ext2_inode_bitmap___entry); + add_user_command (&ptr->type_commands,"next","Moves to the next bit",type_ext2_inode_bitmap___next); + add_user_command (&ptr->type_commands,"prev","Moves to the previous bit",type_ext2_inode_bitmap___prev); + add_user_command (&ptr->type_commands,"allocate","Allocates the current inode",type_ext2_inode_bitmap___allocate); + add_user_command (&ptr->type_commands,"deallocate","Deallocates the current inode",type_ext2_inode_bitmap___deallocate); + } + +} + +void add_user_command (struct struct_commands *ptr,char *name,char *description,PF callback) + +{ + int num; + + num=ptr->last_command; + if (num+1==MAX_COMMANDS_NUM) { + printf ("Internal Error - Can't add command %s\n",name); + return; + } + + ptr->last_command=++num; + + ptr->names [num]=(char *) malloc (strlen (name)+1); + strcpy (ptr->names [num],name); + + if (*description!=0) { + ptr->descriptions [num]=(char *) malloc (strlen (description)+1); + strcpy (ptr->descriptions [num],description); + } + + ptr->callback [num]=callback; +} + +int set_file_system_info (void) + +{ + int ext2_detected=0; + struct ext2_super_block *sb; + + file_system_info.super_block_offset=1024; + file_system_info.file_system_size=DefaultTotalBlocks*DefaultBlockSize; + + low_read ((char *) &file_system_info.super_block,sizeof (struct ext2_super_block),file_system_info.super_block_offset); + + sb=&file_system_info.super_block; + + if (sb->s_magic == EXT2_SUPER_MAGIC) + ext2_detected=1; + + if (ext2_detected) + wprintw (command_win,"Detected extended 2 file system on device %s\n",device_name); + else + wprintw (command_win,"Warning - Extended 2 filesystem not detected on device %s\n",device_name); + + if (!ext2_detected && !ForceExt2) + wprintw (command_win,"You may wish to use the configuration option ForceExt2 on\n"); + + if (ForceExt2 && !ext2_detected) + wprintw (command_win,"Forcing extended 2 filesystem\n"); + + if (ForceDefault || !ext2_detected) + wprintw (command_win,"Forcing default parameters\n"); + + refresh_command_win (); + + if (ext2_detected || ForceExt2) { + add_ext2_general_commands (); + if (!set_struct_descriptors (Ext2Descriptors)) + return (0); + } + + if (!ForceDefault && ext2_detected) { + + file_system_info.block_size=EXT2_MIN_BLOCK_SIZE << sb->s_log_block_size; + if (file_system_info.block_size == EXT2_MIN_BLOCK_SIZE) + file_system_info.first_group_desc_offset=2*EXT2_MIN_BLOCK_SIZE; + else + file_system_info.first_group_desc_offset=file_system_info.block_size; + file_system_info.groups_count = ext2fs_div64_ceil(ext2fs_blocks_count(sb), + sb->s_blocks_per_group); + + file_system_info.inodes_per_block=file_system_info.block_size/sizeof (struct ext2_inode); + file_system_info.blocks_per_group=sb->s_inodes_per_group/file_system_info.inodes_per_block; + file_system_info.no_blocks_in_group=sb->s_blocks_per_group; + file_system_info.file_system_size=(ext2fs_blocks_count(sb)-1)*file_system_info.block_size; + } + + else { + file_system_info.file_system_size=DefaultTotalBlocks*DefaultBlockSize; + file_system_info.block_size=DefaultBlockSize; + file_system_info.no_blocks_in_group=DefaultBlocksInGroup; + } + + if (file_system_info.file_system_size > 2147483647) { + wprintw (command_win,"Sorry, filesystems bigger than 2 GB are currently not supported\n"); + return (0); + } + return (1); +} + +void init_readline (void) + +{ +#ifdef HAVE_READLINE + rl_completion_entry_function=(Function *) complete_command; +#endif +} + +void init_signals (void) + +{ + signal (SIGWINCH, signal_SIGWINCH_handler); /* Catch SIGWINCH */ + signal (SIGTERM, signal_SIGTERM_handler); + signal (SIGSEGV, signal_SIGSEGV_handler); + +} + +void signal_SIGWINCH_handler (int sig_num) + +{ + redraw_request=1; /* We will handle it in main.c */ + + /* Reset signal handler */ + signal (SIGWINCH, signal_SIGWINCH_handler); + +} + +void signal_SIGTERM_handler (int sig_num) + +{ + prepare_to_close (); + printf ("Terminated due to signal %d\n",sig_num); + exit (1); +} + +void signal_SIGSEGV_handler (int sig_num) + +{ + prepare_to_close (); + printf ("Killed by signal %d!\n",sig_num); + exit (1); +} + +int process_configuration_file (void) + +{ + char buffer [300]; + char option [80],value [80]; + FILE *fp; + + strcpy (buffer, ROOT_SYSCONFDIR); + strcat (buffer,"/ext2ed.conf"); + + if ((fp=fopen (buffer,"rt"))==NULL) { + fprintf (stderr,"Error - Unable to open configuration file %s\n",buffer); + return (0); + } + + while (get_next_option (fp,option,value)) { + if (strcasecmp (option,"Ext2Descriptors")==0) { + strcpy (Ext2Descriptors,value); + } + + else if (strcasecmp (option,"AlternateDescriptors")==0) { + strcpy (AlternateDescriptors,value); + } + + else if (strcasecmp (option,"LogFile")==0) { + strcpy (LogFile,value); + } + + else if (strcasecmp (option,"LogChanges")==0) { + if (strcasecmp (value,"on")==0) + LogChanges = 1; + else if (strcasecmp (value,"off")==0) + LogChanges = 0; + else { + fprintf (stderr,"Error - Illegal value: %s %s\n",option,value); + fclose (fp);return (0); + } + } + + else if (strcasecmp (option,"AllowChanges")==0) { + if (strcasecmp (value,"on")==0) + AllowChanges = 1; + else if (strcasecmp (value,"off")==0) + AllowChanges = 0; + else { + fprintf (stderr,"Error - Illegal value: %s %s\n",option,value); + fclose (fp);return (0); + } + } + + else if (strcasecmp (option,"AllowMountedRead")==0) { + if (strcasecmp (value,"on")==0) + AllowMountedRead = 1; + else if (strcasecmp (value,"off")==0) + AllowMountedRead = 0; + else { + fprintf (stderr,"Error - Illegal value: %s %s\n",option,value); + fclose (fp);return (0); + } + } + + else if (strcasecmp (option,"ForceExt2")==0) { + if (strcasecmp (value,"on")==0) + ForceExt2 = 1; + else if (strcasecmp (value,"off")==0) + ForceExt2 = 0; + else { + fprintf (stderr,"Error - Illegal value: %s %s\n",option,value); + fclose (fp);return (0); + } + } + + else if (strcasecmp (option,"DefaultBlockSize")==0) { + DefaultBlockSize = atoi (value); + } + + else if (strcasecmp (option,"DefaultTotalBlocks")==0) { + DefaultTotalBlocks = strtoul (value,NULL,10); + } + + else if (strcasecmp (option,"DefaultBlocksInGroup")==0) { + DefaultBlocksInGroup = strtoul (value,NULL,10); + } + + else if (strcasecmp (option,"ForceDefault")==0) { + if (strcasecmp (value,"on")==0) + ForceDefault = 1; + else if (strcasecmp (value,"off")==0) + ForceDefault = 0; + else { + fprintf (stderr,"Error - Illegal value: %s %s\n",option,value); + fclose (fp);return (0); + } + } + + else { + fprintf (stderr,"Error - Unknown option: %s\n",option); + fclose (fp);return (0); + } + } + + printf ("Configuration completed\n"); + fclose (fp); + return (1); +} + +int get_next_option (FILE *fp,char *option,char *value) + +{ + char *ptr; + char buffer [600]; + + if (feof (fp)) return (0); + do{ + if (feof (fp)) return (0); + fgets (buffer,500,fp); + } while (buffer [0]=='#' || buffer [0]=='\n'); + + ptr=parse_word (buffer,option); + ptr=parse_word (ptr,value); + return (1); +} + +void check_mounted (char *name) + +{ + FILE *fp; + char *ptr; + char current_line [500],current_word [200]; + + mounted=0; + + if ( (fp=fopen ("/etc/mtab","rt"))==NULL) { + wprintw (command_win,"Error - Failed to open /etc/mtab. Assuming filesystem is mounted.\n"); + refresh_command_win ();mounted=1;return; + }; + + while (!feof (fp)) { + fgets (current_line,500,fp); + if (feof (fp)) break; + ptr=parse_word (current_line,current_word); + if (strcasecmp (current_word,name)==0) { + mounted=1;fclose (fp);return; + } + }; + + fclose (fp); + + return; +} |