Home | History | Annotate | Download | only in ext2ed
      1 /*
      2 
      3 /usr/src/ext2ed/init.c
      4 
      5 A part of the extended file system 2 disk editor.
      6 
      7 --------------------------------
      8 Various initialization routines.
      9 --------------------------------
     10 
     11 First written on: April 9 1995
     12 
     13 Copyright (C) 1995 Gadi Oxman
     14 
     15 */
     16 
     17 #include "config.h"
     18 #include <stdio.h>
     19 #include <stdlib.h>
     20 #include <string.h>
     21 #ifdef HAVE_READLINE
     22 #include <readline.h>
     23 #endif
     24 #include <signal.h>
     25 #include <unistd.h>
     26 
     27 #include <sys/types.h>
     28 #include <sys/stat.h>
     29 #include <fcntl.h>
     30 
     31 #include "ext2ed.h"
     32 
     33 char lines_s [80],cols_s [80];
     34 
     35 void signal_handler (void);
     36 
     37 void prepare_to_close (void)
     38 
     39 {
     40 	close_windows ();
     41 	if (device_handle!=NULL)
     42 		fclose (device_handle);
     43 	free_user_commands (&general_commands);
     44 	free_user_commands (&ext2_commands);
     45 	free_struct_descriptors ();
     46 }
     47 
     48 int init (void)
     49 
     50 {
     51 	printf ("Initializing ...\n");
     52 
     53 	if (!process_configuration_file ()) {
     54 		fprintf (stderr,"Error - Unable to complete configuration. Quitting.\n");
     55 		return (0);
     56 	};
     57 
     58 	general_commands.last_command=-1;	/* No commands whatsoever meanwhile */
     59 	ext2_commands.last_command=-1;
     60 	add_general_commands ();		/* Add the general commands, available always */
     61 	device_handle=NULL;			/* Notice that our device is still not set up */
     62 	device_offset=-1;
     63 	current_type=NULL;			/* No filesystem specific types yet */
     64 
     65 	remember_lifo.entries_count=0;		/* Object memory is empty */
     66 
     67 	init_windows ();			/* Initialize the NCURSES interface */
     68 	init_readline ();			/* Initialize the READLINE interface */
     69 	init_signals ();			/* Initialize the signal handlers */
     70 	write_access=0;				/* Write access disabled */
     71 
     72 	strcpy (last_command_line,"help");	/* Show the help screen to the user */
     73 	dispatch ("help");
     74 	return (1);				/* Success */
     75 }
     76 
     77 void add_general_commands (void)
     78 
     79 {
     80 	add_user_command (&general_commands,"help","EXT2ED help system",help);
     81 	add_user_command (&general_commands,"set","Changes a variable in the current object",set);
     82 	add_user_command (&general_commands,"setdevice","Selects the filesystem block device (e.g. /dev/hda1)",set_device);
     83 	add_user_command (&general_commands,"setoffset","Moves asynchronously in the filesystem",set_offset);
     84 	add_user_command (&general_commands,"settype","Tells EXT2ED how to interpret the current object",set_type);
     85 	add_user_command (&general_commands,"show","Displays the current object",show);
     86 	add_user_command (&general_commands,"pgup","Scrolls data one page up",pgup);
     87 	add_user_command (&general_commands,"pgdn","Scrolls data one page down",pgdn);
     88 	add_user_command (&general_commands,"redraw","Redisplay the screen",redraw);
     89 	add_user_command (&general_commands,"remember","Saves the current position and data information",remember);
     90 	add_user_command (&general_commands,"recall","Gets back to the saved object position",recall);
     91 	add_user_command (&general_commands,"enablewrite","Enters Read/Write mode - Allows changing the filesystem",enable_write);
     92 	add_user_command (&general_commands,"disablewrite","Enters read only mode",disable_write);
     93 	add_user_command (&general_commands,"writedata","Write data back to disk",write_data);
     94 	add_user_command (&general_commands,"next","Moves to the next byte in hex mode",next);
     95 	add_user_command (&general_commands,"prev","Moves to the previous byte in hex mode",prev);
     96 }
     97 
     98 void add_ext2_general_commands (void)
     99 
    100 {
    101 	add_user_command (&ext2_commands,"super","Moves to the superblock of the filesystem",type_ext2___super);
    102 	add_user_command (&ext2_commands,"group","Moves to the first group descriptor",type_ext2___group);
    103 	add_user_command (&ext2_commands,"cd","Moves to the directory specified",type_ext2___cd);
    104 }
    105 
    106 int set_struct_descriptors (char *file_name)
    107 
    108 {
    109 	FILE *fp;
    110 	char current_line [500],current_word [50],*ch;
    111 	char variable_name [50],variable_type [20];
    112 	struct struct_descriptor *current_descriptor;
    113 
    114 	if ( (fp=fopen (file_name,"rt"))==NULL) {
    115 		wprintw (command_win,"Error - Failed to open descriptors file %s\n",file_name);
    116 		refresh_command_win ();	return (0);
    117 	};
    118 
    119 	while (!feof (fp)) {
    120 		fgets (current_line,500,fp);
    121 		if (feof (fp)) break;
    122 		ch=parse_word (current_line,current_word);
    123 		if (strcmp (current_word,"struct")==0) {
    124 			ch=parse_word (ch,current_word);
    125 			current_descriptor=add_new_descriptor (current_word);
    126 
    127 			while (strchr (current_line,'{')==NULL) {
    128 				fgets (current_line,500,fp);
    129 				if (feof (fp)) break;
    130 			};
    131 			if (feof (fp)) break;
    132 
    133 			fgets (current_line,500,fp);
    134 
    135 			while (strchr (current_line,'}')==NULL) {
    136 				while (strchr (current_line,';')==NULL) {
    137 					fgets (current_line,500,fp);
    138 					if (strchr (current_line,'}')!=NULL) break;
    139 				};
    140 				if (strchr (current_line,'}') !=NULL) break;
    141 				ch=parse_word (current_line,variable_type);
    142 				ch=parse_word (ch,variable_name);
    143 				while (variable_name [strlen (variable_name)-1]!=';') {
    144 					strcpy (variable_type,variable_name);
    145 					ch=parse_word (ch,variable_name);
    146 				};
    147 				variable_name [strlen (variable_name)-1]=0;
    148 				add_new_variable (current_descriptor,variable_type,variable_name);
    149 				fgets (current_line,500,fp);
    150 			};
    151 		};
    152 	};
    153 
    154 	fclose (fp);
    155 	return (1);
    156 }
    157 
    158 void free_struct_descriptors (void)
    159 
    160 {
    161 	struct struct_descriptor *ptr,*next;
    162 
    163 	ptr=first_type;
    164 	while (ptr!=NULL) {
    165 		next=ptr->next;
    166 		free_user_commands (&ptr->type_commands);
    167 		free (ptr);
    168 		ptr=next;
    169 	}
    170 	first_type=last_type=current_type=NULL;
    171 }
    172 
    173 void free_user_commands (struct struct_commands *ptr)
    174 
    175 {
    176 	int i;
    177 
    178 	for (i=0;i<=ptr->last_command;i++) {
    179 		free (ptr->names [i]);
    180 		free (ptr->descriptions [i]);
    181 	}
    182 
    183 	ptr->last_command=-1;
    184 }
    185 
    186 struct struct_descriptor *add_new_descriptor (char *name)
    187 
    188 {
    189 	struct struct_descriptor *ptr;
    190 
    191 	ptr = malloc (sizeof (struct struct_descriptor));
    192 	if (ptr == NULL) {
    193 		printf ("Error - Can not allocate memory - Quitting\n");
    194 		exit (1);
    195 	}
    196 	memset(ptr, 0, sizeof(struct struct_descriptor));
    197 	ptr->prev = ptr->next = NULL;
    198 	strcpy (ptr->name,name);
    199 	ptr->length=0;
    200 	ptr->fields_num=0;
    201 	if (first_type==NULL) {
    202 		first_type = last_type = ptr;
    203 	} else {
    204 		ptr->prev = last_type; last_type->next = ptr; last_type=ptr;
    205 	}
    206 	ptr->type_commands.last_command=-1;
    207 	fill_type_commands (ptr);
    208 	return (ptr);
    209 }
    210 
    211 struct type_table {
    212 	char 	*name;
    213 	int	field_type;
    214 	int	len;
    215 };
    216 
    217 struct type_table type_table[] = {
    218 	{ "long",   FIELD_TYPE_INT,	4 },
    219 	{ "short",  FIELD_TYPE_INT,	2 },
    220 	{ "char",   FIELD_TYPE_CHAR,	1 },
    221 	{ "__u32",  FIELD_TYPE_UINT,	4 },
    222 	{ "__s32",  FIELD_TYPE_INT,	4 },
    223 	{ "__u16",  FIELD_TYPE_UINT,	2 },
    224 	{ "__s16",  FIELD_TYPE_INT,	2 },
    225 	{ "__u8",   FIELD_TYPE_UINT,	1 },
    226 	{ "__s8",   FIELD_TYPE_INT,	1 },
    227 	{  0,       0,                  0 }
    228 };
    229 
    230 void add_new_variable (struct struct_descriptor *ptr,char *v_type,char *v_name)
    231 
    232 {
    233 	short	len=1;
    234 	char	field_type=FIELD_TYPE_INT;
    235 	struct type_table *p;
    236 
    237 	strcpy (ptr->field_names [ptr->fields_num],v_name);
    238 	ptr->field_positions [ptr->fields_num]=ptr->length;
    239 
    240 	for (p = type_table; p->name; p++) {
    241 		if (strcmp(v_type, p->name) == 0) {
    242 			len = p->len;
    243 			field_type = p->field_type;
    244 			break;
    245 		}
    246 	}
    247 	if (p->name == 0) {
    248 		if (strncmp(v_type, "char[", 5) == 0) {
    249 			len = atoi(v_type+5);
    250 			field_type = FIELD_TYPE_CHAR;
    251 		} else {
    252 			printf("Unknown type %s for field %s\n", v_type, v_name);
    253 			exit(1);
    254 		}
    255 	}
    256 
    257 	ptr->field_lengths [ptr->fields_num] = len;
    258 	ptr->field_types [ptr->fields_num] = field_type;
    259 
    260 	ptr->length+=len;
    261 	ptr->fields_num++;
    262 }
    263 
    264 void fill_type_commands (struct struct_descriptor *ptr)
    265 
    266 /*
    267 
    268 Set specific type user commands.
    269 
    270 */
    271 
    272 {
    273 
    274 	if (strcmp ((ptr->name),"file")==0) {
    275 		add_user_command (&ptr->type_commands,"show","Shows file data",type_file___show);
    276 		add_user_command (&ptr->type_commands,"inode","Returns to the inode of the current file",type_file___inode);
    277 		add_user_command (&ptr->type_commands,"display","Specifies data format - text or hex",type_file___display);
    278 		add_user_command (&ptr->type_commands,"next","Pass to next byte",type_file___next);
    279 		add_user_command (&ptr->type_commands,"prev","Pass to the previous byte",type_file___prev);
    280 		add_user_command (&ptr->type_commands,"offset","Pass to a specified byte in the current block",type_file___offset);
    281 		add_user_command (&ptr->type_commands,"nextblock","Pass to next file block",type_file___nextblock);
    282 		add_user_command (&ptr->type_commands,"prevblock","Pass to the previous file block",type_file___prevblock);
    283 		add_user_command (&ptr->type_commands,"block","Specify which file block to edit",type_file___block);
    284 		add_user_command (&ptr->type_commands,"remember","Saves the file\'s inode position for later reference",type_file___remember);
    285 		add_user_command (&ptr->type_commands,"set","Sets the current byte",type_file___set);
    286 		add_user_command (&ptr->type_commands,"writedata","Writes the current block to the disk",type_file___writedata);
    287 	}
    288 
    289 	if (strcmp ((ptr->name),"ext2_inode")==0) {
    290 		add_user_command (&ptr->type_commands,"show","Shows inode data",type_ext2_inode___show);
    291 		add_user_command (&ptr->type_commands,"next","Move to next inode in current block group",type_ext2_inode___next);
    292 		add_user_command (&ptr->type_commands,"prev","Move to next inode in current block group",type_ext2_inode___prev);
    293 		add_user_command (&ptr->type_commands,"group","Move to the group descriptors of the current inode table",type_ext2_inode___group);
    294 		add_user_command (&ptr->type_commands,"entry","Move to a specified entry in the current inode table",type_ext2_inode___entry);
    295 		add_user_command (&ptr->type_commands,"file","Display file data of the current inode",type_ext2_inode___file);
    296 		add_user_command (&ptr->type_commands,"dir","Display directory data of the current inode",type_ext2_inode___dir);
    297 	}
    298 
    299 	if (strcmp ((ptr->name),"dir")==0) {
    300 		add_user_command (&ptr->type_commands,"show","Shows current directory data",type_dir___show);
    301 		add_user_command (&ptr->type_commands,"inode","Returns to the inode of the current directory",type_dir___inode);
    302 		add_user_command (&ptr->type_commands,"next","Pass to the next directory entry",type_dir___next);
    303 		add_user_command (&ptr->type_commands,"prev","Pass to the previous directory entry",type_dir___prev);
    304 		add_user_command (&ptr->type_commands,"followinode","Follows the inode specified in this directory entry",type_dir___followinode);
    305 		add_user_command (&ptr->type_commands,"remember","Remember the inode of the current directory entry",type_dir___remember);
    306 		add_user_command (&ptr->type_commands,"cd","Changes directory relative to the current directory",type_dir___cd);
    307 		add_user_command (&ptr->type_commands,"entry","Moves to a specified entry in the current directory",type_dir___entry);
    308 		add_user_command (&ptr->type_commands,"writedata","Writes the current entry to the disk",type_dir___writedata);
    309 		add_user_command (&ptr->type_commands,"set","Changes a variable in the current directory entry",type_dir___set);
    310 	}
    311 
    312 	if (strcmp ((ptr->name),"ext2_super_block")==0) {
    313 		add_user_command (&ptr->type_commands,"show","Displays the super block data",type_ext2_super_block___show);
    314 		add_user_command (&ptr->type_commands,"gocopy","Move to another backup copy of the superblock",type_ext2_super_block___gocopy);
    315 		add_user_command (&ptr->type_commands,"setactivecopy","Copies the current superblock to the main superblock",type_ext2_super_block___setactivecopy);
    316 	}
    317 
    318 	if (strcmp ((ptr->name),"ext2_group_desc")==0) {
    319 		add_user_command (&ptr->type_commands,"next","Pass to the next block group descriptor",type_ext2_group_desc___next);
    320 		add_user_command (&ptr->type_commands,"prev","Pass to the previous group descriptor",type_ext2_group_desc___prev);
    321 		add_user_command (&ptr->type_commands,"entry","Pass to a specific group descriptor",type_ext2_group_desc___entry);
    322 		add_user_command (&ptr->type_commands,"show","Shows the current group descriptor",type_ext2_group_desc___show);
    323 		add_user_command (&ptr->type_commands,"inode","Pass to the inode table of the current group block",type_ext2_group_desc___inode);
    324 		add_user_command (&ptr->type_commands,"gocopy","Move to another backup copy of the group descriptor",type_ext2_group_desc___gocopy);
    325 		add_user_command (&ptr->type_commands,"blockbitmap","Show the block allocation bitmap of the current group block",type_ext2_group_desc___blockbitmap);
    326 		add_user_command (&ptr->type_commands,"inodebitmap","Show the inode allocation bitmap of the current group block",type_ext2_group_desc___inodebitmap);
    327 		add_user_command (&ptr->type_commands,"setactivecopy","Copies the current group descriptor to the main table",type_ext2_super_block___setactivecopy);
    328 	}
    329 
    330 	if (strcmp ((ptr->name),"block_bitmap")==0) {
    331 		add_user_command (&ptr->type_commands,"show","Displays the block allocation bitmap",type_ext2_block_bitmap___show);
    332 		add_user_command (&ptr->type_commands,"entry","Moves to a specific bit",type_ext2_block_bitmap___entry);
    333 		add_user_command (&ptr->type_commands,"next","Moves to the next bit",type_ext2_block_bitmap___next);
    334 		add_user_command (&ptr->type_commands,"prev","Moves to the previous bit",type_ext2_block_bitmap___prev);
    335 		add_user_command (&ptr->type_commands,"allocate","Allocates the current block",type_ext2_block_bitmap___allocate);
    336 		add_user_command (&ptr->type_commands,"deallocate","Deallocates the current block",type_ext2_block_bitmap___deallocate);
    337 	}
    338 
    339 	if (strcmp ((ptr->name),"inode_bitmap")==0) {
    340 		add_user_command (&ptr->type_commands,"show","Displays the inode allocation bitmap",type_ext2_inode_bitmap___show);
    341 		add_user_command (&ptr->type_commands,"entry","Moves to a specific bit",type_ext2_inode_bitmap___entry);
    342 		add_user_command (&ptr->type_commands,"next","Moves to the next bit",type_ext2_inode_bitmap___next);
    343 		add_user_command (&ptr->type_commands,"prev","Moves to the previous bit",type_ext2_inode_bitmap___prev);
    344 		add_user_command (&ptr->type_commands,"allocate","Allocates the current inode",type_ext2_inode_bitmap___allocate);
    345 		add_user_command (&ptr->type_commands,"deallocate","Deallocates the current inode",type_ext2_inode_bitmap___deallocate);
    346 	}
    347 
    348 }
    349 
    350 void add_user_command (struct struct_commands *ptr,char *name,char *description,PF callback)
    351 
    352 {
    353 	int num;
    354 
    355 	num=ptr->last_command;
    356 	if (num+1==MAX_COMMANDS_NUM) {
    357 		printf ("Internal Error - Can't add command %s\n",name);
    358 		return;
    359 	}
    360 
    361 	ptr->last_command=++num;
    362 
    363 	ptr->names [num]=(char *) malloc (strlen (name)+1);
    364 	strcpy (ptr->names [num],name);
    365 
    366 	if (*description!=0) {
    367 		ptr->descriptions [num]=(char *) malloc (strlen (description)+1);
    368 		strcpy (ptr->descriptions [num],description);
    369 	}
    370 
    371 	ptr->callback [num]=callback;
    372 }
    373 
    374 int set_file_system_info (void)
    375 
    376 {
    377 	int ext2_detected=0;
    378 	struct ext2_super_block *sb;
    379 
    380 	file_system_info.super_block_offset=1024;
    381 	file_system_info.file_system_size=DefaultTotalBlocks*DefaultBlockSize;
    382 
    383 	low_read ((char *) &file_system_info.super_block,sizeof (struct ext2_super_block),file_system_info.super_block_offset);
    384 
    385 	sb=&file_system_info.super_block;
    386 
    387 	if (sb->s_magic == EXT2_SUPER_MAGIC)
    388 		ext2_detected=1;
    389 
    390 	if (ext2_detected)
    391 		wprintw (command_win,"Detected extended 2 file system on device %s\n",device_name);
    392 	else
    393 		wprintw (command_win,"Warning - Extended 2 filesystem not detected on device %s\n",device_name);
    394 
    395 	if (!ext2_detected && !ForceExt2)
    396 		wprintw (command_win,"You may wish to use the configuration option ForceExt2 on\n");
    397 
    398 	if (ForceExt2 && !ext2_detected)
    399 		wprintw (command_win,"Forcing extended 2 filesystem\n");
    400 
    401 	if (ForceDefault || !ext2_detected)
    402 		wprintw (command_win,"Forcing default parameters\n");
    403 
    404 	refresh_command_win ();
    405 
    406 	if (ext2_detected || ForceExt2) {
    407 		add_ext2_general_commands ();
    408 		if (!set_struct_descriptors (Ext2Descriptors))
    409 			return (0);
    410 	}
    411 
    412 	if (!ForceDefault && ext2_detected) {
    413 
    414 		file_system_info.block_size=EXT2_MIN_BLOCK_SIZE << sb->s_log_block_size;
    415 		if (file_system_info.block_size == EXT2_MIN_BLOCK_SIZE)
    416 			file_system_info.first_group_desc_offset=2*EXT2_MIN_BLOCK_SIZE;
    417 		else
    418 			file_system_info.first_group_desc_offset=file_system_info.block_size;
    419 		file_system_info.groups_count = ext2fs_div64_ceil(ext2fs_blocks_count(sb),
    420 						 sb->s_blocks_per_group);
    421 
    422 		file_system_info.inodes_per_block=file_system_info.block_size/sizeof (struct ext2_inode);
    423 		file_system_info.blocks_per_group=sb->s_inodes_per_group/file_system_info.inodes_per_block;
    424 		file_system_info.no_blocks_in_group=sb->s_blocks_per_group;
    425 		file_system_info.file_system_size=(ext2fs_blocks_count(sb)-1)*file_system_info.block_size;
    426 	}
    427 
    428 	else {
    429 		file_system_info.file_system_size=DefaultTotalBlocks*DefaultBlockSize;
    430 		file_system_info.block_size=DefaultBlockSize;
    431 		file_system_info.no_blocks_in_group=DefaultBlocksInGroup;
    432 	}
    433 
    434 	if (file_system_info.file_system_size > 2147483647) {
    435 		wprintw (command_win,"Sorry, filesystems bigger than 2 GB are currently not supported\n");
    436 		return (0);
    437 	}
    438 	return (1);
    439 }
    440 
    441 void init_readline (void)
    442 
    443 {
    444 #ifdef HAVE_READLINE
    445 	rl_completion_entry_function=(Function *) complete_command;
    446 #endif
    447 }
    448 
    449 void init_signals (void)
    450 
    451 {
    452 	signal (SIGWINCH, signal_SIGWINCH_handler);	/* Catch SIGWINCH */
    453 	signal (SIGTERM, signal_SIGTERM_handler);
    454 	signal (SIGSEGV, signal_SIGSEGV_handler);
    455 
    456 }
    457 
    458 void signal_SIGWINCH_handler (int sig_num)
    459 
    460 {
    461 	redraw_request=1;	/* We will handle it in main.c */
    462 
    463 	/* Reset signal handler */
    464 	signal (SIGWINCH, signal_SIGWINCH_handler);
    465 
    466 }
    467 
    468 void signal_SIGTERM_handler (int sig_num)
    469 
    470 {
    471 	prepare_to_close ();
    472 	printf ("Terminated due to signal %d\n",sig_num);
    473 	exit (1);
    474 }
    475 
    476 void signal_SIGSEGV_handler (int sig_num)
    477 
    478 {
    479 	prepare_to_close ();
    480 	printf ("Killed by signal %d!\n",sig_num);
    481 	exit (1);
    482 }
    483 
    484 int process_configuration_file (void)
    485 
    486 {
    487 	char buffer [300];
    488 	char option [80],value [80];
    489 	FILE *fp;
    490 
    491 	strcpy (buffer, ROOT_SYSCONFDIR);
    492 	strcat (buffer,"/ext2ed.conf");
    493 
    494 	if ((fp=fopen (buffer,"rt"))==NULL) {
    495 		fprintf (stderr,"Error - Unable to open configuration file %s\n",buffer);
    496 		return (0);
    497 	}
    498 
    499 	while (get_next_option (fp,option,value)) {
    500 		if (strcasecmp (option,"Ext2Descriptors")==0) {
    501 			strcpy (Ext2Descriptors,value);
    502 		}
    503 
    504 		else if (strcasecmp (option,"AlternateDescriptors")==0) {
    505 			strcpy (AlternateDescriptors,value);
    506 		}
    507 
    508 		else if (strcasecmp (option,"LogFile")==0) {
    509 			strcpy (LogFile,value);
    510 		}
    511 
    512 		else if (strcasecmp (option,"LogChanges")==0) {
    513 			if (strcasecmp (value,"on")==0)
    514 				LogChanges = 1;
    515 			else if (strcasecmp (value,"off")==0)
    516 				LogChanges = 0;
    517 			else {
    518 				fprintf (stderr,"Error - Illegal value: %s %s\n",option,value);
    519 				fclose (fp);return (0);
    520 			}
    521 		}
    522 
    523 		else if (strcasecmp (option,"AllowChanges")==0) {
    524 			if (strcasecmp (value,"on")==0)
    525 				AllowChanges = 1;
    526 			else if (strcasecmp (value,"off")==0)
    527 				AllowChanges = 0;
    528 			else {
    529 				fprintf (stderr,"Error - Illegal value: %s %s\n",option,value);
    530 				fclose (fp);return (0);
    531 			}
    532 		}
    533 
    534 		else if (strcasecmp (option,"AllowMountedRead")==0) {
    535 			if (strcasecmp (value,"on")==0)
    536 				AllowMountedRead = 1;
    537 			else if (strcasecmp (value,"off")==0)
    538 				AllowMountedRead = 0;
    539 			else {
    540 				fprintf (stderr,"Error - Illegal value: %s %s\n",option,value);
    541 				fclose (fp);return (0);
    542 			}
    543 		}
    544 
    545 		else if (strcasecmp (option,"ForceExt2")==0) {
    546 			if (strcasecmp (value,"on")==0)
    547 				ForceExt2 = 1;
    548 			else if (strcasecmp (value,"off")==0)
    549 				ForceExt2 = 0;
    550 			else {
    551 				fprintf (stderr,"Error - Illegal value: %s %s\n",option,value);
    552 				fclose (fp);return (0);
    553 			}
    554 		}
    555 
    556 		else if (strcasecmp (option,"DefaultBlockSize")==0) {
    557 			DefaultBlockSize = atoi (value);
    558 		}
    559 
    560 		else if (strcasecmp (option,"DefaultTotalBlocks")==0) {
    561 			DefaultTotalBlocks = strtoul (value,NULL,10);
    562 		}
    563 
    564 		else if (strcasecmp (option,"DefaultBlocksInGroup")==0) {
    565 			DefaultBlocksInGroup = strtoul (value,NULL,10);
    566 		}
    567 
    568 		else if (strcasecmp (option,"ForceDefault")==0) {
    569 			if (strcasecmp (value,"on")==0)
    570 				ForceDefault = 1;
    571 			else if (strcasecmp (value,"off")==0)
    572 				ForceDefault = 0;
    573 			else {
    574 				fprintf (stderr,"Error - Illegal value: %s %s\n",option,value);
    575 				fclose (fp);return (0);
    576 			}
    577 		}
    578 
    579 		else {
    580 			fprintf (stderr,"Error - Unknown option: %s\n",option);
    581 			fclose (fp);return (0);
    582 		}
    583 	}
    584 
    585 	printf ("Configuration completed\n");
    586 	fclose (fp);
    587 	return (1);
    588 }
    589 
    590 int get_next_option (FILE *fp,char *option,char *value)
    591 
    592 {
    593 	char *ptr;
    594 	char buffer [600];
    595 
    596 	if (feof (fp)) return (0);
    597 	do{
    598 		if (feof (fp)) return (0);
    599 		fgets (buffer,500,fp);
    600 	} while (buffer [0]=='#' || buffer [0]=='\n');
    601 
    602 	ptr=parse_word (buffer,option);
    603 	ptr=parse_word (ptr,value);
    604 	return (1);
    605 }
    606 
    607 void check_mounted (char *name)
    608 
    609 {
    610 	FILE *fp;
    611 	char *ptr;
    612 	char current_line [500],current_word [200];
    613 
    614 	mounted=0;
    615 
    616 	if ( (fp=fopen ("/etc/mtab","rt"))==NULL) {
    617 		wprintw (command_win,"Error - Failed to open /etc/mtab. Assuming filesystem is mounted.\n");
    618 		refresh_command_win ();mounted=1;return;
    619 	};
    620 
    621 	while (!feof (fp)) {
    622 		fgets (current_line,500,fp);
    623 		if (feof (fp)) break;
    624 		ptr=parse_word (current_line,current_word);
    625 		if (strcasecmp (current_word,name)==0) {
    626 			mounted=1;fclose (fp);return;
    627 		}
    628 	};
    629 
    630 	fclose (fp);
    631 
    632 	return;
    633 }
    634